Structs, Classes and Cache Efficiency

[arpieParticipant]

I recently bought this book : http://gameprogrammingpatterns.com/ and was fascinated by this chapter in particular: http://gameprogrammingpatterns.com/data-locality.html

TLDR: improving data locality can improve cache efficiency and can have enormous effects on speed of execution.

I wondered if I could find a significant difference between using arrays of Structs vs using arrays of Class objects in Monkey2 as Class object arrays are (afaik) arrays of pointers, wheras arrays of Structs ar stored in contiguous memory.  Once I got it right, the results were surprising.

It seems to be that Structs are a lot faster (up to 20x faster!) than Class objects for large numbers (thousands) of entities, and coding to optimise data locality is potentially worth considering… but this is a dark art and we all know not to waste time prematurely optimising code.

I would be delighted if we ever get a reasonably safe way to use pointers into arrays of Structs but as far as I understand this is difficult to achieve in Monkey2 (using the undocumented (?) varptr and ptr).

Your comments, results on other hardware, critiques of my code, etc. will be very welcome.

This is the code I ended up with (NOTE: You must run it in release mode to get accurate results).  Hopefully the comments in the code will make it clear what is happening :

Monkey

#Import "<std>" #Import "<mojo>" Using std.. Class TestClass Field thing:Int End Class Struct TestStruct Field thing:Int End Struct Function Main() 'Run tests for different sized arrays, increasing each time by a factor 'of ten. Stop the tests if/when your machine starts to struggle! For Local i := 2 To 6 'That's 100, 1000, 10000, 100000 and 1million RunTest(Pow(10, i)) Next End Function RunTest(n:Int) 'Variable for timing measurements Local t0:Int Print("") Print("") Print("Initialising test using " + n + " array members. Please wait...") 'Seed the RNG '============ 'Try to seed the RNG as randomly as possible (probably this is overkill!). While (Millisecs() < 10) Local seed:Int = Millisecs() + Microsecs() SeedRnd(seed) Print(Rnd()) Sleep(Rnd()) End While 'Generate some random numbers for random array access testing '============================================================ 'We generate two arrays in advance : 'One contains ordered numbers (ie array[x] = x) and 'The other contains random numbers (ie. array[x] = Rnd()) 'This way, both sets of tests will produce timings that can be directly compared with 'each other without skewing results with extra array lookups or calls to Rnd(). Local ordered := New Int[n] Local random := New Int[n] For Local i := 0 To n-1 ordered[i] = i random[i] = Rnd(n-1) Next 'Generate an array of TestClass objects, all in quick succession '=============================================================== 'This method of allocating memory for the array should maximise 'the likelyhood of objects being allocated contiguously in memory. 'This should allow the most efficient array operations. Local classarray1 := New TestClass[n] For Local i := 0 To n-1 classarray1[i] = New TestClass() Next 'Generate an array of TestClass objects, with junk allocations between array members '=================================================================================== 'This method of allocating memory for the array should spread the objects out and 'reduce the likelyhood of neighbouring array members being cached during array 'operations, causing a lot of cache misses and slowness. I think this will most 'closely simulate common coding practices where a pool is not used for allocating 'new entities as and when needed. Local classarray2 := New TestClass[n] For Local i := 0 To n-1 classarray2[i] = New TestClass() 'Now allocate a bunch of new classes without assigning them to anything to fill 'some space between real array members For Local i := 0 To 100 New TestClass() Next Next 'Generate an array of TestClass objects, in a random order '========================================================= 'This will keep the array within a localised area of memory but will still 'degrade performance by causing a lot of cache misses. 'This should perform slower than classarray1 but faster than classarray2 'and is mostly here just to confirm that my theory of what is happening is correct. Local classarray3 := New TestClass[n] For Local i := 0 To n-1 'Random order Class instantiation classarray3[Rnd(n-1)] = New TestClass() Next For Local i := 0 To n-1 ' Now fill in any gaps in that random set of objects If classarray3[i] = Null Then classarray3[i] = New TestClass() Next 'Generate an array of TestStruct objects '======================================= 'These objects will be generated in a nice, neat contiguous chunk, this being 'one of the advantages of Structs over Classes. It should be lightning fast 'for array operations, being the most cache efficient and having the fewest 'indirections (probably!) in the generated C code. Local structarray := New TestStruct[n] 'Run the tests '============= 'All tests perform a very simple array operation (adding 1 to the object 'thing' 'field). The intention is to measure as closely as possible the cost of array 'lookups without any avoidable overhead caused by actually doing anything to the 'array objects. 'Each test performs the same operation on consecutive or random array members, 'looping continuously over the array until ten million operations have been 'performed, thus allowing all timings to be directly compared (in theory!). Print "" Print "Testing rate of linear access of all array members." t0 = Millisecs() For Local i := 0 To 10000000/n For Local j := 0 To n-1 classarray1[ordered[j]].thing += 1 Next Next Print("Linear ClassArray1 access took " + (Millisecs() - t0) + "ms") t0 = Millisecs() For Local i := 0 To 10000000/n For Local j := 0 To n-1 classarray2[ordered[j]].thing += 1 Next Next Print("Linear ClassArray2 access took " + (Millisecs() - t0) + "ms") t0 = Millisecs() For Local i := 0 To 10000000/n For Local j := 0 To n-1 classarray3[ordered[j]].thing += 1 Next Next Print("Linear ClassArray3 access took " + (Millisecs() - t0) + "ms") t0 = Millisecs() For Local i := 0 To 10000000/n For Local j := 0 To n-1 structarray[ordered[j]].thing += 1 Next Next Print("Linear StructArray access took " + (Millisecs() - t0) + "ms") Print "" Print "Testing rate of random access of array members." t0 = Millisecs() For Local i := 0 To 10000000/n For Local j := 0 To n-1 classarray1[random[j]].thing += 1 Next Next Print("Random ClassArray1 access took " + (Millisecs() - t0) + "ms") t0 = Millisecs() For Local i := 0 To 10000000/n For Local j := 0 To n-1 classarray2[random[j]].thing += 1 Next Next Print("Random ClassArray2 access took " + (Millisecs() - t0) + "ms") t0 = Millisecs() For Local i := 0 To 10000000/n For Local j := 0 To n-1 classarray3[random[j]].thing += 1 Next Next Print("Random ClassArray3 access took " + (Millisecs() - t0) + "ms") t0 = Millisecs() For Local i := 0 To 10000000/n For Local j := 0 To n-1 structarray[random[j]].thing += 1 Next Next Print("Random StructArray access took " + (Millisecs() - t0) + "ms") End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191

#Import "<std>" #Import "<mojo>"   Using std..   Class TestClass   Field thing:Int End Class   Struct TestStruct   Field thing:Int End Struct   Function Main()   'Run tests for different sized arrays, increasing each time by a factor   'of ten.  Stop the tests if/when your machine starts to struggle!   For Local i := 2 To 6 'That's 100, 1000, 10000, 100000 and 1million     RunTest(Pow(10, i))   Next End   Function RunTest(n:Int)   'Variable for timing measurements   Local t0:Int     Print("")   Print("")   Print("Initialising test using " + n + " array members.  Please wait...")      'Seed the RNG   '============   'Try to seed the RNG as randomly as possible (probably this is overkill!).   While (Millisecs() < 10)     Local seed:Int = Millisecs() + Microsecs()     SeedRnd(seed)     Print(Rnd())     Sleep(Rnd())   End While      'Generate some random numbers for random array access testing   '============================================================   'We generate two arrays in advance :   'One contains ordered numbers (ie array[x] = x) and   'The other contains random numbers (ie. array[x] = Rnd())   'This way, both sets of tests will produce timings that can be directly compared with   'each other without skewing results with extra array lookups or calls to Rnd().   Local ordered := New Int[n]   Local random := New Int[n]   For Local i := 0 To n-1     ordered[i] = i     random[i] = Rnd(n-1)   Next         'Generate an array of TestClass objects, all in quick succession   '===============================================================   'This method of allocating memory for the array should maximise   'the likelyhood of objects being allocated contiguously in memory.   'This should allow the most efficient array operations.   Local classarray1 := New TestClass[n]   For Local i := 0 To n-1     classarray1[i] = New TestClass()   Next         'Generate an array of TestClass objects, with junk allocations between array members   '===================================================================================   'This method of allocating memory for the array should spread the objects out and   'reduce the likelyhood of neighbouring array members being cached during array   'operations, causing a lot of cache misses and slowness.  I think this will most   'closely simulate common coding practices where a pool is not used for allocating   'new entities as and when needed.   Local classarray2 := New TestClass[n]   For Local i := 0 To n-1     classarray2[i] = New TestClass()     'Now allocate a bunch of new classes without assigning them to anything to fill     'some space between real array members     For Local i := 0 To 100       New TestClass()     Next   Next         'Generate an array of TestClass objects, in a random order   '=========================================================   'This will keep the array within a localised area of memory but will still   'degrade performance by causing a lot of cache misses.   'This should perform slower than classarray1 but faster than classarray2   'and is mostly here just to confirm that my theory of what is happening is correct.   Local classarray3 := New TestClass[n]   For Local i := 0 To n-1     'Random order Class instantiation     classarray3[Rnd(n-1)] = New TestClass()   Next   For Local i := 0 To n-1     ' Now fill in any gaps in that random set of objects     If classarray3[i] = Null Then classarray3[i] = New TestClass()   Next         'Generate an array of TestStruct objects   '=======================================   'These objects will be generated in a nice, neat contiguous chunk, this being   'one of the advantages of Structs over Classes.  It should be lightning fast   'for array operations, being the most cache efficient and having the fewest   'indirections (probably!) in the generated C code.   Local structarray := New TestStruct[n]         'Run the tests   '=============   'All tests perform a very simple array operation (adding 1 to the object 'thing'   'field).  The intention is to measure as closely as possible the cost of array   'lookups without any avoidable overhead caused by actually doing anything to the   'array objects.     'Each test performs the same operation on consecutive or random array members,   'looping continuously over the array until ten million operations have been   'performed, thus allowing all timings to be directly compared (in theory!).   Print ""   Print "Testing rate of linear access of all array members."        t0 = Millisecs()   For Local i := 0 To 10000000/n     For Local j := 0 To n-1       classarray1[ordered[j]].thing += 1     Next   Next   Print("Linear ClassArray1 access took " + (Millisecs() - t0) + "ms")      t0 = Millisecs()   For Local i := 0 To 10000000/n     For Local j := 0 To n-1       classarray2[ordered[j]].thing += 1     Next   Next   Print("Linear ClassArray2 access took " + (Millisecs() - t0) + "ms")      t0 = Millisecs()   For Local i := 0 To 10000000/n     For Local j := 0 To n-1       classarray3[ordered[j]].thing += 1     Next   Next   Print("Linear ClassArray3 access took " + (Millisecs() - t0) + "ms")      t0 = Millisecs()   For Local i := 0 To 10000000/n     For Local j := 0 To n-1       structarray[ordered[j]].thing += 1     Next   Next   Print("Linear StructArray access took " + (Millisecs() - t0) + "ms")           Print ""   Print "Testing rate of random access of array members."      t0 = Millisecs()   For Local i := 0 To 10000000/n     For Local j := 0 To n-1       classarray1[random[j]].thing += 1     Next   Next   Print("Random ClassArray1 access took " + (Millisecs() - t0) + "ms")      t0 = Millisecs()   For Local i := 0 To 10000000/n     For Local j := 0 To n-1       classarray2[random[j]].thing += 1     Next   Next   Print("Random ClassArray2 access took " + (Millisecs() - t0) + "ms")      t0 = Millisecs()   For Local i := 0 To 10000000/n     For Local j := 0 To n-1       classarray3[random[j]].thing += 1     Next   Next   Print("Random ClassArray3 access took " + (Millisecs() - t0) + "ms")      t0 = Millisecs()   For Local i := 0 To 10000000/n     For Local j := 0 To n-1       structarray[random[j]].thing += 1     Next   Next   Print("Random StructArray access took " + (Millisecs() - t0) + "ms")    End

 

And the results on my i5-powered laptop are :

Initialising test using 100 array members. Please wait... 0.41406254938420939 Testing rate of linear access of all array members. Linear ClassArray1 access took 8ms Linear ClassArray2 access took 11ms Linear ClassArray3 access took 8ms Linear StructArray access took 7ms Testing rate of random access of array members. Random ClassArray1 access took 8ms Random ClassArray2 access took 9ms Random ClassArray3 access took 9ms Random StructArray access took 6ms Initialising test using 1000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 19ms Linear ClassArray2 access took 66ms Linear ClassArray3 access took 19ms Linear StructArray access took 6ms Testing rate of random access of array members. Random ClassArray1 access took 11ms Random ClassArray2 access took 16ms Random ClassArray3 access took 12ms Random StructArray access took 6ms Initialising test using 10000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 29ms Linear ClassArray2 access took 96ms Linear ClassArray3 access took 29ms Linear StructArray access took 7ms Testing rate of random access of array members. Random ClassArray1 access took 34ms Random ClassArray2 access took 66ms Random ClassArray3 access took 36ms Random StructArray access took 9ms Initialising test using 100000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 90ms Linear ClassArray2 access took 264ms Linear ClassArray3 access took 164ms Linear StructArray access took 7ms Testing rate of random access of array members. Random ClassArray1 access took 161ms Random ClassArray2 access took 272ms Random ClassArray3 access took 252ms Random StructArray access took 25ms Initialising test using 1000000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 127ms Linear ClassArray2 access took 291ms Linear ClassArray3 access took 261ms Linear StructArray access took 16ms Testing rate of random access of array members. Random ClassArray1 access took 1340ms Random ClassArray2 access took 1675ms Random ClassArray3 access took 980ms Random StructArray access took 86ms Finished running app.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

Initialising test using 100 array members.  Please wait... 0.41406254938420939   Testing rate of linear access of all array members. Linear ClassArray1 access took 8ms Linear ClassArray2 access took 11ms Linear ClassArray3 access took 8ms Linear StructArray access took 7ms   Testing rate of random access of array members. Random ClassArray1 access took 8ms Random ClassArray2 access took 9ms Random ClassArray3 access took 9ms Random StructArray access took 6ms     Initialising test using 1000 array members.  Please wait...   Testing rate of linear access of all array members. Linear ClassArray1 access took 19ms Linear ClassArray2 access took 66ms Linear ClassArray3 access took 19ms Linear StructArray access took 6ms   Testing rate of random access of array members. Random ClassArray1 access took 11ms Random ClassArray2 access took 16ms Random ClassArray3 access took 12ms Random StructArray access took 6ms     Initialising test using 10000 array members.  Please wait...   Testing rate of linear access of all array members. Linear ClassArray1 access took 29ms Linear ClassArray2 access took 96ms Linear ClassArray3 access took 29ms Linear StructArray access took 7ms   Testing rate of random access of array members. Random ClassArray1 access took 34ms Random ClassArray2 access took 66ms Random ClassArray3 access took 36ms Random StructArray access took 9ms     Initialising test using 100000 array members.  Please wait...   Testing rate of linear access of all array members. Linear ClassArray1 access took 90ms Linear ClassArray2 access took 264ms Linear ClassArray3 access took 164ms Linear StructArray access took 7ms   Testing rate of random access of array members. Random ClassArray1 access took 161ms Random ClassArray2 access took 272ms Random ClassArray3 access took 252ms Random StructArray access took 25ms     Initialising test using 1000000 array members.  Please wait...   Testing rate of linear access of all array members. Linear ClassArray1 access took 127ms Linear ClassArray2 access took 291ms Linear ClassArray3 access took 261ms Linear StructArray access took 16ms   Testing rate of random access of array members. Random ClassArray1 access took 1340ms Random ClassArray2 access took 1675ms Random ClassArray3 access took 980ms Random StructArray access took 86ms   Finished running app.

[arpieParticipant]

And on my Sony Xperia D5803 running Android 6.0.1 the results aren’t too shabby either :

Initialising test using 100 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 74ms Linear ClassArray2 access took 67ms Linear ClassArray3 access took 50ms Linear StructArray access took 38ms Testing rate of random access of array members. Random ClassArray1 access took 69ms Random ClassArray2 access took 74ms Random ClassArray3 access took 47ms Random StructArray access took 27ms Initialising test using 1000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 106ms Linear ClassArray2 access took 320ms Linear ClassArray3 access took 105ms Linear StructArray access took 38ms Testing rate of random access of array members. Random ClassArray1 access took 99ms Random ClassArray2 access took 351ms Random ClassArray3 access took 102ms Random StructArray access took 28ms Initialising test using 10000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 85ms Linear ClassArray2 access took 418ms Linear ClassArray3 access took 121ms Linear StructArray access took 50ms Testing rate of random access of array members. Random ClassArray1 access took 260ms Random ClassArray2 access took 673ms Random ClassArray3 access took 232ms Random StructArray access took 108ms Initialising test using 100000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 166ms Linear ClassArray2 access took 746ms Linear ClassArray3 access took 603ms Linear StructArray access took 51ms Testing rate of random access of array members. Random ClassArray1 access took 983ms Random ClassArray2 access took 1218ms Random ClassArray3 access took 1257ms Random StructArray access took 154ms Initialising test using 1000000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 295ms Linear ClassArray2 access took 832ms Linear ClassArray3 access took 819ms Linear StructArray access took 57ms Testing rate of random access of array members. Random ClassArray1 access took 1886ms Random ClassArray2 access took 1923ms Random ClassArray3 access took 1964ms Random StructArray access took 688ms

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

Initialising test using 100 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 74ms Linear ClassArray2 access took 67ms Linear ClassArray3 access took 50ms Linear StructArray access took 38ms Testing rate of random access of array members. Random ClassArray1 access took 69ms Random ClassArray2 access took 74ms Random ClassArray3 access took 47ms Random StructArray access took 27ms   Initialising test using 1000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 106ms Linear ClassArray2 access took 320ms Linear ClassArray3 access took 105ms Linear StructArray access took 38ms Testing rate of random access of array members. Random ClassArray1 access took 99ms Random ClassArray2 access took 351ms Random ClassArray3 access took 102ms Random StructArray access took 28ms   Initialising test using 10000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 85ms Linear ClassArray2 access took 418ms Linear ClassArray3 access took 121ms Linear StructArray access took 50ms Testing rate of random access of array members. Random ClassArray1 access took 260ms Random ClassArray2 access took 673ms Random ClassArray3 access took 232ms Random StructArray access took 108ms   Initialising test using 100000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 166ms Linear ClassArray2 access took 746ms Linear ClassArray3 access took 603ms Linear StructArray access took 51ms Testing rate of random access of array members. Random ClassArray1 access took 983ms Random ClassArray2 access took 1218ms Random ClassArray3 access took 1257ms Random StructArray access took 154ms   Initialising test using 1000000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 295ms Linear ClassArray2 access took 832ms Linear ClassArray3 access took 819ms Linear StructArray access took 57ms Testing rate of random access of array members. Random ClassArray1 access took 1886ms Random ClassArray2 access took 1923ms Random ClassArray3 access took 1964ms Random StructArray access took 688ms

[arpieParticipant]

Finally, here are some results on a 2-year-old lenovo yoga B8000 android tablet. Not sure why the last line is missing.

Monkey

Initialising test using 100 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 124ms Linear ClassArray2 access took 129ms Linear ClassArray3 access took 110ms Linear StructArray access took 91ms Testing rate of random access of array members. Random ClassArray1 access took 118ms Random ClassArray2 access took 140ms Random ClassArray3 access took 111ms Random StructArray access took 84ms Initialising test using 1000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 122ms Linear ClassArray2 access took 322ms Linear ClassArray3 access took 180ms Linear StructArray access took 86ms Testing rate of random access of array members. Random ClassArray1 access took 129ms Random ClassArray2 access took 262ms Random ClassArray3 access took 181ms Random StructArray access took 86ms Initialising test using 9999 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 240ms Linear ClassArray2 access took 1452ms Linear ClassArray3 access took 388ms Linear StructArray access took 94ms Testing rate of random access of array members. Random ClassArray1 access took 359ms Random ClassArray2 access took 537ms Random ClassArray3 access took 365ms Random StructArray access took 121ms Initialising test using 100000 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 495ms Linear ClassArray2 access took 1753ms Linear ClassArray3 access took 1522ms Linear StructArray access took 144ms Testing rate of random access of array members. Random ClassArray1 access took 2166ms Random ClassArray2 access took 2673ms Random ClassArray3 access took 2533ms Random StructArray access took 285ms Initialising test using 999999 array members. Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 736ms Linear ClassArray2 access took 1974ms Linear ClassArray3 access took 1981ms Linear StructArray access took 284ms Testing rate of random access of array members. Random ClassArray1 access took 3813ms Random ClassArray2 access took 3969ms Random ClassArray3 access took 4201ms

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

Initialising test using 100 array members.  Please wait...   Testing rate of linear access of all array members. Linear ClassArray1 access took 124ms Linear ClassArray2 access took 129ms Linear ClassArray3 access took 110ms Linear StructArray access took 91ms Testing rate of random access of array members. Random ClassArray1 access took 118ms Random ClassArray2 access took 140ms Random ClassArray3 access took 111ms Random StructArray access took 84ms   Initialising test using 1000 array members.  Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 122ms Linear ClassArray2 access took 322ms Linear ClassArray3 access took 180ms Linear StructArray access took 86ms Testing rate of random access of array members. Random ClassArray1 access took 129ms Random ClassArray2 access took 262ms Random ClassArray3 access took 181ms Random StructArray access took 86ms   Initialising test using 9999 array members.  Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 240ms Linear ClassArray2 access took 1452ms Linear ClassArray3 access took 388ms Linear StructArray access took 94ms Testing rate of random access of array members. Random ClassArray1 access took 359ms Random ClassArray2 access took 537ms Random ClassArray3 access took 365ms Random StructArray access took 121ms   Initialising test using 100000 array members.  Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 495ms Linear ClassArray2 access took 1753ms Linear ClassArray3 access took 1522ms Linear StructArray access took 144ms Testing rate of random access of array members. Random ClassArray1 access took 2166ms Random ClassArray2 access took 2673ms Random ClassArray3 access took 2533ms Random StructArray access took 285ms   Initialising test using 999999 array members.  Please wait... Testing rate of linear access of all array members. Linear ClassArray1 access took 736ms Linear ClassArray2 access took 1974ms Linear ClassArray3 access took 1981ms Linear StructArray access took 284ms Testing rate of random access of array members. Random ClassArray1 access took 3813ms Random ClassArray2 access took 3969ms Random ClassArray3 access took 4201ms

[Author]

Posts