500 optimize task dimensioning for table creation rules

src/Learning/KWDRRuleLibrary/KWDRBuildRelation.cpp

@@ -11,6 +11,7 @@ void KWDRRegisterBuildRelationRules()
 	KWDerivationRule::RegisterDerivationRule(new KWDRBuildEntityView);
 	KWDerivationRule::RegisterDerivationRule(new KWDRBuildEntityAdvancedView);
 	KWDerivationRule::RegisterDerivationRule(new KWDRBuildEntity);
+	KWDerivationRule::RegisterDerivationRule(new KWDRBuildDummyTable);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
@@ -256,3 +257,81 @@ boolean KWDRBuildEntity::IsViewModeActivated() const
 {
 	return false;
 }
+
+//////////////////////////////////////////////////////////////////////////////////////
+// Classe KWDRBuildDummyTable
+
+KWDRBuildDummyTable::KWDRBuildDummyTable()
+{
+	SetName("BuildDummyTable");
+	SetLabel("Build dummy table");
+	SetType(KWType::ObjectArray);
+
+	// Un operande, pour specifier le nombre d'instance a cree
+	SetOperandNumber(1);
+	GetFirstOperand()->SetType(KWType::Continuous);
+
+	// Variables en entree: une pour le nombre d'instance a cree,
+	// et un nombre variable d'operande pour alimenter les variables en sortie
+	SetOperandNumber(2);
+	GetFirstOperand()->SetType(KWType::Continuous);
+	GetSecondOperand()->SetType(KWType::Unknown);
+	SetVariableOperandNumber(true);
+
+	// Variables en sortie: nombre variable d'operandes pour alimenter la table en sortie
+	SetOutputOperandNumber(1);
+	GetOutputOperandAt(0)->SetType(KWType::Unknown);
+	SetVariableOutputOperandNumber(true);
+}
+
+KWDRBuildDummyTable::~KWDRBuildDummyTable() {}
+
+KWDerivationRule* KWDRBuildDummyTable::Create() const
+{
+	return new KWDRBuildDummyTable;
+}
+
+ObjectArray* KWDRBuildDummyTable::ComputeObjectArrayResult(const KWObject* kwoObject,
+							   const KWLoadIndex liAttributeLoadIndex) const
+{
+	const int nMaxTableSize = 1000000;
+	Continuous cTableSize;
+	int nTableSize;
+	KWObject* kwoTargetContainedObject;
+	int nObject;
+
+	require(IsCompiled());
+
+	// Calcul du resultat
+	oaResult.SetSize(0);
+
+	// Taille de la table a cree
+	cTableSize = GetFirstOperand()->GetContinuousValue(kwoObject);
+	nTableSize = 0;
+	if (cTableSize != KWContinuous::GetMissingValue())
+	{
+		if (cTableSize < 0)
+			nTableSize = 0;
+		else if (cTableSize > nMaxTableSize)
+			nTableSize = nMaxTableSize;
+		else
+			nTableSize = int(floor(cTableSize + 0.5));
+	}
+
+	// Creation des instances
+	oaResult.SetSize(nTableSize);
+	for (nObject = 0; nObject < nTableSize; nObject++)
+	{
+		kwoTargetContainedObject = NewTargetObject(kwoObject, liAttributeLoadIndex);
+
+		// Alimentation de type calcul pour les operandes en entree correspondant
+		FillComputeModeTargetAttributesForVariableOperandNumber(kwoObject, kwoTargetContainedObject);
+		oaResult.SetAt(nObject, kwoTargetContainedObject);
+	}
+	return &oaResult;
+}
+
+boolean KWDRBuildDummyTable::IsViewModeActivated() const
+{
+	return false;
+}

src/Learning/KWDRRuleLibrary/KWDRBuildRelation.h

@@ -12,6 +12,7 @@ class KWDRBuildTableAdvancedView;
 class KWDRBuildEntityView;
 class KWDRBuildEntityAdvancedView;
 class KWDRBuildEntity;
+class KWDRBuildDummyTable;
 
 #include "KWDerivationRule.h"
 #include "KWRelationCreationRule.h"
@@ -118,6 +119,31 @@ class KWDRBuildEntity : public KWDRRelationCreationRule
 	///////////////////////////////////////////////////////
 	///// Implementation
 protected:
-	// Pas d'alimenattionde type vue
+	// Pas d'alimentation de type vue
+	boolean IsViewModeActivated() const override;
+};
+
+////////////////////////////////////////////////////////////////////////////
+// Classe KWDRBuildDummyTable
+// Creation d'une table factice avec autant d'instances que specifie en parametre
+// Regle interne, uniquement pour des raison de test de volumetrie
+class KWDRBuildDummyTable : public KWDRTableCreationRule
+{
+public:
+	// Constructeur
+	KWDRBuildDummyTable();
+	~KWDRBuildDummyTable();
+
+	// Creation
+	KWDerivationRule* Create() const override;
+
+	// Calcul de l'attribut derive
+	ObjectArray* ComputeObjectArrayResult(const KWObject* kwoObject,
+					      const KWLoadIndex liAttributeLoadIndex) const override;
+
+	///////////////////////////////////////////////////////
+	///// Implementation
+protected:
+	// Pas d'alimentation de type vue
 	boolean IsViewModeActivated() const override;
 };

src/Learning/KWData/KWClass.cpp

@@ -1897,6 +1897,98 @@ void KWClass::ExportKeyAttributeNames(StringVector* svAttributeNames) const
 	}
 }
 
+longint KWClass::GetEstimatedUsedMemoryPerObject() const
+{
+	const boolean bTrace = false;
+	int nObjectArrayLoadedValueNumber;
+	int nTextLoadedValueNumber;
+	int nDenseLoadedValueNumber;
+	int nSparseLoadedValueNumber;
+	int nSparseLoadedValueBlockNumber;
+	int nEstimatedValueNumber;
+	longint lObjectSize;
+	KWAttribute* attribute;
+	KWAttributeBlock* attributeBlock;
+	ObjectDictionary odEmpty;
+
+	// Initialisation des statistiques par type d'attribut
+	nTextLoadedValueNumber = 0;
+	nObjectArrayLoadedValueNumber = 0;
+	nDenseLoadedValueNumber = 0;
+	nSparseLoadedValueNumber = 0;
+	nSparseLoadedValueBlockNumber = 0;
+
+	// Calcul des nombres d'attributs charges en memoire dans la classe physique
+	// qui ne memorise que les attributs charges en memoire (natifs ou calcules)
+	// Dans le cas des blocs, on fait une estimation
+	attribute = GetHeadAttribute();
+	while (attribute != NULL)
+	{
+		// Cas des attributs denses
+		if (not attribute->IsInBlock())
+		{
+			if (attribute->GetLoaded())
+			{
+				if (attribute->GetType() == KWType::Text)
+					nTextLoadedValueNumber++;
+				else if (attribute->GetType() == KWType::ObjectArray)
+					nObjectArrayLoadedValueNumber++;
+				nDenseLoadedValueNumber++;
+			}
+		}
+		// Cas des attributs dans les blocs
+		else
+		{
+			// Dans ce cas, on se base sur une estimation heuristique du nombre de valeurs presentes
+			// en fonction de la taille globale du bloc (au plus une fois par bloc)
+			if (attribute->IsFirstInBlock())
+			{
+				attributeBlock = attribute->GetAttributeBlock();
+				if (attributeBlock->GetLoaded())
+				{
+					nEstimatedValueNumber =
+					    (int)ceil(KWAttributeBlock::GetEstimatedMeanValueNumber(
+							  attributeBlock->GetAttributeNumber()) *
+						      1.0 * attributeBlock->GetLoadedAttributeNumber() /
+						      attributeBlock->GetAttributeNumber());
+					nSparseLoadedValueNumber += nEstimatedValueNumber;
+					nSparseLoadedValueBlockNumber++;
+				}
+			}
+		}
+		GetNextAttribute(attribute);
+	}
+
+	// Estimation de la memoire necessaire pour stocker un objet
+	lObjectSize = sizeof(KWObject) + 2 * sizeof(void*);              // KWObject a vide
+	lObjectSize += nDenseLoadedValueNumber * sizeof(KWValue);        // Valeurs dense de l'objet
+	lObjectSize += (longint)nTextLoadedValueNumber * nTextValueSize; // Valeurs Text de l'objet
+	lObjectSize +=
+	    (longint)nObjectArrayLoadedValueNumber *
+	    (sizeof(ObjectArray) + sizeof(void*)); // Valeur ObjectArray de l'objet, avec un seul objet contenu
+	lObjectSize += (longint)nSparseLoadedValueNumber * (sizeof(int) + sizeof(KWValue)); // Valeurs sparse de l'objet
+	lObjectSize += (longint)nSparseLoadedValueBlockNumber * sizeof(KWSymbolValueBlock);
+	if (IsKeyLoaded())
+		lObjectSize += (longint)GetKeyAttributeNumber() *
+			       (Symbol::GetUsedMemoryPerSymbol() + nKeyFieldSize); // Taille des Symbol de la cle
+
+	// Affichage
+	if (bTrace)
+	{
+		cout << "GetEstimatedUsedMemoryPerObject"
+		     << "\n";
+		cout << "\tDictionary\t" << GetName() << "\n";
+		cout << "\tTextLoadedValueNumber\t" << nTextLoadedValueNumber << "\n";
+		cout << "\tObjectArrayLoadedValueNumber\t" << nObjectArrayLoadedValueNumber << "\n";
+		cout << "\tDenseLoadedValueNumber\t" << nDenseLoadedValueNumber << "\n";
+		cout << "\tSparseLoadedValueNumber\t" << nSparseLoadedValueNumber << "\n";
+		cout << "\tSparseLoadedValueBlockNumber\t" << nSparseLoadedValueBlockNumber << "\n";
+		cout << "\tsizeof(KWObject)\t" << sizeof(KWObject) << "\n";
+		cout << "\tObjectSize\t" << lObjectSize << "\n";
+	}
+	return lObjectSize;
+}
+
 void KWClass::CopyFrom(const KWClass* aSource)
 {
 	KWAttribute* attribute;

src/Learning/KWData/KWClass.h

@@ -46,8 +46,8 @@ class KWDerivationRule;
 //    false: objet interne
 //    true: objet reference
 //
-// MEMORY
-// Une KWClass contient et gere sa description(a savoir ses variables,
+// Memoire
+// Une KWClass contient et gere sa description (a savoir ses variables,
 // ses containers, et le contenu de ses containers)
 // Les KWClass referencees sont par contre independantes.
 class KWClass : public Object
@@ -456,6 +456,18 @@ class KWClass : public Object
 	// Export des noms des attributs cles dans l'ordre des cles
 	void ExportKeyAttributeNames(StringVector* svAttributedNames) const;
 
+	////////////////////////////////////////////////////////
+	// Services de dimensionnement
+
+	// Estimation heuristique de la memoire utilise par KWObject en se basant sur les
+	// variables utilisees, natives ou calculees
+	// La memoire utilisee par les sous-objet de la composition n'est pas prise en compte
+	longint GetEstimatedUsedMemoryPerObject() const;
+
+	// Constantes pour l'estimation heuristique de la taille des champs en memoire
+	static const int nTextValueSize = 200;
+	static const int nKeyFieldSize = 5;
+
 	////////////////////////////////////////////////////////
 	// Services standard