FWD » Core Development » Base Language

For example, there are BlockDefinition collection fields which can be assigned only when that field is required. Some of BlockDefinition fields will be fixed in 3821c/6129a, what is remaining is BlockDefinition.finalizables.

This task is meant to analyze what collection fields in high-impact FWD state (with lots of allocated instances) can be delayed initialization. Same with scope support: push a Collections.empty instead of a real instance, and create one only as needed.

The goal is to reduce the number of collection instances being created.

Some changes are in 3821c/14272. Greg, please review.

• ArrayList - 1.6 million
  • ErrorManager$ErrorStatus.<init> 270k
  • AnnotatedAst.getImmediateChild 100k
  • DataSet.<init> 80k
  • SourceNameMapper 30k (from String.split)
  • HQLExpression.<init> 30k
  • ObjectOps.getExecuteMethod 30k (from String.format)
  • AbstractPArameter$Scope.<init> 26k
  • PreselectQuery.<init> 20k
  • DataSet.setBuffers 20k
  • PreselectQuery.execute 18k
• HashMap - 1.4 million
  • HashSet.<init> 400k (from WidgetPool.scopeFinished, Session.invalidateRecords, AbstractTempTable.<init>, TemporaryBuffer.getAllSlaveBuffers, DataSet.<init>)
  • BufferImpl.<init> 200k
  • LinkedHashMap.<init> 180k (from RepositionCache$Node.<init>, orm.Persister.update)
  • RecordBuffer.<init> 180k
  • TriggerTracker.areAssignTriggersEnabled 84k
  • DataSet.<init> 80k
  • RecordBuffer.reportChange 52k
  • TemporaryBuffer$ReferenceProxy.<init> 44k
• IdentityHashMap - 900k
  • TransactionManager.addFinalizable 123k
  • BufferManager.scopeStart 115k
  • ObjectOps$WorkArea.scopeFinished/scopeStart 110k
  • ArrayAssigner.scopeStart 76k
  • SavePointManager.<init> 76k
  • ObjectOps.pendingAssign 74k
  • DataSet.<init> 20k
  • ProcedureManager$WorkArea.searchInStack 31k
  • AbstractParameter$Scope.<init> 26k
  • BufferManager$PersistentProcScope.<init> 20k
• BitSet - 900k
  • BaseRecord.getDirtyIndices 220k
  • RecordBuffer.<init> 180k
  • BaseRecord.getUnvalidatedIndices 76k
  • RecordBuffer.getIndexedProperties 56k
• HashSet - 400k
  • WidgetPool$WorkArea.scopeFinished 90k
  • Session.invalidateRecords 50k
  • AbstractTempTable.<init> 40k
  • TemporaryBuffer.getAllSlaveBuffers 40k
  • RecordNursery.indexUpdated 21k
  • DataSet.<init> 40k
• LinkedList - 115k
  • SourceNameMapper.removeUpPath 21k
  • SourceNameMapper.getConstructors 12k
  • SourceNameMapper.canonicalize 10k
  • ProcedureManager.publish 10k
• ArrayDeque - 120k
  • WidgetPool$WorkArea.scopeStart 86k
  • ArrayAssigner$WorkArea.scopeStart 13k
  • ProcedureManager$ProcedureData.<init> 13k
  • ObjectResource.<init> 12k
• LinkedHashMap - 320k
  • AnnotatedAst.initialize 116k (from AnnotatedAst.duplicateImpl)
  • @RepositionCache$Node.<init> 81k
  • Persister.update 35k
  • AnnotatedAst.putAnnotationImpl 26k
• WeakHashMap - 53k
  • TemporaryBuffer.define 40k
  • ProcedureManager$ProcedureData.<init> 13k

• reduce the number of allocations, by lazy initialization (don't create it until is really needed).
• in some cases (like stacks/deques) it may be possible to use a single stack and keep together all the info in a single entry in the stack.

• BufferImpl.callbacks can be lazily created, not all buffers are used in FILL operations.
• RecordBuffer - getterDatums and setterDatums can be lazily created, as these are used only via getGetterDatums and getSetterDatums, and are needed only in specific usage of a RecordBuffer.
• BaseRecord.getDirtyIndices(BitSet[] indices, int dirtyOffset, BitSet filter, boolean full) can easily return null if there are no 'dirty' bits set - and the callers can handle this. I'm not sure about the filter - if all bits are set, we can just pass a null instance to it, instead of creating a new BitSet with all bits set.

A batch of changes (including #6824-4) are in 6129b/14348

Please review.

Review of: 6129b/14348.

I am OK with the code. However, in DataSet, when it is decided that callbacks == null there is no point in calling invokeCallback. That would require for calls of other methods like asHandle() to set the parameters. Example DataSet:1928 line:

      if (!invokeCallback(asHandle(), callbacks == null ? null : callbacks.get(BEFORE_FILL_EVENT)))

      if (callbacks != null && !invokeCallback(asHandle(), callbacks.get(BEFORE_FILL_EVENT)))

I also noticed the replacement of ArrayList usages with HashSet. I think we can do even better, using BitSet instead. I created a quick test in which N = 1000000 objects of each type were created and used. The result are:

While the HashSet performs slightly better when created, the add and remove operations are 10-15X faster with BitSet s and do not require additional memory.

Java codeJava code

      final int N = 1000000;
      final int SET_SIZE = 3000;
      final int WORK_SET = 8095;

      HashSet<Integer>[] hashSet = new HashSet[N];
      BitSet[] bitSets = new BitSet[N];

      {
         System.gc();
         long t = System.currentTimeMillis();
         long m1 = Runtime.getRuntime().freeMemory();
         for (int i = 0; i < N; i++)
         {
            bitSets[i] = new BitSet(SET_SIZE);
         }
         long m2 = Runtime.getRuntime().freeMemory();
         System.out.println("C:   B:" + (System.currentTimeMillis() - t) + " " + (m1 - m2) + " " + (m1 - m2) / N);
      }

      {
         System.gc();
         long t = System.currentTimeMillis();
         long m1 = Runtime.getRuntime().freeMemory();
         for (int i = 0; i < 11*N; i++)
         {
            bitSets[i % WORK_SET].set(i % (SET_SIZE-1));
         }
         long m2 = Runtime.getRuntime().freeMemory();
         System.out.println("+:   B:" + (System.currentTimeMillis() - t) + " " + (m1 - m2) + " " + (m1 - m2) / WORK_SET);
      }

      {
         System.gc();
         long t = System.currentTimeMillis();
         long m1 = Runtime.getRuntime().freeMemory();
         for (int i = 0; i < 11*N; i++)
         {
            bitSets[i % WORK_SET].set(i % (SET_SIZE-1), false);
         }
         long m2 = Runtime.getRuntime().freeMemory();
         System.out.println("-:   B:" + (System.currentTimeMillis() - t) + " " + (m1 - m2) + " " + (m1 - m2) / WORK_SET);
      }

      {
         System.gc();
         long t = System.currentTimeMillis();
         long m1 = Runtime.getRuntime().freeMemory();
         for (int i = 0; i < N; i++)
         {
            hashSet[i] = new HashSet<>(SET_SIZE);
         }
         long m2 = Runtime.getRuntime().freeMemory();
         System.out.println("C:   H:" + (System.currentTimeMillis() - t) + " " + (m1 - m2) + " " + (m1 - m2) / N);
      }

      {
         System.gc();
         long t = System.currentTimeMillis();
         long m1 = Runtime.getRuntime().freeMemory();
         for (int i = 0; i < 11*N; i++)
         {
            hashSet[i % WORK_SET].add(i % (SET_SIZE-1));
         }
         long m2 = Runtime.getRuntime().freeMemory();
         System.out.println("+:   H:" + (System.currentTimeMillis() - t) + " " + (m1 - m2) + " " + (m1 - m2) / WORK_SET);
      }

      {
         System.gc();
         long t = System.currentTimeMillis();
         long m1 = Runtime.getRuntime().freeMemory();
         for (int i = 0; i < 11*N; i++)
         {
            hashSet[i % WORK_SET].remove(i % (SET_SIZE-1));
         }
         long m2 = Runtime.getRuntime().freeMemory();
         System.out.println("-:   H:" + (System.currentTimeMillis() - t) + " " + (m1 - m2) + " " + (m1 - m2) / WORK_SET);
      }

Some other changes related to this are in 6129b/14366.