Copying arrays FOR vs _MEMCOPY

[TempodiBasic]

Hi Guys

Learning  _MEM and its cousins _MEM() _MEMPUT _MEMGET _MEMCOPY _MEMNEW etc etc
seeing how to make a copy of array1 into array2 and following Steve's Wiki instructions
i wrote this code...
but on my TOSHIBA the time that I get is the same with the two methods, while surely the code more simple is _MEM.
Here the code

Code: QB64: [Select]

1.  
2.  
3. DIM a(100, 100) AS INTEGER
4. DIM b(100, 100) AS INTEGER
5.  
6. PRINT " COPY Array by FOR"
7. oldt1 = TIMER
8. SLEEP 2
9. initaz
10. showarray
11. SLEEP 2
12. copyArrayFor
13. showarray
14. SLEEP 2
15. oldt1 = TIMER - oldt1
16. PRINT oldt1
17. SLEEP 4
18. PRINT " COPY Array by _MEMCOPY"
19. oldt2 = TIMER
20. SLEEP 2
21. initaz
22. showarray
23. SLEEP 2
24. CopyArrayMEM
25. showarray
26. SLEEP 2
27. oldt2 = TIMER - oldt2
28. PRINT oldt2
29. SLEEP 2
30. PRINT "CopyFor = "; oldt1; " Copy_MEM = "; oldt2
31. END
32.  
33.  
34. SUB initaz
35.     SHARED a() AS INTEGER, b() AS INTEGER
36.     '--INITIALIZTION
37.     PRINT "INITALIZATION"
38.     FOR i1 = 0 TO 100
39.         FOR i2 = 0 TO 100
40.             b(i1, i2) = i1
41.             a(i1, i2) = 999
42.         NEXT
43.     NEXT
44. END SUB
45.  
46. SUB showarray
47.     SHARED a() AS INTEGER, b() AS INTEGER
48.     PRINT "SHOWING ARRAYS  B   A "
49.     FOR i1 = 0 TO 100
50.         FOR i2 = 0 TO 100
51.             PRINT b(i1, i2), a(i1, i2)
52.         NEXT
53.     NEXT
54. END SUB
55.  
56. SUB copyArrayFor
57.     SHARED a() AS INTEGER, b() AS INTEGER
58.     'copy array a to array b one index at a time:
59.     'FOR...NEXT|
60.     FOR i1 = 0 TO 100
61.         'FOR...NEXT|
62.         FOR i2 = 0 TO 100
63.             b(i1, i2) = a(i1, i2)
64.         NEXT
65.     NEXT
66. END SUB
67.  
68. SUB CopyArrayMEM
69.     SHARED a() AS INTEGER, b() AS INTEGER
70.     'copy array a to array b in memory instantly:
71.  
72.     DIM ma AS _MEM: ma = _MEM(a()) 'place array data into blocks
73.     DIM mb AS _MEM: mb = _MEM(b())
74.     _MEMCOPY ma, ma.OFFSET, ma.SIZE TO mb, mb.OFFSET
75.     _MEMFREE ma: _MEMFREE mb 'clear the memory when done
76. END SUB
77.  

Well, surely there is a better code to use _MEM. But How?

[SMcNeill]

The problem here isn't in the copying routines; the problem is with the method used to time the copying...

Lots of SLEEP statements, along with the initialization of the first array, and then printing to the screen... All these things take up time which makes it hard to see what, if any, change the switch from FOR to _MEMCOPY does for your program.

Taking the SLEEP, initialize, and PRINT statements out, and just timing the copy routines themselves, and changing the routines to work off a larger loop limit to highlight the differences, and what we see is the following:

Code: QB64: [Select]

1.  
2. CONST TestLimit = 10000
3. DIM a(TestLimit, TestLimit) AS INTEGER
4. DIM b(TestLimit, TestLimit) AS INTEGER
5. DIM SHARED ma1 AS _MEM
6. DIM SHARED mb1 AS _MEM
7.  
8.  
9. PRINT " COPY Array by FOR"
10. initaz
11. oldt1 = TIMER(0.001)
12. copyArrayFor
13. 'showarray
14. oldt1 = TIMER(0.001) - oldt1
15. PRINT oldt1
16.  
17. PRINT " COPY Array by _MEMCOPY"
18. initaz
19. oldt2 = TIMER(0.001)
20. CopyArrayMEM
21. 'showarray
22. oldt2 = TIMER(0.001) - oldt2
23. PRINT oldt2
24.  
25. PRINT "CopyFor = "; oldt1; " Copy_MEM = "; oldt2
26.  
27. END
28.  
29.  
30. SUB initaz
31.     SHARED a() AS INTEGER, b() AS INTEGER
32.     '--INITIALIZTION
33.     PRINT "INITALIZATION"
34.     FOR i1 = 0 TO TestLimit
35.         FOR i2 = 0 TO TestLimit
36.             b(i1, i2) = i1
37.             a(i1, i2) = 999
38.         NEXT
39.     NEXT
40. END SUB
41.  
42. SUB showarray
43.     SHARED a() AS INTEGER, b() AS INTEGER
44.     PRINT "SHOWING ARRAYS  B   A "
45.     FOR i1 = 0 TO TestLimit
46.         FOR i2 = 0 TO TestLimit
47.             PRINT b(i1, i2), a(i1, i2)
48.         NEXT
49.     NEXT
50. END SUB
51.  
52. SUB copyArrayFor
53.     SHARED a() AS INTEGER, b() AS INTEGER
54.     'copy array a to array b one index at a time:
55.     'FOR...NEXT|
56.     FOR i1 = 0 TO TestLimit
57.         'FOR...NEXT|
58.         FOR i2 = 0 TO TestLimit
59.             b(i1, i2) = a(i1, i2)
60.         NEXT
61.     NEXT
62. END SUB
63.  
64. SUB CopyArrayMEM
65.     SHARED a() AS INTEGER, b() AS INTEGER
66.     'copy array a to array b in memory instantly:
67.  
68.     DIM ma AS _MEM: ma = _MEM(a()) 'place array data into blocks
69.     DIM mb AS _MEM: mb = _MEM(b())
70.     _MEMCOPY ma, ma.OFFSET, ma.SIZE TO mb, mb.OFFSET
71.     _MEMFREE ma: _MEMFREE mb 'clear the memory when done
72. END SUB
73.  

7.7 seconds for the FOR LOOP to copy the arrays.
0.03 seconds for the _MEMCOPY to do its thing.

I think that shows a good comparison of which one might be a little more faster for our programs. 

[TempodiBasic]

Thanks Steve

I must agree with you that I have done a SLEEPed use of _MEM...
:-)
IMHO the whole structure of code wins over single instructions

Thanks again

[TempodiBasic]

Hi Steve

agreeing about the speedy of _MEM and the slowness of FOR...NEXT
here I post a code to show the one situation on which I think coders must prefer FOR...NEXT to _MEM

Code: QB64: [Select]

1.  
2. OPTION BASE 1
3. REDIM a(5, 3) AS INTEGER
4. DIM b(UBOUND(a, 1), UBOUND(a, 2)) AS INTEGER
5.  
6. initaz
7. PRINT "Array A  ";
8. showarray a()
9. PRINT " Array B  ";
10. showarray b()
11. SLEEP 2
12. PRINT "Saving orginal array data "
13. copyArray a(), b()
14. showarray b()
15. PRINT "press a key";: SLEEP: CLS
16. PRINT " REDIM array A with _PRESERVE  "
17. REDIM _PRESERVE a(7, 6) AS INTEGER
18. showarray a()
19. showarray b()
20. PRINT "Restoring original array data into array A "
21. copyArray b(), a()
22. showarray a()
23. PRINT " Garbage by _PRESERVE feature "
24. PRINT "press a key";: SLEEP: CLS
25. ' to fix _PRESERVE  we must not use _PRESERVE
26. PRINT " Redim Array A and NO _preserve "
27. REDIM a(8, 7) AS INTEGER
28. showarray a()
29. showarray b()
30. ' no clear no erase because they take down dimensions of the array
31. PRINT " Restoring original array data into array A "
32. copyArray b(), a()
33. showarray a()
34. showarray b()
35. PRINT "Press a key ": SLEEP: CLS
36. PRINT " Now Redim A with NO _PRESERVE"
37. REDIM a(7, 6) AS INTEGER
38. showarray a()
39. showarray b()
40. PRINT " Restoring data using CopyArrayFOR "
41. CopyArrayFor b(), a()
42. showarray a()
43. showarray b()
44.  
45. END
46.  
47.  
48. SUB initaz
49.     SHARED a() AS INTEGER, b() AS INTEGER
50.     '--INITIALIZATION
51.     PRINT "INITIALIZATION"
52.     FOR i1 = 1 TO UBOUND(a, 1)
53.         FOR i2 = 1 TO UBOUND(a, 2)
54.             b(i1, i2) = 999
55.             a(i1, i2) = i1
56.         NEXT
57.     NEXT
58. END SUB
59.  
60. SUB showarray (al() AS INTEGER)
61.     PRINT "SHOWING ARRAYS  "
62.     FOR i1 = 1 TO UBOUND(al, 1)
63.         FOR i2 = 1 TO UBOUND(al, 2)
64.             PRINT al(i1, i2); "-";
65.         NEXT
66.         _DELAY .5
67.         PRINT
68.     NEXT
69.     PRINT
70. END SUB
71.  
72. SUB copyArray (S() AS INTEGER, D() AS INTEGER)
73.  
74.     ' COPYARRAY (ArraySource(), ArrayDest())
75.     'copy array a1 to array b1 using _MEM functions:
76.  
77.     PRINT " COPYING ARRAY..."
78.     DIM mD AS _MEM, mS AS _MEM
79.     mD = _MEM(D())
80.     mS = _MEM(S())
81.     ' _MEMPUT mD, mD.OFFSET, S()  ' ALSO THIS INSTRUCTION GIVES THE SAME RESULTS....
82.     _MEMCOPY mS, mS.OFFSET, mS.SIZE TO mD, mD.OFFSET
83.     _MEMFREE mD: _MEMFREE mS
84.     PRINT "END COPY!"
85. END SUB
86.  
87. SUB CopyArrayFor (S() AS INTEGER, D() AS INTEGER)
88.     '-- COPY ARRAY USING FOR CICLES
89.     PRINT "COPY ARRAY USING FOR CICLES"
90.     FOR i1 = 1 TO UBOUND(s, 1)
91.         FOR i2 = 1 TO UBOUND(s, 2)
92.             D(i1, i2) = S(i1, i2)
93.         NEXT
94.     NEXT
95. END SUB
96.  
97.  

This code try to solve _PRESERVE issue using a manual function of copy and paste of old array in new array.
here _delay and SLEEP are used to show output, no speed of performance but rightness of results of operations of code is the cutoff to choose method to copy array....

seeing how _MEM is fast I wish that it is again a my poor code structure to give me these results...but it seems that _MEM instructions duplicate _PRESERVE results.
Thanks to read, waiting feedback.