Dynamic record allocation always use provided allocator to retrieve r…

…ecords.

Remove iterator from list of supplier parameters, always use allocator of some sort to retrieve dynamic record.
Remove empty iterators.
Remove duplicated test allocators.
Create specific allocators for scenarious when reuse of record is required.

community/consistency-check/src/test/java/org/neo4j/consistency/checking/NodeDynamicLabelOrphanChainStartCheckTest.java

@@ -27,21 +27,18 @@
 
 import org.neo4j.consistency.report.ConsistencyReport.DynamicLabelConsistencyReport;
 import org.neo4j.helpers.collection.Iterators;
-import org.neo4j.kernel.impl.store.PreAllocatedRecords;
+import org.neo4j.kernel.impl.store.allocator.ReusableRecordsAllocator;
 import org.neo4j.kernel.impl.store.record.DynamicRecord;
 import org.neo4j.kernel.impl.store.record.NodeRecord;
 
 import static org.mockito.Mockito.verify;
-import static org.neo4j.helpers.collection.Iterators.iterator;
 import static org.neo4j.kernel.impl.store.DynamicArrayStore.allocateFromNumbers;
 import static org.neo4j.kernel.impl.store.DynamicNodeLabels.dynamicPointer;
 
 public class NodeDynamicLabelOrphanChainStartCheckTest
         extends RecordCheckTestBase<DynamicRecord, DynamicLabelConsistencyReport, NodeDynamicLabelOrphanChainStartCheck>
 {
 
-    public static final PreAllocatedRecords RECORD_ALLOCATOR = new PreAllocatedRecords( 66 );
-
     public NodeDynamicLabelOrphanChainStartCheckTest()
     {
         super( new NodeDynamicLabelOrphanChainStartCheck(), DynamicLabelConsistencyReport.class, new int[0] );
@@ -60,8 +57,7 @@ public void shouldReportOrphanRecordsThatAreNotFirst() throws Exception
         {
             longs[i] = i;
         }
-        allocateFromNumbers( new ArrayList<DynamicRecord>(), longs, iterator( record0, record1, record2 ),
-                RECORD_ALLOCATOR );
+        allocateFromNumbers( new ArrayList<>(), longs, new ReusableRecordsAllocator( 66,  record0, record1, record2 ) );
         record0.setInUse( false );
 
         // when
@@ -75,12 +71,12 @@ public void shouldReportOrphanRecordsThatAreNotFirst() throws Exception
     public void shouldReportMissingOwnerId() throws Exception
     {
         // given
-        DynamicRecord nodeDynamicLabelRecord = inUse( new DynamicRecord( 0 ) ) ;
-        allocateFromNumbers( new ArrayList<DynamicRecord>(), new long[] { }, iterator( nodeDynamicLabelRecord ),
-                RECORD_ALLOCATOR );
+        DynamicRecord record = new DynamicRecord( 0 );
+        inUse( record ) ;
+        allocateFromNumbers( new ArrayList<>(), new long[] { }, new ReusableRecordsAllocator( 66, record ) );
 
         // when
-        DynamicLabelConsistencyReport report = check( nodeDynamicLabelRecord );
+        DynamicLabelConsistencyReport report = check( record );
 
         // then
         verify( report ).orphanDynamicLabelRecord();
@@ -94,8 +90,7 @@ public void shouldReportOwningNodeRecordNotInUse() throws Exception
         add( nodeRecord );
 
         DynamicRecord nodeDynamicLabelRecord = inUse( new DynamicRecord( 0 ) );
-        allocateFromNumbers( new ArrayList<DynamicRecord>(), new long[]{12L}, iterator( nodeDynamicLabelRecord ),
-                RECORD_ALLOCATOR );
+        allocateFromNumbers( new ArrayList<>(), new long[]{12L}, new ReusableRecordsAllocator( 66, nodeDynamicLabelRecord ) );
 
         // when
         DynamicLabelConsistencyReport report = check( nodeDynamicLabelRecord );
@@ -111,11 +106,12 @@ public void shouldReportOwningNodeRecordNotPointingBack() throws Exception
         long nodeId = 12L;
 
         Collection<DynamicRecord> validLabelRecords = new ArrayList<>();
-        allocateFromNumbers( validLabelRecords, new long[] {nodeId}, iterator( inUse( new DynamicRecord( 0 ) ) ),
-                RECORD_ALLOCATOR );
+        DynamicRecord dynamicRecord = inUse( new DynamicRecord( 0 ) );
+        allocateFromNumbers( validLabelRecords, new long[] {nodeId}, new ReusableRecordsAllocator( 66, dynamicRecord ) );
 
         Collection<DynamicRecord> fakePointedToRecords = new ArrayList<>();
-        allocateFromNumbers( fakePointedToRecords, new long[] {nodeId}, iterator( inUse( new DynamicRecord( 1 ) ) ), RECORD_ALLOCATOR );
+        DynamicRecord dynamicRecord1 = inUse( new DynamicRecord( 1 ) );
+        allocateFromNumbers( fakePointedToRecords, new long[] {nodeId}, new ReusableRecordsAllocator( 66, dynamicRecord1 ) );
 
         NodeRecord nodeRecord = inUse( new NodeRecord( nodeId, false, -1, -1 ) );
         nodeRecord.setLabelField( dynamicPointer( fakePointedToRecords ), fakePointedToRecords );

community/consistency-check/src/test/java/org/neo4j/consistency/checking/NodeRecordCheckTest.java

@@ -19,11 +19,11 @@
  */
 package org.neo4j.consistency.checking;
 
+import org.junit.Test;
+
 import java.util.ArrayList;
 import java.util.Collection;
 
-import org.junit.Test;
-
 import org.neo4j.consistency.checking.NodeRecordCheck.LabelsField;
 import org.neo4j.consistency.checking.NodeRecordCheck.RelationshipField;
 import org.neo4j.consistency.report.ConsistencyReport;
@@ -32,7 +32,7 @@
 import org.neo4j.kernel.impl.store.DynamicRecordAllocator;
 import org.neo4j.kernel.impl.store.InlineNodeLabels;
 import org.neo4j.kernel.impl.store.NodeStore;
-import org.neo4j.kernel.impl.store.PreAllocatedRecords;
+import org.neo4j.kernel.impl.store.allocator.ReusableRecordsAllocator;
 import org.neo4j.kernel.impl.store.record.DynamicRecord;
 import org.neo4j.kernel.impl.store.record.LabelTokenRecord;
 import org.neo4j.kernel.impl.store.record.NodeRecord;
@@ -252,8 +252,8 @@ public void shouldReportDynamicLabelsNotInUse() throws Exception
         Collection<DynamicRecord> labelRecords = asList( labelsRecord1, labelsRecord2 );
 
         labelIds[12] = labelIds.length;
-        DynamicArrayStore.allocateFromNumbers( new ArrayList<DynamicRecord>(), labelIds, labelRecords.iterator(),
-                new PreAllocatedRecords( 52 ) );
+        DynamicArrayStore.allocateFromNumbers( new ArrayList<>(), labelIds,
+                new ReusableRecordsAllocator( 52, labelRecords ) );
         assertDynamicRecordChain( labelsRecord1, labelsRecord2 );
         node.setLabelField( DynamicNodeLabels.dynamicPointer( labelRecords ), labelRecords );
 
@@ -301,8 +301,8 @@ public void shouldReportDuplicateDynamicLabels() throws Exception
         Collection<DynamicRecord> labelRecords = asList( labelsRecord1, labelsRecord2 );
 
         labelIds[12] = 11;
-        DynamicArrayStore.allocateFromNumbers( new ArrayList<DynamicRecord>(), labelIds, labelRecords.iterator(),
-                new PreAllocatedRecords( 52 ) );
+        DynamicArrayStore.allocateFromNumbers( new ArrayList<>(), labelIds,
+                new ReusableRecordsAllocator( 52, labelRecords ) );
         assertDynamicRecordChain( labelsRecord1, labelsRecord2 );
         node.setLabelField( DynamicNodeLabels.dynamicPointer( labelRecords ), labelRecords );
 
@@ -403,8 +403,8 @@ public void shouldReportOutOfOrderDynamicLabels() throws Exception
         long temp = labelIds[12];
         labelIds[12] = labelIds[11];
         labelIds[11] = temp;
-        DynamicArrayStore.allocateFromNumbers( new ArrayList<DynamicRecord>(), labelIds, labelRecords.iterator(),
-                new PreAllocatedRecords( 52 ) );
+        DynamicArrayStore.allocateFromNumbers( new ArrayList<>(), labelIds,
+                new ReusableRecordsAllocator( 52, labelRecords ) );
         assertDynamicRecordChain( labelsRecord1, labelsRecord2 );
         node.setLabelField( DynamicNodeLabels.dynamicPointer( labelRecords ), labelRecords );
 
@@ -431,8 +431,8 @@ public void shouldDynamicLabelRecordsNotInUse() throws Exception
         DynamicRecord labelsRecord2 = notInUse( array( new DynamicRecord( 2 ) ) );
         Collection<DynamicRecord> labelRecords = asList( labelsRecord1, labelsRecord2 );
 
-        DynamicArrayStore.allocateFromNumbers( new ArrayList<DynamicRecord>(), labelIds,
-                labelRecords.iterator(), new PreAllocatedRecords( 52 ) );
+        DynamicArrayStore.allocateFromNumbers( new ArrayList<>(), labelIds,
+                new NotUsedReusableRecordsAllocator( 52, labelRecords ) );
         assertDynamicRecordChain( labelsRecord1, labelsRecord2 );
         node.setLabelField( DynamicNodeLabels.dynamicPointer( labelRecords ), labelRecords );
 
@@ -470,4 +470,21 @@ private void assertDynamicRecordChain( DynamicRecord... records )
         }
     }
 
+    private class NotUsedReusableRecordsAllocator extends ReusableRecordsAllocator
+    {
+
+        public NotUsedReusableRecordsAllocator( int recordSize, Collection<DynamicRecord> records )
+        {
+            super( recordSize, records );
+        }
+
+        @Override
+        public DynamicRecord nextRecord()
+        {
+            DynamicRecord record = super.nextRecord();
+            record.setInUse( false );
+            return record;
+        }
+    }
+
 }

community/consistency-check/src/test/java/org/neo4j/consistency/checking/full/FullCheckIntegrationTest.java

@@ -83,7 +83,7 @@
 import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge;
 import org.neo4j.kernel.impl.store.AbstractDynamicStore;
 import org.neo4j.kernel.impl.store.NodeLabelsField;
-import org.neo4j.kernel.impl.store.PreAllocatedRecords;
+import org.neo4j.kernel.impl.store.allocator.ReusableRecordsAllocator;
 import org.neo4j.kernel.impl.store.PropertyType;
 import org.neo4j.kernel.impl.store.RecordStore;
 import org.neo4j.kernel.impl.store.SchemaStorage;
@@ -346,7 +346,7 @@ protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
                 DynamicRecord record = inUse( new DynamicRecord( next.nodeLabel() ) );
                 Collection<DynamicRecord> newRecords = new ArrayList<>();
                 allocateFromNumbers( newRecords, prependNodeId( nodeRecord.getId(), new long[]{42L} ),
-                        iterator( record ), new PreAllocatedRecords( 60 ) );
+                        new ReusableRecordsAllocator( 60, record ) );
                 nodeRecord.setLabelField( dynamicPointer( newRecords ), newRecords );
 
                 tx.create( nodeRecord );
@@ -390,9 +390,8 @@ protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
                 DynamicRecord record1 = inUse( new DynamicRecord( chain.get( 0 ).getId() ) );
                 DynamicRecord record2 = notInUse( new DynamicRecord( chain.get( 1 ).getId() ) );
                 long[] data = (long[]) getRightArray( readFullByteArrayFromHeavyRecords( chain, ARRAY ) );
-                PreAllocatedRecords allocator = new PreAllocatedRecords( 60 );
-                allocateFromNumbers( new ArrayList<DynamicRecord>(), Arrays.copyOf( data, 11 ),
-                        iterator( record1 ), allocator );
+                ReusableRecordsAllocator allocator = new ReusableRecordsAllocator( 60, record1 );
+                allocateFromNumbers( new ArrayList<>(), Arrays.copyOf( data, 11 ), allocator );
 
                 NodeRecord before = inUse( new NodeRecord( data[0], false, -1, -1 ) );
                 NodeRecord after = inUse( new NodeRecord( data[0], false, -1, -1 ) );
@@ -797,8 +796,8 @@ protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
                 DynamicRecord record2 = inUse( new DynamicRecord( next.nodeLabel() ) );
                 DynamicRecord record3 = inUse( new DynamicRecord( next.nodeLabel() ) );
                 labels[0] = nodeRecord.getId(); // the first id should not be a label id, but the id of the node
-                PreAllocatedRecords allocator = new PreAllocatedRecords( 60 );
-                allocateFromNumbers( chain, labels, iterator( record1, record2, record3 ), allocator );
+                ReusableRecordsAllocator allocator = new ReusableRecordsAllocator( 60, record1, record2, record3 );
+                allocateFromNumbers( chain, labels, allocator );
 
                 nodeRecord.setLabelField( dynamicPointer( chain ), chain );
 
@@ -825,7 +824,7 @@ protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
                 Collection<DynamicRecord> newRecords = new ArrayList<>();
                 allocateFromNumbers( newRecords,
                         prependNodeId( nodeRecord.getId(), new long[]{42L, 42L} ),
-                        iterator( record ), new PreAllocatedRecords( 60 ) );
+                        new ReusableRecordsAllocator( 60, record ) );
                 nodeRecord.setLabelField( dynamicPointer( newRecords ), newRecords );
 
                 tx.create( nodeRecord );
@@ -857,7 +856,7 @@ protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
                 DynamicRecord record = inUse( new DynamicRecord( next.nodeLabel() ) );
                 Collection<DynamicRecord> newRecords = new ArrayList<>();
                 allocateFromNumbers( newRecords, prependNodeId( next.node(), new long[]{42L} ),
-                        iterator( record ), new PreAllocatedRecords( 60 ) );
+                        new ReusableRecordsAllocator( 60, record ) );
                 nodeRecord.setLabelField( dynamicPointer( newRecords ), newRecords );
 
                 tx.create( nodeRecord );
@@ -1125,9 +1124,9 @@ public static Collection<DynamicRecord> serializeRule( SchemaRule rule, Collecti
         serializer.append( (AbstractSchemaRule)rule );
 
         byte[] data = serializer.serialize();
-        PreAllocatedRecords dynamicRecordAllocator = new PreAllocatedRecords( data.length );
+        ReusableRecordsAllocator dynamicRecordAllocator = new ReusableRecordsAllocator( data.length, records );
         Collection<DynamicRecord> result = new ArrayList<>();
-        AbstractDynamicStore.allocateRecordsFromBytes( result, data, records.iterator(), dynamicRecordAllocator );
+        AbstractDynamicStore.allocateRecordsFromBytes( result, data, dynamicRecordAllocator );
         return result;
     }
 

community/consistency-check/src/test/java/org/neo4j/consistency/checking/full/NodeInUseWithCorrectLabelsCheckTest.java

@@ -31,7 +31,7 @@
 import org.neo4j.consistency.store.synthetic.LabelScanDocument;
 import org.neo4j.kernel.impl.store.DynamicArrayStore;
 import org.neo4j.kernel.impl.store.InlineNodeLabels;
-import org.neo4j.kernel.impl.store.PreAllocatedRecords;
+import org.neo4j.kernel.impl.store.allocator.ReusableRecordsAllocator;
 import org.neo4j.kernel.impl.store.record.DynamicRecord;
 import org.neo4j.kernel.impl.store.record.NodeRecord;
 
@@ -142,7 +142,7 @@ private NodeRecord withDynamicLabels( RecordAccessStub recordAccess, NodeRecord
         }
         Collection<DynamicRecord> dynamicRecords = new ArrayList<>();
         DynamicArrayStore.allocateFromNumbers( dynamicRecords, prependNodeId( nodeRecord.getId(), labelIds ),
-                preAllocatedRecords.iterator(), new PreAllocatedRecords( 4 ) );
+                new ReusableRecordsAllocator( 4, preAllocatedRecords ) );
         for ( DynamicRecord dynamicRecord : dynamicRecords )
         {
             recordAccess.addNodeDynamicLabels( dynamicRecord );

community/kernel/src/main/java/org/neo4j/kernel/impl/store/AbstractDynamicStore.java

@@ -23,11 +23,9 @@
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Iterator;
 import java.util.List;
 
 import org.neo4j.helpers.collection.Iterables;
-import org.neo4j.helpers.collection.Iterators;
 import org.neo4j.helpers.collection.Pair;
 import org.neo4j.io.pagecache.PageCache;
 import org.neo4j.io.pagecache.PageCursor;
@@ -83,12 +81,11 @@ recordFormat, new DynamicStoreHeaderFormat( dataSizeFromConfiguration, recordFor
                 storeVersion );
     }
 
-    public static void allocateRecordsFromBytes(
-            Collection<DynamicRecord> recordList, byte[] src, Iterator<DynamicRecord> recordsToUseFirst,
+    public static void allocateRecordsFromBytes( Collection<DynamicRecord> recordList, byte[] src,
             DynamicRecordAllocator dynamicRecordAllocator )
     {
         assert src != null : "Null src argument";
-        DynamicRecord nextRecord = dynamicRecordAllocator.nextUsedRecordOrNew( recordsToUseFirst );
+        DynamicRecord nextRecord = dynamicRecordAllocator.nextRecord();
         int srcOffset = 0;
         int dataSize = dynamicRecordAllocator.getRecordDataSize();
         do
@@ -100,7 +97,7 @@ public static void allocateRecordsFromBytes(
                 byte[] data = new byte[dataSize];
                 System.arraycopy( src, srcOffset, data, 0, dataSize );
                 record.setData( data );
-                nextRecord = dynamicRecordAllocator.nextUsedRecordOrNew( recordsToUseFirst );
+                nextRecord = dynamicRecordAllocator.nextRecord();
                 record.setNextBlock( nextRecord.getId() );
                 srcOffset += dataSize;
             }
@@ -181,29 +178,17 @@ public static Pair<byte[], byte[]> readFullByteArrayFromHeavyRecords(
     }
 
     @Override
-    public DynamicRecord nextUsedRecordOrNew( Iterator<DynamicRecord> recordsToUseFirst )
+    public DynamicRecord nextRecord()
     {
-        DynamicRecord record;
-        if ( recordsToUseFirst.hasNext() )
-        {
-            record = recordsToUseFirst.next();
-            if ( !record.inUse() )
-            {
-                record.setCreated();
-            }
-        }
-        else
-        {
-            record = new DynamicRecord( nextId() );
-            record.setCreated();
-        }
+        DynamicRecord record = new DynamicRecord( nextId() );
+        record.setCreated();
         record.setInUse( true );
         return record;
     }
 
     public void allocateRecordsFromBytes( Collection<DynamicRecord> target, byte[] src )
     {
-        allocateRecordsFromBytes( target, src, Iterators.<DynamicRecord>emptyIterator(), this );
+        allocateRecordsFromBytes( target, src, this );
     }
 
     @Override

community/kernel/src/main/java/org/neo4j/kernel/impl/store/DynamicArrayStore.java

@@ -23,7 +23,6 @@
 import java.lang.reflect.Array;
 import java.nio.ByteBuffer;
 import java.util.Collection;
-import java.util.Iterator;
 
 import org.neo4j.helpers.collection.Pair;
 import org.neo4j.io.pagecache.PageCache;
@@ -71,7 +70,7 @@ public <FAILURE extends Exception> void accept( RecordStore.Processor<FAILURE> p
     }
 
     public static void allocateFromNumbers( Collection<DynamicRecord> target, Object array,
-            Iterator<DynamicRecord> recordsToUseFirst, DynamicRecordAllocator recordAllocator )
+            DynamicRecordAllocator recordAllocator )
     {
         Class<?> componentType = array.getClass().getComponentType();
         boolean isPrimitiveByteArray = componentType.equals( Byte.TYPE );
@@ -118,11 +117,11 @@ public static void allocateFromNumbers( Collection<DynamicRecord> target, Object
             type.writeAll(array, arrayLength,requiredBits,bits);
             bytes = bits.asBytes();
         }
-        allocateRecordsFromBytes( target, bytes, recordsToUseFirst, recordAllocator );
+        allocateRecordsFromBytes( target, bytes, recordAllocator );
     }
 
     private static void allocateFromString( Collection<DynamicRecord> target, String[] array,
-            Iterator<DynamicRecord> recordsToUseFirst, DynamicRecordAllocator recordAllocator )
+            DynamicRecordAllocator recordAllocator )
     {
         byte[][] stringsAsBytes = new byte[array.length][];
         int totalBytesRequired = STRING_HEADER_SIZE; // 1b type + 4b array length
@@ -142,17 +141,16 @@ private static void allocateFromString( Collection<DynamicRecord> target, String
             buf.putInt( stringAsBytes.length );
             buf.put( stringAsBytes );
         }
-        allocateRecordsFromBytes( target, buf.array(), recordsToUseFirst, recordAllocator );
+        allocateRecordsFromBytes( target, buf.array(), recordAllocator );
     }
 
-    public void allocateRecords( Collection<DynamicRecord> target, Object array,
-            Iterator<DynamicRecord> recordsToUseFirst )
+    public void allocateRecords( Collection<DynamicRecord> target, Object array )
     {
-        allocateRecords( target, array, recordsToUseFirst, this );
+        allocateRecords( target, array, this );
     }
 
     public static void allocateRecords( Collection<DynamicRecord> target, Object array,
-            Iterator<DynamicRecord> recordsToUseFirst, DynamicRecordAllocator recordAllocator )
+            DynamicRecordAllocator recordAllocator )
     {
         if ( !array.getClass().isArray() )
         {
@@ -162,11 +160,11 @@ public static void allocateRecords( Collection<DynamicRecord> target, Object arr
         Class<?> type = array.getClass().getComponentType();
         if ( type.equals( String.class ) )
         {
-            allocateFromString( target, (String[]) array, recordsToUseFirst, recordAllocator );
+            allocateFromString( target, (String[]) array, recordAllocator );
         }
         else
         {
-            allocateFromNumbers( target, array, recordsToUseFirst, recordAllocator );
+            allocateFromNumbers( target, array, recordAllocator );
         }
     }