18652: Improves performance by reducing lock contention via immediate return values, fixes rare bugs

src/Amalgam/Parser.cpp

@@ -199,7 +199,7 @@ EvaluableNode *Parser::GetCodeForPathFromAToB(UnparseData &upd, EvaluableNode *a
 
 	//build code to get the reference
 	EvaluableNode *refpath = upd.enm->AllocNode(ENT_TARGET);
-	refpath->AppendOrderedChildNode(upd.enm->AllocNode(a_ancestor_depth));
+	refpath->AppendOrderedChildNode(upd.enm->AllocNode(static_cast<double>(a_ancestor_depth)));
 
 	//combine together
 	while(b_path_nodes.size() > 0)

src/Amalgam/entity/Entity.cpp

@@ -887,7 +887,7 @@ void Entity::SetRoot(EvaluableNode *_code, bool allocated_with_entity_enm, Evalu
 	else
 	{
 		auto code_copy = evaluableNodeManager.DeepAllocCopy(_code, metadata_modifier);
-		evaluableNodeManager.SetRootNode(code_copy.reference);
+		evaluableNodeManager.SetRootNode(code_copy);
 	}
 
 	//keep reference for current root
@@ -919,7 +919,7 @@ void Entity::SetRoot(EvaluableNode *_code, bool allocated_with_entity_enm, Evalu
 void Entity::SetRoot(std::string &code_string, EvaluableNodeManager::EvaluableNodeMetadataModifier metadata_modifier, std::vector<EntityWriteListener *> *write_listeners)
 {
 	EvaluableNodeReference new_code = Parser::Parse(code_string, &evaluableNodeManager);
-	SetRoot(new_code.reference, true, metadata_modifier, write_listeners);
+	SetRoot(new_code, true, metadata_modifier, write_listeners);
 }
 
 void Entity::AccumRoot(EvaluableNodeReference accum_code, bool allocated_with_entity_enm, EvaluableNodeManager::EvaluableNodeMetadataModifier metadata_modifier, std::vector<EntityWriteListener *> *write_listeners)

src/Amalgam/entity/EntityManipulation.cpp

@@ -20,8 +20,8 @@ Entity *EntityManipulation::EntitiesMergeMethod::MergeValues(Entity *a, Entity *
 		merged_entity->SetRandomStream(b->GetRandomStream());
 
 	//merge entitys' code
-	EvaluableNode *code_a = (a != nullptr ? a->GetRoot().reference : nullptr);
-	EvaluableNode *code_b = (b != nullptr ? b->GetRoot().reference : nullptr);
+	EvaluableNodeReference code_a = (a != nullptr ? a->GetRoot() : EvaluableNodeReference::Null());
+	EvaluableNodeReference code_b = (b != nullptr ? b->GetRoot() : EvaluableNodeReference::Null());
 
 	EvaluableNodeTreeManipulation::NodesMergeMethod mm(&merged_entity->evaluableNodeManager, keepAllOfBoth, true);
 	EvaluableNode *result = mm.MergeValues(code_a, code_b);
@@ -44,8 +44,8 @@ Entity *EntityManipulation::EntitiesMergeForDifferenceMethod::MergeValues(Entity
 	Entity *result = new Entity();
 
 	//compare entitys' code
-	EvaluableNode *code_a = (a != nullptr ? a->GetRoot().reference : nullptr);
-	EvaluableNode *code_b = (b != nullptr ? b->GetRoot().reference : nullptr);
+	EvaluableNodeReference code_a = (a != nullptr ? a->GetRoot() : EvaluableNodeReference::Null());
+	EvaluableNodeReference code_b = (b != nullptr ? b->GetRoot() : EvaluableNodeReference::Null());
 
 	if(a != nullptr)
 		aEntitiesIncludedFromB[b] = a;
@@ -125,8 +125,8 @@ Entity *EntityManipulation::EntitiesMixMethod::MergeValues(Entity *a, Entity *b,
 		merged_entity->SetRandomStream(b->GetRandomStream());
 
 	//merge entity's code
-	EvaluableNode *code_a = (a != nullptr ? a->GetRoot().reference : nullptr);
-	EvaluableNode *code_b = (b != nullptr ? b->GetRoot().reference : nullptr);
+	EvaluableNodeReference code_a = (a != nullptr ? a->GetRoot() : EvaluableNodeReference::Null());
+	EvaluableNodeReference code_b = (b != nullptr ? b->GetRoot() : EvaluableNodeReference::Null());
 
 	EvaluableNodeTreeManipulation::NodesMixMethod mm(interpreter->randomStream.CreateOtherStreamViaRand(),
 		&merged_entity->evaluableNodeManager, fractionA, fractionB, similarMixChance);

src/Amalgam/evaluablenode/EvaluableNode.h

@@ -1032,6 +1032,15 @@ class EvaluableNodeImmediateValueWithType
 		: nodeType(ENIVT_NULL)
 	{	}
 
+	__forceinline EvaluableNodeImmediateValueWithType(bool value)
+	{
+		nodeType = ENIVT_NUMBER;
+		if(value)
+			nodeValue.number = 1.0;
+		else
+			nodeValue.number = 0.0;
+	}
+
 	constexpr EvaluableNodeImmediateValueWithType(double number)
 		: nodeType(ENIVT_NUMBER), nodeValue(number)
 	{	}
@@ -1091,6 +1100,125 @@ class EvaluableNodeImmediateValueWithType
 		nodeValue = EvaluableNodeImmediateValue(en);
 	}
 
+	bool GetValueAsBoolean()
+	{
+		if(nodeType == ENIVT_NUMBER)
+		{
+			if(nodeValue.number == 0.0)
+				return false;
+			if(FastIsNaN(nodeValue.number))
+				return false;
+			return true;
+		}
+
+		if(nodeType == ENIVT_STRING_ID)
+		{
+			if(nodeValue.stringID <= StringInternPool::EMPTY_STRING_ID)
+				return false;
+			return true;
+		}
+
+		if(nodeType == ENIVT_CODE)
+			return EvaluableNode::IsTrue(nodeValue.code);
+
+		//nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX
+		return false;
+	}
+
+	double GetValueAsNumber(double value_if_null = std::numeric_limits<double>::quiet_NaN())
+	{
+		if(nodeType == ENIVT_NUMBER)
+			return nodeValue.number;
+
+		if(nodeType == ENIVT_STRING_ID)
+		{
+			if(nodeValue.stringID == string_intern_pool.NOT_A_STRING_ID)
+				return value_if_null;
+
+			const auto &str = string_intern_pool.GetStringFromID(nodeValue.stringID);
+			auto [value, success] = Platform_StringToNumber(str);
+			if(success)
+				return value;
+			return value_if_null;
+		}
+
+		if(nodeType == ENIVT_CODE)
+			return EvaluableNode::ToNumber(nodeValue.code);
+
+		//nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX
+		return value_if_null;
+	}
+
+	std::pair<bool, std::string> GetValueAsString()
+	{
+		if(nodeType == ENIVT_NUMBER)
+		{
+			if(FastIsNaN(nodeValue.number))
+				return std::make_pair(false, "");
+
+			return std::make_pair(true, EvaluableNode::NumberToString(nodeValue.number));
+		}
+
+		if(nodeType == ENIVT_STRING_ID)
+		{
+			if(nodeValue.stringID == string_intern_pool.NOT_A_STRING_ID)
+				return std::make_pair(false, "");
+
+			const auto &str = string_intern_pool.GetStringFromID(nodeValue.stringID);
+			return std::make_pair(true, str);
+		}
+
+		if(nodeType == ENIVT_CODE)
+			return std::make_pair(true, EvaluableNode::ToStringPreservingOpcodeType(nodeValue.code));
+
+		//nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX
+		return std::make_pair(false, "");
+	}
+
+	StringInternPool::StringID GetValueAsStringIDIfExists()
+	{
+		if(nodeType == ENIVT_NUMBER)
+		{
+			if(FastIsNaN(nodeValue.number))
+				return StringInternPool::NOT_A_STRING_ID;
+
+			const std::string str_value = EvaluableNode::NumberToString(nodeValue.number);
+			//will return empty string if not found
+			return string_intern_pool.GetIDFromString(str_value);
+		}
+
+		if(nodeType == ENIVT_STRING_ID)
+			return nodeValue.stringID;
+
+		if(nodeType == ENIVT_CODE)
+			return EvaluableNode::ToStringIDIfExists(nodeValue.code);
+
+		//nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX
+		return string_intern_pool.NOT_A_STRING_ID;
+	}
+
+	StringInternPool::StringID GetValueAsStringIDWithReference()
+	{
+		if(nodeType == ENIVT_NUMBER)
+		{
+			if(FastIsNaN(nodeValue.number))
+				return StringInternPool::NOT_A_STRING_ID;
+
+			const std::string str_value = EvaluableNode::NumberToString(nodeValue.number);
+			//will return empty string if not found
+			return string_intern_pool.CreateStringReference(str_value);
+		}
+
+		if(nodeType == ENIVT_STRING_ID)
+			return string_intern_pool.CreateStringReference(nodeValue.stringID);
+
+		if(nodeType == ENIVT_CODE)
+			return EvaluableNode::ToStringIDWithReference(nodeValue.code);
+
+		//nodeType is one of ENIVT_NOT_EXIST, ENIVT_NULL, ENIVT_NUMBER_INDIRECTION_INDEX
+		return string_intern_pool.NOT_A_STRING_ID;
+	}
+
 	static inline bool AreEqual(EvaluableNodeImmediateValueWithType &a, EvaluableNodeImmediateValueWithType &b)
 	{
 		return EvaluableNodeImmediateValue::AreEqual(a.nodeType, a.nodeValue, b.nodeType, b.nodeValue);