Changeset 14834 for branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/InterpreterPoolContainer.cs

Timestamp:

04/10/17 00:27:31 (8 years ago)

Author:

pkimmesw

Message:

#2665 LexicaseSelector, Performance improvements, UI Fixes, Debugger only shows used stacks, fixed Debugger stepping, Added vector expressions, ERCOptions,

File:

• branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/InterpreterPoolContainer.cs (modified) (3 diffs)

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/InterpreterPoolContainer.cs

@@ -22 +22 @@
       expressionListPoolProvider = new ManagedPoolProvider<PooledList<Expression>>(partitionSize, () => new PooledList<Expression>(), maxPartitionCount);
 
-      InitStatefulExpressionPools();
+      InitStatefulExpressionPools(partitionSize, maxPartitionCount);
     }
 
@@ -33 +33 @@
       this.expressionListPoolProvider = expressionListPoolProvider;
 
-      InitStatefulExpressionPools();
+      InitStatefulExpressionPools(1024, 2048);
     }
 
-    public IManagedPool<PushProgram> PushProgramPool { get; private set; }
-    public IManagedPool<LoopState> LoopStatePool { get; private set; }
-    public IManagedPool<PooledList<Expression>> ExpressionListPool { get; private set; }
+    private IManagedPool<PushProgram> pushProgramPool;
+    public IManagedPool<PushProgram> PushProgramPool
+    {
+      get
+      {
+        if (pushProgramPool == null) pushProgramPool = pushProgramPoolProvider.CreatePool();
+        return pushProgramPool;
+      }
+    }
 
-    private void InitStatefulExpressionPools() {
+    private IManagedPool<LoopState> loopStatePool;
+    public IManagedPool<LoopState> LoopStatePool
+    {
+      get
+      {
+        if (loopStatePool == null) loopStatePool = loopStatePoolProvider.CreatePool();
+        return loopStatePool;
+      }
+    }
+
+    private IManagedPool<PooledList<Expression>> expressionListPool;
+    public IManagedPool<PooledList<Expression>> ExpressionListPool
+    {
+      get
+      {
+        if (expressionListPool == null) expressionListPool = expressionListPoolProvider.CreatePool();
+        return expressionListPool;
+      }
+    }
+
+    private void InitStatefulExpressionPools(int partitionSize, int maxPartitionCount) {
       for (var i = 0; i < ExpressionTable.StatefulExpressionTypes.Length; i++) {
         var type = ExpressionTable.StatefulExpressionTypes[i];
         var name = ExpressionTable.TypeToNameTable[type];
-        var factory = ExpressionTable.StatefulExpressionFactory[name];
 
-        statefulExpressionPoolProviders.Add(type, new ManagedPoolProvider<Expression>(1024, factory));
+        statefulExpressionPoolProviders.Add(type, new ManagedPoolProvider<Expression>(
+          partitionSize,
+          ExpressionTable.StatefulExpressionFactory[name],
+          maxPartitionCount));
 
         statefulExpressionPools.Add(type, null);
@@ -52 +80 @@
     }
 
-    public IManagedPool<Expression> GetStatefulExpressionPool<T, StateT>() where T : StatefulExpression<StateT> {
-      return statefulExpressionPools[typeof(T)];
+    public T GetStatefulExpression<T>() where T : Expression {
+      var type = typeof(T);
+      if (statefulExpressionPools[type] == null)
+        statefulExpressionPools[type] = statefulExpressionPoolProviders[type].CreatePool();
+
+      return (T)statefulExpressionPools[type].Get();
     }
 
-    public T GetStatefulExpression<T>() where T : Expression {
-      return (T)statefulExpressionPools[typeof(T)].Get();
-    }
+    public void DisposePools() {
+      if (pushProgramPool != null) {
+        pushProgramPool.Dispose();
+        pushProgramPool = null;
+      }
 
-    public void CreatePools() {
-      PushProgramPool = pushProgramPoolProvider.CreatePool();
-      LoopStatePool = loopStatePoolProvider.CreatePool();
-      ExpressionListPool = expressionListPoolProvider.CreatePool();
+      if (loopStatePool != null) {
+        loopStatePool.Dispose();
+        loopStatePool = null;
+      }
+
+      if (expressionListPool != null) {
+        expressionListPool.Dispose();
+        expressionListPool = null;
+      }
 
       for (var i = 0; i < ExpressionTable.StatefulExpressionTypes.Length; i++) {
         var type = ExpressionTable.StatefulExpressionTypes[i];
-        statefulExpressionPools[type] = statefulExpressionPoolProviders[type].CreatePool();
-      }
-    }
+        var pool = statefulExpressionPools[type];
 
-    public void DisposePools() {
-      if (PushProgramPool != null) PushProgramPool.Dispose();
-      if (LoopStatePool != null) LoopStatePool.Dispose();
-      if (ExpressionListPool != null) ExpressionListPool.Dispose();
-
-      for (var i = 0; i < ExpressionTable.StatefulExpressionTypes.Length; i++) {
-        var type = ExpressionTable.StatefulExpressionTypes[i];
-        if (statefulExpressionPools[type] != null) statefulExpressionPools[type].Dispose();
+        if (pool != null) {
+          pool.Dispose();
+          statefulExpressionPools[type] = null;
+        }
       }
     }