Changeset 19687


Ignore:
Timestamp:
02/10/12 00:31:46 (4 months ago)
Author:
sys
Message:

Tree en cours...

Location:
trunk/Jav_Orient
Files:
7 added
4 edited
6 moved

Legend:

Unmodified
Added
Removed

  • trunk/Jav_Orient/src/eu/scenari/orient/recordstruct/value/ValueListImmutableFixed.java

    r19680 r19687  
    281281                int vCountToAdd = pC.size(); 
    282282                if (vCountToAdd == 0) return false; 
    283                 Iterator<? extends E> vEntry = pC.iterator(); 
     283                isolateBufferForUpdates(fSize + vCountToAdd); 
    284284                int vOffset = index2Offset(pIndex); 
    285285                if (pIndex < fSize) { 
    286                         System.arraycopy(fRawEntries, vOffset, fRawEntries, vOffset + (vCountToAdd * getFixedLengthEntry()), (pIndex - fSize) * getFixedLengthEntry()); 
    287                 } 
    288                 while (vEntry.hasNext()) { 
    289                         marshallEntry(vEntry.next(), vOffset); 
     286                        System.arraycopy(fRawEntries, vOffset, fRawEntries, vOffset + (vCountToAdd * getFixedLengthEntry()), (fSize - pIndex) * getFixedLengthEntry()); 
     287                } 
     288                Iterator<? extends E> vIt = pC.iterator(); 
     289                while (vIt.hasNext()) { 
     290                        marshallEntry(vIt.next(), vOffset); 
    290291                        vOffset += getFixedLengthEntry(); 
    291292                } 
    … …  
    320321                int vOffset = index2Offset(pIndex); 
    321322                if (pIndex < fSize) { 
    322                         System.arraycopy(fRawEntries, vOffset, fRawEntries, vOffset + getFixedLengthEntry(), (pIndex - fSize) * getFixedLengthEntry()); 
     323                        System.arraycopy(fRawEntries, vOffset, fRawEntries, vOffset + getFixedLengthEntry(), (fSize - pIndex) * getFixedLengthEntry()); 
    323324                } 
    324325                marshallEntry(pElement, vOffset); 

  • trunk/Jav_Orient/src/eu/scenari/orient/tree/impl/RSTreeRake.java

    r19681 r19687  
    8888                if (vNewRake == null) return null; 
    8989                ensureSize(vCurrentSize + 1); 
     90                //move 
     91                //note : write access lock is held on tree, no lock here. 
     92                for (int i = vCurrentSize - 1, l = pOffset; i >= l; i--) { 
     93                        RSTreeNode<K, V> vNode = fChildren[i]; 
     94                        fChildren[i + 1] = vNode; 
     95                        if (vNode != null) vNode.setParent(this, i + 1); 
     96                } 
    9097                RSTreeRake vRake = (RSTreeRake) createChildNode(vNewRake, pOffset); 
    91                 int vCountToMove = vCurrentSize - pOffset - 1; 
    92                 if (vCountToMove > 0) { 
    93                         //move 
    94                         //note : write access lock is held on tree, no lock here. 
    95                         System.arraycopy(fChildren, pOffset, fChildren, pOffset + 1, vCountToMove); 
    96                 } 
    9798                fChildren[pOffset] = vRake; 
     99                assert (assertChildrenOffset()); 
    98100                return vRake; 
    99101        } 
    100102 
    101103        public RSTreeSlot<K, V> insertNewSlot(int pOffset) { 
     104                assert (assertChildrenOffset()); 
    102105                int vCurrentSize = getProvider().getSize(); 
    103                 assert (pOffset <= getProvider().getSize()); 
     106                assert (pOffset <= vCurrentSize); 
    104107                ITreeSlotProvider<K, V> vNewSlot = getProvider().insertNewSlot(pOffset); 
    105108                if (vNewSlot == null) return null; 
    106109                ensureSize(vCurrentSize + 1); 
    107                 RSTreeSlot vNode = (RSTreeSlot) createChildNode(vNewSlot, pOffset); 
    108                 int vCountToMove = vCurrentSize - pOffset - 1; 
    109                 if (vCountToMove > 0) { 
    110                         //move 
    111                         //note : write access lock is held on tree, no lock here. 
    112                         System.arraycopy(fChildren, pOffset, fChildren, pOffset + 1, vCountToMove); 
    113                 } 
    114                 fChildren[pOffset] = vNode; 
    115                 return vNode; 
     110                //move 
     111                //note : write access lock is held on tree, no lock here. 
     112                for (int i = vCurrentSize - 1, l = pOffset; i >= l; i--) { 
     113                        RSTreeNode<K, V> vNode = fChildren[i]; 
     114                        fChildren[i + 1] = vNode; 
     115                        if (vNode != null) vNode.setParent(this, i + 1); 
     116                } 
     117                RSTreeSlot vSlot = (RSTreeSlot) createChildNode(vNewSlot, pOffset); 
     118                fChildren[pOffset] = vSlot; 
     119                assert (assertChildrenOffset()); 
     120                return vSlot; 
    116121        } 
    117122 
    … …  
    126131                        RSTreeNode<K, V>[] vRightChildren = vRight.fChildren; 
    127132                        System.arraycopy(vRightChildren, 0, fChildren, vNewSize - vMoved, vMoved); 
    128                         System.arraycopy(vRightChildren, vMoved, vRightChildren, 0, vRightChildren.length - vMoved); 
    129133                        for (int i = vNewSize - vMoved; i < vNewSize; i++) { 
    130                                 fChildren[i].setParent(this, i); 
    131                         } 
    132                 } 
     134                                RSTreeNode<K, V> vNode = fChildren[i]; 
     135                                if (vNode != null) vNode.setParent(this, i); 
     136                        } 
     137                        int vRightNewSize = vRight.getProvider().getSize(); 
     138                        System.arraycopy(vRightChildren, vMoved, vRightChildren, 0, vRightNewSize); 
     139                        for (int i = 0; i < vRightNewSize; i++) { 
     140                                RSTreeNode<K, V> vNode = vRight.fChildren[i]; 
     141                                if (vNode != null) vNode.setParent(this, i); 
     142                        } 
     143                        for (int i = vRightNewSize; i < vRightChildren.length; i++) { 
     144                                vRight.fChildren[i] = null; 
     145                        } 
     146                        assert (vRight.assertChildrenOffset()); 
     147                } 
     148                assert (assertChildrenOffset()); 
    133149                return vMoved; 
    134150        } 
    … …  
    143159                        //note : write access lock is held on tree, no lock here. 
    144160                        RSTreeNode<K, V>[] vLeftChildren = vLeft.fChildren; 
     161                        int vLeftNewSize = vLeft.getProvider().getSize(); 
    145162                        System.arraycopy(fChildren, 0, fChildren, vMoved, vNewSize - vMoved); 
    146                         System.arraycopy(vLeftChildren, vLeft.getProvider().getSize(), fChildren, 0, vMoved); 
    147                         for (int i = 0; i < vMoved; i++) { 
    148                                 fChildren[i].setParent(this, i); 
    149                         } 
    150                 } 
     163                        System.arraycopy(vLeftChildren, vLeftNewSize, fChildren, 0, vMoved); 
     164                        for (int i = 0; i < vNewSize; i++) { 
     165                                RSTreeNode<K, V> vNode = fChildren[i]; 
     166                                if (vNode != null) vNode.setParent(this, i); 
     167                        } 
     168                        for (int i = vLeftNewSize, l = vLeftNewSize + vMoved; i < l; i++) { 
     169                                vLeft.fChildren[i] = null; 
     170                        } 
     171                        assert (vLeft.assertChildrenOffset()); 
     172                } 
     173                assert (assertChildrenOffset()); 
    151174                return vMoved; 
    152175        } 
    … …  
    163186                        System.arraycopy(vRightChildren, 0, fChildren, vOldSize, vNewSize - vOldSize); 
    164187                        for (int i = vOldSize; i < vNewSize; i++) { 
    165                                 fChildren[i].setParent(this, i); 
    166                         } 
     188                                RSTreeNode<K, V> vNode = fChildren[i]; 
     189                                if (vNode != null) vNode.setParent(this, i); 
     190                        } 
     191                        assert (assertChildrenOffset()); 
    167192                        return true; 
    168193                } 
     194                assert (assertChildrenOffset()); 
    169195                return false; 
    170196        } 
    … …  
    181207                        System.arraycopy(fChildren, 0, fChildren, vMoved, vNewSize - vMoved); 
    182208                        System.arraycopy(vLeftChildren, 0, fChildren, 0, vMoved); 
    183                         for (int i = 0; i < vMoved; i++) { 
    184                                 fChildren[i].setParent(this, i); 
    185                         } 
     209                        for (int i = 0; i < vNewSize; i++) { 
     210                                RSTreeNode<K, V> vNode = fChildren[i]; 
     211                                if (vNode != null) vNode.setParent(this, i); 
     212                        } 
     213                        assert (assertChildrenOffset()); 
    186214                        return true; 
    187215                } 
     216                assert (assertChildrenOffset()); 
    188217                return false; 
    189218        } 
    … …  
    269298                                vSlot.clearChildren(); 
    270299                                fTree.setRoot(vSlot); 
     300                                assert (assertChildrenOffset()); 
    271301                        } 
    272302                } else { 
    … …  
    278308                                RSTreeNode<K, V> vNext = fChildren[i + 1]; 
    279309                                fChildren[i] = vNext; 
    280                                 vNext.setParent(this, i); 
     310                                if (vNext != null) vNext.setParent(this, i); 
    281311                        } 
    282312                        fChildren[vOldSize - 1] = null; 
    … …  
    286316                                fParent.updateKey(fOffsetInParent, fProvider.getKey(0)); 
    287317                        } 
     318                        assert (assertChildrenOffset()); 
    288319                        // Give a chance to optimize the tree. 
    289320                        fTree.fBalancingLayout.onRemovedEntry(this); 
    … …  
    339370 
    340371        public void removeChildFromMemory(RSTreeNode<K, V> pNode) { 
     372                assert (pNode.fParent == this); 
    341373                synchronized (this) { 
    342374                        fChildren[pNode.fOffsetInParent] = null; 
    343375                        //pNode.setParent(null, 0); no, will kill pending iterators. 
    344376                } 
     377                assert (assertChildrenOffset()); 
    345378        } 
    346379 
    … …  
    361394                } 
    362395        } 
     396 
     397        protected boolean assertChildrenOffset() { 
     398                synchronized (this) { 
     399                        for (int i = 0; i < fChildren.length; i++) { 
     400                                RSTreeNode<K, V> vNode = fChildren[i]; 
     401                                if (vNode != null) assert (vNode.fOffsetInParent == i) : vNode.fOffsetInParent + "!=" + i; 
     402                                //                              if (vNode != null && vNode.fOffsetInParent != i) { 
     403                                //                                      System.out.println(vNode.fOffsetInParent + "!=" + i); 
     404                                //                                      break; 
     405                                //                              } 
     406                        } 
     407                } 
     408                return true; 
     409        } 
    363410} 

  • trunk/Jav_Orient/test/eu/scenari/orient/tree/TreeBasicIncrementalTest.java

    r19680 r19687  
    3939package eu.scenari.orient.tree; 
    4040 
    41 import java.util.Iterator; 
    42 import java.util.Map; 
    43  
    44 import junit.framework.Assert; 
    45  
    4641import org.junit.Test; 
    4742 
    48 import com.orientechnologies.orient.core.id.ORID; 
     43import eu.scenari.orient.tree.datafactory.FactorySequentialLong; 
    4944 
    50 import eu.scenari.orient.recordstruct.IRecordStruct; 
    51 import eu.scenari.orient.recordstruct.lib.tree.ValueTree; 
    52 import eu.scenari.orient.test.TestDbAbstract; 
    53  
    54 public class TreeBasicTest extends TestDbAbstract { 
    55  
    56         public static int MAP_SIZE = 2000; 
    57  
    58         protected FactorySequentialLong fFactorySeqLong = new FactorySequentialLong(); 
     45public class TreeBasicIncrementalTest extends TreeBasicTestAbstract { 
    5946 
    6047        @Override 
    … …  
    6350 
    6451        @Test 
    65         public void test1() { 
    66                 int vSize = MAP_SIZE; 
    67                 fDatabase = fDbDriver.acquireDatabase(); 
    68                 IRecordStruct<ValueTree<Long, Long>> vRecord = fDatabase.newInstance(); 
    69                 vRecord.setValue((ValueTree) TypesTreeTests.TREE_LONG_LONG.toValue(null, vRecord)); 
    70                 vRecord.save(); 
    71                 ORID vId = vRecord.getIdentity(); 
    72  
    73                 //Inserts 
    74                 Map<Long, Long> vTree = vRecord.getValue().getPojo(); 
    75                 for (int i = 1; i <= vSize; i++) { 
    76                         Long vKey = fFactorySeqLong.newKey(); 
    77                         vTree.put(vKey, fFactorySeqLong.newValueFor(vKey)); 
    78                         vRecord.save(); 
    79                         checkSize(vTree, i); 
    80                 } 
    81                 checkSize(vTree, vSize); 
    82                 checkEntrySetIterator(vTree); 
    83                 checkAllEntries(vTree); 
    84  
    85                 //Sequential access 
    86                 forceNewDatabase(); 
    87                 vRecord = fDatabase.load(vId); 
    88                 vTree = vRecord.getValue().getPojo(); 
    89                 checkSize(vTree, vSize); 
    90                 checkAllEntries(vTree); 
    91  
    92                 //Unordered access 
    93                 forceNewDatabase(); 
    94                 vRecord = fDatabase.load(vId); 
    95                 vTree = vRecord.getValue().getPojo(); 
    96                 for (Iterator<Long> vIt = fFactorySeqLong.unorderedIterator(); vIt.hasNext();) { 
    97                         Long vKey = vIt.next(); 
    98                         fFactorySeqLong.checkValueForKey(vKey, vTree.get(vKey)); 
    99                 } 
    100  
    101                 //Remove entries 
    102                 forceNewDatabase(); 
    103                 vRecord = fDatabase.load(vId); 
    104                 vTree = vRecord.getValue().getPojo(); 
    105                 Long vKey = fFactorySeqLong.getUnorderedKeyToRemove(); 
    106                 while (vKey != null) { 
    107                         //System.out.println(vKey); 
    108                         vTree.remove(vKey); 
    109                         vRecord.save(); 
    110                         //                      forceNewDatabase(); 
    111                         //                      vRecord = fDatabase.load(vId); 
    112                         //                      vTree = vRecord.getValue().getPojo(); 
    113                         //                      checkSize(vTree, --vSize); 
    114                         //                      checkAllEntries(vTree); 
    115                         vKey = fFactorySeqLong.getUnorderedKeyToRemove(); 
    116                 } 
    117                 Assert.assertTrue(vTree.isEmpty()); 
    118         } 
    119  
    120         protected void checkSize(Map<Long, Long> pTree, int pSize) { 
    121                 if (TypesTreeTests.STORE_SIZE) { 
    122                         Assert.assertEquals(pTree.size(), pSize); 
    123                 } 
    124         } 
    125  
    126         protected void checkEntrySetIterator(Map<Long, Long> pTree) { 
    127                 int vCount = 0; 
    128                 for (Map.Entry<Long, Long> vEntry : pTree.entrySet()) { 
    129                         fFactorySeqLong.checkValueForKey(vEntry.getKey(), vEntry.getValue()); 
    130                         vCount++; 
    131                 } 
    132                 checkSize(pTree, vCount); 
    133         } 
    134  
    135         protected void checkAllEntries(Map<Long, Long> pTree) { 
    136                 int vCount = 0; 
    137                 for (Iterator<Long> vIt = fFactorySeqLong.creationOrderIterator(); vIt.hasNext();) { 
    138                         Long vKey = vIt.next(); 
    139                         fFactorySeqLong.checkValueForKey(vKey, pTree.get(vKey)); 
    140                         vCount++; 
    141                 } 
    142                 checkSize(pTree, vCount); 
    143  
     52        public void testIncrementalInserts() { 
     53                executeTest(new FactorySequentialLong(), TypesTreeTests.TREE_LL_INCR); 
    14454        } 
    14555 

  • trunk/Jav_Orient/test/eu/scenari/orient/tree/TreeBigIncrementalTest.java

    r19681 r19687  
    3939package eu.scenari.orient.tree; 
    4040 
    41 import java.util.Iterator; 
    42 import java.util.Map; 
    43  
    44 import junit.framework.Assert; 
    45  
    4641import org.junit.Test; 
    4742 
    48 import com.orientechnologies.orient.core.Orient; 
     43import eu.scenari.orient.tree.datafactory.FactorySequentialLong; 
    4944 
    50 import eu.scenari.orient.recordstruct.IRecordStruct; 
    51 import eu.scenari.orient.recordstruct.lib.tree.ValueTree; 
    52 import eu.scenari.orient.test.TestDbAbstract; 
    53 import eu.scenari.orient.tree.impl.RSTreeConcurrent; 
    54  
    55 public class TreeBigTest extends TestDbAbstract { 
    56  
    57         public static int MAP_SIZE = 1 * 1000000; 
    58  
    59         protected FactorySequentialLong fFactorySeqLong = new FactorySequentialLong(); 
     45public class TreeBigIncrementalTest extends TreeBigTestAbstract { 
    6046 
    6147        @Override 
    … …  
    6450 
    6551        @Test 
    66         public void test1() { 
    67                 int vSize = MAP_SIZE; 
    68                 fDatabase = fDbDriver.acquireDatabase(); 
    69                 IRecordStruct<ValueTree<Long, Long>> vRecord = fDatabase.newInstance(); 
    70                 vRecord.setValue((ValueTree) TypesTreeTests.TREE_LONG_LONG_C.toValue(null, vRecord)); 
    71                 vRecord.save(); 
    72                 Map<Long, Long> vTree = vRecord.getValue().getPojo(); 
    73                 Orient.instance().getMemoryWatchDog().addListener((RSTreeConcurrent) vTree); 
    74  
    75                 //Inserts 
    76                 for (int i = 1; i <= vSize; i++) { 
    77                         Long vKey = fFactorySeqLong.newKey(); 
    78                         vTree.put(vKey, fFactorySeqLong.newValueFor(vKey)); 
    79                         if (i % 100 == 0) { 
    80                                 vRecord.save(); 
    81                                 if (i % 10000 == 0) System.out.print('+'); 
    82                         } 
    83                 } 
    84                 vRecord.save(); 
    85                 System.out.println("[END INSERT]"); 
    86                 checkSize(vTree, vSize); 
    87                 System.out.println("[END CHECKSIZE]"); 
    88                 checkEntrySetIterator(vTree); 
    89                 System.out.println("[END CHECK ENTRY SET]"); 
    90                 checkAllEntries(vTree); 
    91                 System.out.println("[END CHECK ALL ENTRIES]"); 
    92  
    93                 //Unordered access 
    94                 for (Iterator<Long> vIt = fFactorySeqLong.unorderedIterator(); vIt.hasNext();) { 
    95                         Long vKey = vIt.next(); 
    96                         fFactorySeqLong.checkValueForKey(vKey, vTree.get(vKey)); 
    97                 } 
    98                 System.out.println("[END UNORDERED ACCESS]"); 
    99  
    100                 //Remove entries 
    101                 Long vKey = fFactorySeqLong.getUnorderedKeyToRemove(); 
    102                 int i = 0; 
    103                 while (vKey != null) { 
    104                         i++; 
    105                         //System.out.println(vKey); 
    106                         vTree.remove(vKey); 
    107                         if (i % 100 == 0) { 
    108                                 vRecord.save(); 
    109                                 if (i % 10000 == 0) System.out.print('-'); 
    110                         } 
    111                         //                      forceNewDatabase(); 
    112                         //                      vRecord = fDatabase.load(vId); 
    113                         //                      vTree = vRecord.getValue().getPojo(); 
    114                         //                      checkSize(vTree, --vSize); 
    115                         //                      checkAllEntries(vTree); 
    116                         vKey = fFactorySeqLong.getUnorderedKeyToRemove(); 
    117                 } 
    118                 vRecord.save(); 
    119                 Assert.assertTrue(vTree.isEmpty()); 
    120         } 
    121  
    122         protected void checkSize(Map<Long, Long> pTree, int pExpectedSize) { 
    123                 if (TypesTreeTests.STORE_SIZE) { 
    124                         Assert.assertEquals(pExpectedSize, pTree.size()); 
    125                 } 
    126         } 
    127  
    128         protected void checkEntrySetIterator(Map<Long, Long> pTree) { 
    129                 int vCount = 0; 
    130                 for (Map.Entry<Long, Long> vEntry : pTree.entrySet()) { 
    131                         fFactorySeqLong.checkValueForKey(vEntry.getKey(), vEntry.getValue()); 
    132                         vCount++; 
    133                 } 
    134                 checkSize(pTree, vCount); 
    135         } 
    136  
    137         protected void checkAllEntries(Map<Long, Long> pTree) { 
    138                 int vCount = 0; 
    139                 for (Iterator<Long> vIt = fFactorySeqLong.creationOrderIterator(); vIt.hasNext();) { 
    140                         Long vKey = vIt.next(); 
    141                         fFactorySeqLong.checkValueForKey(vKey, pTree.get(vKey)); 
    142                         vCount++; 
    143                 } 
    144                 checkSize(pTree, vCount); 
    145  
     52        public void testIncrementalInserts() { 
     53                executeTest(new FactorySequentialLong(), TypesTreeTests.TREE_LL_INCR_CONCUR); 
    14654        } 
    14755 

  • trunk/Jav_Orient/test/eu/scenari/orient/tree/TypesTreeTests.java

    r19680 r19687  
    1111        public static boolean STORE_SIZE = true; 
    1212 
    13         public static final TreeStorageConfig TREECONFIG_LONG_LONG = new TreeStorageConfig().setKeysStruct(TypesBase.LIST_LONG).setValuesStruct(TypesBase.LIST_LONG).setSizeStored(STORE_SIZE) 
     13        /** */ 
     14        public static final TreeStorageConfig TREECONFIG_LL_INCR = new TreeStorageConfig().setKeysStruct(TypesBase.LIST_LONG).setValuesStruct(TypesBase.LIST_LONG).setSizeStored(STORE_SIZE) 
    1415                        .setBalancingLayout(IBalancingLayout.DEFAULT_BALANCED_INCREMENTAL_INSERT).setRakeCapacity(32).setSlotCapacity(32); 
    1516 
    16         public static final TreeStorageConfig TREECONFIG_LONG_LONG_C = new TreeStorageConfig().setKeysStruct(TypesBase.LIST_LONG).setValuesStruct(TypesBase.LIST_LONG).setSizeStored(STORE_SIZE) 
     17        /** */ 
     18        public static final TreeStorageConfig TREECONFIG_LL_INCR_CONCUR = new TreeStorageConfig().setKeysStruct(TypesBase.LIST_LONG).setValuesStruct(TypesBase.LIST_LONG).setSizeStored(STORE_SIZE) 
    1719                        .setBalancingLayout(IBalancingLayout.DEFAULT_BALANCED_INCREMENTAL_INSERT).setRakeCapacity(256).setSlotCapacity(256).setTreeThreadSafe(true); 
    1820 
    19         public static final StructTree TREE_LONG_LONG = new StructTree(new ExtendedStructId(1, 1), "treeLongLong").setTreeConfig(TREECONFIG_LONG_LONG); 
     21        /** */ 
     22        public static final TreeStorageConfig TREECONFIG_LL_RANDOM = new TreeStorageConfig().setKeysStruct(TypesBase.LIST_LONG).setValuesStruct(TypesBase.LIST_LONG).setSizeStored(STORE_SIZE).setBalancingLayout(IBalancingLayout.DEFAULT_BALANCED_RANDOM_INSERT) 
     23                        .setRakeCapacity(32).setSlotCapacity(32); 
    2024 
    21         public static final StructTree TREE_LONG_LONG_C = new StructTree(new ExtendedStructId(1, 2), "treeLongLong_C").setTreeConfig(TREECONFIG_LONG_LONG_C); 
     25        /** */ 
     26        public static final TreeStorageConfig TREECONFIG_LL_RANDOM_CONCUR = new TreeStorageConfig().setKeysStruct(TypesBase.LIST_LONG).setValuesStruct(TypesBase.LIST_LONG).setSizeStored(STORE_SIZE) 
     27                        .setBalancingLayout(IBalancingLayout.DEFAULT_BALANCED_RANDOM_INSERT).setRakeCapacity(256).setSlotCapacity(256).setTreeThreadSafe(true); 
     28 
     29        public static final StructTree TREE_LL_INCR = new StructTree(new ExtendedStructId(1, 1), "LL_INCR").setTreeConfig(TREECONFIG_LL_INCR); 
     30 
     31        public static final StructTree TREE_LL_INCR_CONCUR = new StructTree(new ExtendedStructId(1, 2), "LL_INCR_CONCUR").setTreeConfig(TREECONFIG_LL_INCR_CONCUR); 
     32 
     33        public static final StructTree TREE_LL_RANDOM = new StructTree(new ExtendedStructId(1, 3), "LL_RANDOM").setTreeConfig(TREECONFIG_LL_RANDOM); 
     34 
     35        public static final StructTree TREE_LL_RANDOM_CONCUR = new StructTree(new ExtendedStructId(1, 4), "LL_RANDOM_CONCUR").setTreeConfig(TREECONFIG_LL_RANDOM_CONCUR); 
    2236 
    2337} 

  • trunk/Jav_Orient/test/eu/scenari/orient/tree/datafactory/FactorySequentialLong.java

    r19678 r19687  
    1 package eu.scenari.orient.tree; 
     1package eu.scenari.orient.tree.datafactory; 
    22 
    33import java.util.Iterator; 
    … …  
    99import eu.scenari.commons.util.lang.ScException; 
    1010 
    11 public class FactorySequentialLong implements IKeyFactory<Long>, IValueFactory<Long> { 
     11public class FactorySequentialLong implements IKVFactory<Long, Long> { 
    1212 
    1313        protected long fStartValue = 1; 
    … …  
    5959                } 
    6060 
     61                public Long next() { 
     62                        return tranfsormValue(super.next()); 
     63                } 
     64 
    6165                public boolean isAlreadyReturned(Long pEntry) { 
    6266                        long vModulo = (pEntry.longValue() - fStartValue) % (long) fBase; 
    … …  
    7175        public Long newKey() { 
    7276                if (fRemovedKeys != null) throw new ScException("Removes keys is started, create new keys not allowed."); 
    73                 return fCounter.getAndIncrement(); 
     77                return tranfsormValue(fCounter.getAndIncrement()); 
    7478        } 
    7579 
    7680        public Long peekRandomKey() { 
    77                 return (long) fRandom.nextInt((int) (fCounter.get() + 1)); 
     81                return tranfsormValue((long) fRandom.nextInt((int) (fCounter.get() + 1))); 
    7882        } 
    7983 
    … …  
    100104                                return (fNext != null); 
    101105                        } 
     106 
     107                        public Long next() { 
     108                                return tranfsormValue(super.next()); 
     109                        } 
    102110                }; 
    103111        } 
    … …  
    107115                return fRemovedKeys.hasNext() ? fRemovedKeys.next() : null; 
    108116        } 
     117 
     118        protected Long tranfsormValue(Long pValue) { 
     119                return pValue; 
     120        } 
     121 
     122        //##### 
    109123 
    110124        public Long newValueFor(Object pKey) { 

  • trunk/Jav_Orient/test/eu/scenari/orient/tree/datafactory/FactorySequentialLongTest.java

    r19678 r19687  
    1 package eu.scenari.orient.tree; 
     1package eu.scenari.orient.tree.datafactory; 
    22 
    33import java.util.HashSet; 
    … …  
    1111 
    1212        @Test 
    13         public void testUnorderedIterator() { 
     13        public void testFactorySequentialLong() { 
    1414                FactorySequentialLong vFact = new FactorySequentialLong(); 
    1515                HashSet vKeys = new HashSet(); 
    16                 for (int i = 0; i < 253; i++) { 
     16                for (int i = 0; i < 5304; i++) { 
     17                        vKeys.add(vFact.newKey()); 
     18                } 
     19 
     20                checkCreationOrderIt(vFact, new HashSet(vKeys)); 
     21                checkUnorderedIt(vFact, new HashSet(vKeys)); 
     22 
     23                Long vKeyToRemove = vFact.getUnorderedKeyToRemove(); 
     24                while (vKeyToRemove != null) { 
     25                        vKeys.remove(vKeyToRemove); 
     26                        checkCreationOrderIt(vFact, new HashSet(vKeys)); 
     27                        checkUnorderedIt(vFact, new HashSet(vKeys)); 
     28                        vKeyToRemove = vFact.getUnorderedKeyToRemove(); 
     29                } 
     30                Assert.assertEquals(0, vKeys.size()); 
     31        } 
     32 
     33        @Test 
     34        public void testFactoryUnorderedLong() { 
     35                FactorySequentialLong vFact = new FactoryUnorderedLong(); 
     36                HashSet vKeys = new HashSet(); 
     37                for (int i = 0; i < 5304; i++) { 
    1738                        vKeys.add(vFact.newKey()); 
    1839                } 
    … …  
    4869                Assert.assertEquals(0, pKeys.size()); 
    4970        } 
     71 
    5072} 

  • trunk/Jav_Orient/test/eu/scenari/orient/tree/datafactory/IKeyFactory.java

    r19678 r19687  
    1 package eu.scenari.orient.tree; 
     1package eu.scenari.orient.tree.datafactory; 
    22 
    33import java.util.Iterator; 

  • trunk/Jav_Orient/test/eu/scenari/orient/tree/datafactory/IValueFactory.java

    r19672 r19687  
    1 package eu.scenari.orient.tree; 
     1package eu.scenari.orient.tree.datafactory; 
    22 
    33public interface IValueFactory<V> { 

  • trunk/Jav_Orient/test/eu/scenari/orient/tree/perf/MVRBTreePerfTest.java

    r19678 r19687  
    1414 
    1515import eu.scenari.orient.test.TestDbAbstract; 
    16 import eu.scenari.orient.tree.FactorySequentialLong; 
     16import eu.scenari.orient.tree.datafactory.FactorySequentialLong; 
    1717 
    1818public class MVRBTreePerfTest extends TestDbAbstract { 
Note: See TracChangeset for help on using the changeset viewer.