Compiled shared metacache

Author: AlexPeshkoff

src/dsql/DdlNodes.epp

@@ -34,6 +34,7 @@
 #include "../jrd/obj.h"
 #include "../jrd/ods.h"
 #include "../jrd/tra.h"
+#include "../jrd/met.h"
 #include "../common/os/path_utils.h"
 #include "../jrd/CryptoManager.h"
 #include "../jrd/IntlManager.h"
@@ -8417,7 +8418,7 @@ void DropRelationNode::checkPermission(thread_db* tdbb, jrd_tra* transaction)
 void DropRelationNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch,
 	jrd_tra* transaction)
 {
-	jrd_rel* rel_drop = MetadataCache::lookup_relation(tdbb, name);
+	HazardPtr<jrd_rel> rel_drop = MetadataCache::lookup_relation(tdbb, name);
 	if (rel_drop)
 		MET_scan_relation(tdbb, rel_drop);
 

src/dsql/ExprNodes.cpp

@@ -31,6 +31,7 @@
 #include "../jrd/align.h"
 #include "firebird/impl/blr.h"
 #include "../jrd/tra.h"
+#include "../jrd/met.h"
 #include "../jrd/Function.h"
 #include "../jrd/SysFunction.h"
 #include "../jrd/recsrc/RecordSource.h"
@@ -4864,7 +4865,7 @@ DmlNode* DefaultNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch*
 	if (csb->csb_g_flags & csb_get_dependencies)
 	{
 		CompilerScratch::Dependency dependency(obj_relation);
-		dependency.relation = MetadataCache::lookup_relation(tdbb, relationName);
+		dependency.relation = MetadataCache::lookup_relation(tdbb, relationName).unsafePointer();
 		dependency.subName = FB_NEW_POOL(pool) MetaName(fieldName);
 		csb->csb_dependencies.push(dependency);
 	}
@@ -4873,11 +4874,11 @@ DmlNode* DefaultNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch*
 
 	while (true)
 	{
-		jrd_rel* relation = MetadataCache::lookup_relation(tdbb, relationName);
+		HazardPtr<jrd_rel> relation = MetadataCache::lookup_relation(tdbb, relationName);
 
 		if (relation && relation->rel_fields)
 		{
-			int fieldId = MET_lookup_field(tdbb, relation, fieldName);
+			int fieldId = MET_lookup_field(tdbb, relation.unsafePointer(), fieldName);
 
 			if (fieldId >= 0)
 			{
@@ -5826,7 +5827,7 @@ DmlNode* FieldNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* cs
 				(procedure->flags & Routine::FLAG_BEING_SCANNED) ||
 				(procedure->flags & Routine::FLAG_BEING_ALTERED)))
 		{
-			const jrd_prc* scan_proc = MetadataCache::findProcedure(tdbb, procedure->getId(), false, 0);
+			HazardPtr<jrd_prc> scan_proc = MetadataCache::findProcedure(tdbb, procedure->getId(), false, 0);
 
 			if (scan_proc != procedure)
 				procedure = NULL;
@@ -12759,11 +12760,14 @@ DmlNode* UdfCallNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch*
 		}
 	}
 
-	Function* function = node->function;
-
-	if (!function)
-		function = node->function = Function::lookup(tdbb, name, false);
+	HazardPtr<Function> func;
+	if (!node->function)
+	{
+		func = Function::lookup(tdbb, name, false);			// !!!!!!!!!!!!!!!!!!! resource
+		node->function = func.unsafePointer();
+	}
 
+	Function* function = node->function;
 	if (function)
 	{
 		if (function->isImplemented() && !function->isDefined())
@@ -12881,7 +12885,13 @@ ValueExprNode* UdfCallNode::copy(thread_db* tdbb, NodeCopier& copier) const
 {
 	UdfCallNode* node = FB_NEW_POOL(*tdbb->getDefaultPool()) UdfCallNode(*tdbb->getDefaultPool(), name);
 	node->args = copier.copy(tdbb, args);
-	node->function = isSubRoutine ? function : Function::lookup(tdbb, name, false);
+	if (isSubRoutine)
+		node->function = function;
+	else
+	{
+		HazardPtr<Function> func = Function::lookup(tdbb, name, false);	// !!!!!!!!!!!!!!!!!!! resource
+		node->function = func.unsafePointer();
+	}
 	return node;
 }
 

src/dsql/StmtNodes.cpp

@@ -32,6 +32,7 @@
 #include "../jrd/ids.h"
 #include "../jrd/ini.h"
 #include "../jrd/tra.h"
+#include "../jrd/met.h"
 #include "../jrd/Coercion.h"
 #include "../jrd/Function.h"
 #include "../jrd/Optimizer.h"
@@ -107,7 +108,7 @@ static void pass1Validations(thread_db* tdbb, CompilerScratch* csb, Array<Valida
 static ForNode* pass2FindForNode(StmtNode* node, StreamType stream);
 static void postTriggerAccess(CompilerScratch* csb, jrd_rel* ownerRelation,
 	ExternalAccess::exa_act operation, jrd_rel* view);
-static void preModifyEraseTriggers(thread_db* tdbb, TrigVector** trigs,
+static void preModifyEraseTriggers(thread_db* tdbb, TrigVectorPtr* trigs,
 	StmtNode::WhichTrigger whichTrig, record_param* rpb, record_param* rec, TriggerAction op);
 static void preprocessAssignments(thread_db* tdbb, CompilerScratch* csb,
 	StreamType stream, CompoundStmtNode* compoundNode, const Nullable<OverrideClause>* insertOverride);
@@ -2917,13 +2918,14 @@ DmlNode* ExecProcedureNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScr
 {
 	SET_TDBB(tdbb);
 
+	HazardPtr<jrd_prc> proc;
 	jrd_prc* procedure = NULL;
 	QualifiedName name;
 
 	if (blrOp == blr_exec_pid)
 	{
 		const USHORT pid = csb->csb_blr_reader.getWord();
-		if (!(procedure = MetadataCache::lookup_procedure_id(tdbb, pid, false, false, 0)))
+		if (!(proc = MetadataCache::lookup_procedure_id(tdbb, pid, false, false, 0)))
 			name.identifier.printf("id %d", pid);
 	}
 	else
@@ -2944,9 +2946,12 @@ DmlNode* ExecProcedureNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScr
 			}
 		}
 		else
-			procedure = MetadataCache::lookup_procedure(tdbb, name, false);
+			proc = MetadataCache::lookup_procedure(tdbb, name, false);
 	}
 
+	if (proc && !procedure)
+		procedure = proc.unsafePointer();
+
 	if (!procedure)
 		PAR_error(csb, Arg::Gds(isc_prcnotdef) << Arg::Str(name.toString()));
 
@@ -10531,7 +10536,9 @@ static RelationSourceNode* pass1Update(thread_db* tdbb, CompilerScratch* csb, jr
 
 		for (FB_SIZE_T i = 0; i < trigger->getCount(); i++)
 		{
-			if (!(*trigger)[i].sysTrigger)
+			HazardPtr<Trigger> tr;
+			trigger->load(i, tr);
+			if (!tr->sysTrigger)
 			{
 				userTriggers = true;
 				break;
@@ -10633,7 +10640,7 @@ static void postTriggerAccess(CompilerScratch* csb, jrd_rel* ownerRelation,
 }
 
 // Perform operation's pre-triggers, storing active rpb in chain.
-static void preModifyEraseTriggers(thread_db* tdbb, TrigVector** trigs,
+static void preModifyEraseTriggers(thread_db* tdbb, TrigVectorPtr* trigs,
 	StmtNode::WhichTrigger whichTrig, record_param* rpb, record_param* rec, TriggerAction op)
 {
 	if (!tdbb->getTransaction()->tra_rpblist)
@@ -10715,7 +10722,7 @@ static void preprocessAssignments(thread_db* tdbb, CompilerScratch* csb,
 					}
 					else if (relation->rel_view_rse && fld->fld_source_rel_field.first.hasData())
 					{
-						relation = MetadataCache::lookup_relation(tdbb, fld->fld_source_rel_field.first);
+						relation = MetadataCache::lookup_relation(tdbb, fld->fld_source_rel_field.first).unsafePointer();
 
 						fb_assert(relation);
 						if (!relation)

src/dsql/metd.epp

@@ -40,6 +40,7 @@
 #include "../jrd/intl.h"
 #include "../jrd/irq.h"
 #include "../jrd/tra.h"
+#include "../jrd/met.h"
 #include "../dsql/ExprNodes.h"
 #include "../dsql/ddl_proto.h"
 #include "../dsql/metd_proto.h"

src/jrd/HazardPtr.cpp

@@ -37,38 +37,13 @@ using namespace Firebird;
 HazardObject::~HazardObject()
 { }
 
-int HazardObject::release(thread_db* tdbb)
+int HazardObject::delayedDelete(thread_db* tdbb)
 {
 	HazardDelayedDelete& dd = tdbb->getAttachment()->att_delayed_delete;
 	dd.delayedDelete(this);
 	return 0;
 }
 
-RefHazardObject::~RefHazardObject()
-{
-	fb_assert(counter == 0);
-}
-
-int RefHazardObject::release(thread_db* tdbb)
-{
-	fb_assert(counter > 0);
-	if (--counter == 0)
-	{
-		HazardObject::release(tdbb);
-		return 0;
-	}
-
-	return 1;
-}
-
-void RefHazardObject::addRef(thread_db*)
-{
-	fb_assert(counter >= 0);
-	if (counter < 1)
-		fatal_exception::raise("Attempt to reuse released object failed");		// need special error handling? !!!!!!!!!!!
-	++counter;
-}
-
 HazardDelayedDelete* HazardBase::getHazardDelayed(thread_db* tdbb)
 {
 	if (!tdbb)

src/jrd/HazardPtr.h

@@ -48,22 +48,7 @@ namespace Jrd {
 	protected:
 		virtual ~HazardObject();
 	public:
-		virtual int release(thread_db* tdbb);
-	};
-
-	class RefHazardObject : public HazardObject
-	{
-	public:
-		RefHazardObject()
-			: counter(1)		// non-std reference counted implementation
-		{ }
-
-		~RefHazardObject() override;
-		int release(thread_db* tdbb) override;
-		virtual void addRef(thread_db* tdbb);
-
-	private:
-		std::atomic<int> counter;
+		int delayedDelete(thread_db* tdbb);
 	};
 
 	class HazardDelayedDelete : public Firebird::PermanentStorage
@@ -280,6 +265,11 @@ namespace Jrd {
 			return hazardPointer == v;
 		}
 
+		bool operator!=(const T* v) const
+		{
+			return hazardPointer != v;
+		}
+
 		operator bool() const
 		{
 			return hazardPointer != nullptr;
@@ -434,8 +424,8 @@ namespace Jrd {
 				if (!m_objects[id >> SUBARRAY_SHIFT].compare_exchange_strong(sub, newSub,
 					std::memory_order_release, std::memory_order_acquire))
 				{
-					// someone else already installed this subarray
-					// ok for us - just free unneeded memory
+					// Someone else already installed this subarray.
+					// OK for us - just free unneeded memory.
 					delete[] newSub;
 				}
 				else
@@ -448,7 +438,7 @@ namespace Jrd {
 				std::memory_order_release, std::memory_order_acquire));	// empty body
 
 			if (oldVal)
-				oldVal->release(tdbb);		// delayedDelete
+				oldVal->delayedDelete(tdbb);
 
 			return HazardPtr<Object>(tdbb, *sub);
 		}

src/jrd/RecordSourceNodes.h

@@ -359,7 +359,7 @@ class RelationSourceNode : public TypedNode<RecordSourceNode, RecordSourceNode::
 		: TypedNode<RecordSourceNode, RecordSourceNode::TYPE_RELATION>(pool),
 		  dsqlName(pool, aDsqlName),
 		  alias(pool),
-		  relation(NULL),
+		  //relation(NULL),
 		  view(NULL),
 		  context(0)
 	{

src/jrd/Relation.cpp

@@ -601,3 +601,13 @@ void RelationPages::free(RelationPages*& nextFree)
 	dpMap.clear();
 	dpMapMark = 0;
 }
+
+
+/// TrigVector
+
+HazardPtr<Trigger> TrigVector::add(thread_db* tdbb, Trigger* trig)
+{
+	FB_SIZE_T id = addCount.fetch_add(1);
+	return store(tdbb, id, trig);
+}
+

src/jrd/Relation.h

@@ -79,7 +79,7 @@ class Trigger : public HazardObject
 	bool isActive() const;
 
 	void compile(thread_db*);				// Ensure that trigger is compiled
-	int release(thread_db*) override;		// Try to free trigger request
+	int release(thread_db*);				// Try to free trigger request
 
 	explicit Trigger(MemoryPool& p)
 		: blr(p),
@@ -109,10 +109,10 @@ class TrigVector : public HazardArray<Trigger>
 
 	TrigVector()
 		: HazardArray<Trigger>(Firebird::AutoStorage::getAutoMemoryPool()),
-		  useCount(0)
+		  useCount(0), addCount(0)
 	{ }
 
-	HazardPtr<Trigger> add(Trigger*);
+	HazardPtr<Trigger> add(thread_db* tdbb, Trigger*);
 
 	void addRef()
 	{
@@ -138,11 +138,12 @@ class TrigVector : public HazardArray<Trigger>
 
 	~TrigVector()
 	{
-		fb_assert(useCount.value() == 0);
+		fb_assert(useCount.load() == 0);
 	}
 
 private:
-	Firebird::AtomicCounter useCount;
+	std::atomic<int> useCount;
+	std::atomic<FB_SIZE_T> addCount;
 };
 
 typedef std::atomic<TrigVector*> TrigVectorPtr;

src/jrd/Routine.h

@@ -41,7 +41,7 @@ namespace Jrd
 	class Parameter;
 	class UserId;
 
-	class Routine : public Firebird::PermanentStorage, public RefHazardObject
+	class Routine : public Firebird::PermanentStorage, public HazardObject
 	{
 	protected:
 		explicit Routine(MemoryPool& p)
@@ -154,10 +154,12 @@ namespace Jrd
 		{
 		}
 
-		int release(thread_db* tdbb) override;
+		int release(thread_db* tdbb);
 		void releaseStatement(thread_db* tdbb);
 		void remove(thread_db* tdbb);
-		virtual void releaseExternal() {};
+		virtual void releaseExternal()
+		{
+		}
 
 	public:
 		virtual int getObjectType() const = 0;