c1-stream.txt

<<<======This is test : 1======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67353 microseconds.
   (= 67353 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9896.5     0.097186     0.097004     0.097388
Scale:           9967.8     0.096434     0.096310     0.097692
Add:            11479.4     0.125535     0.125442     0.126698
Triad:          11426.8     0.126166     0.126019     0.126836
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 2======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67422 microseconds.
   (= 67422 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9889.7     0.097220     0.097071     0.098514
Scale:           9968.4     0.096409     0.096304     0.096984
Add:            11480.6     0.125541     0.125429     0.127597
Triad:          11425.6     0.126215     0.126033     0.128555
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 3======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67373 microseconds.
   (= 67373 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9892.4     0.097163     0.097044     0.097926
Scale:           9961.7     0.096486     0.096369     0.096688
Add:            11468.3     0.125662     0.125564     0.125919
Triad:          11418.3     0.126333     0.126113     0.141475
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 4======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67347 microseconds.
   (= 67347 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9891.8     0.097203     0.097050     0.097346
Scale:           9968.5     0.096428     0.096303     0.096737
Add:            11483.4     0.125491     0.125398     0.125678
Triad:          11427.9     0.126122     0.126007     0.126488
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 5======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67189 microseconds.
   (= 67189 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9898.4     0.097148     0.096985     0.097525
Scale:           9971.2     0.096358     0.096277     0.096533
Add:            11483.3     0.125515     0.125399     0.125712
Triad:          11429.9     0.126107     0.125986     0.126496
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 6======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67338 microseconds.
   (= 67338 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9891.0     0.097180     0.097058     0.097791
Scale:           9967.6     0.096420     0.096312     0.096692
Add:            11484.4     0.125483     0.125387     0.126514
Triad:          11428.1     0.126107     0.126005     0.126475
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 7======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67471 microseconds.
   (= 67471 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9892.2     0.097185     0.097046     0.097905
Scale:           9970.0     0.096424     0.096289     0.097427
Add:            11478.4     0.125535     0.125453     0.126584
Triad:          11428.3     0.126183     0.126003     0.131461
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 8======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67335 microseconds.
   (= 67335 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9898.4     0.097109     0.096985     0.097330
Scale:           9973.2     0.096343     0.096258     0.097427
Add:            11482.4     0.125497     0.125409     0.125660
Triad:          11432.6     0.126085     0.125956     0.126552
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 9======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67229 microseconds.
   (= 67229 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9887.3     0.097237     0.097094     0.097415
Scale:           9969.3     0.096391     0.096296     0.096515
Add:            11481.6     0.125498     0.125418     0.125843
Triad:          11429.9     0.126116     0.125985     0.126581
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 10======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67300 microseconds.
   (= 67300 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9887.0     0.097278     0.097097     0.098447
Scale:           9970.5     0.096400     0.096284     0.096511
Add:            11483.0     0.125497     0.125403     0.125590
Triad:          11428.9     0.126114     0.125997     0.126485
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 11======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67310 microseconds.
   (= 67310 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9887.4     0.097295     0.097093     0.098344
Scale:           9962.4     0.096480     0.096362     0.097045
Add:            11470.7     0.125642     0.125537     0.125875
Triad:          11419.2     0.126222     0.126104     0.126567
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 12======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67446 microseconds.
   (= 67446 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9887.6     0.097267     0.097091     0.098413
Scale:           9968.8     0.096408     0.096301     0.096531
Add:            11479.7     0.125515     0.125439     0.125610
Triad:          11427.8     0.126131     0.126009     0.126470
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 13======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67291 microseconds.
   (= 67291 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9882.9     0.097291     0.097138     0.097486
Scale:           9963.4     0.096442     0.096353     0.096570
Add:            11479.4     0.125531     0.125442     0.125700
Triad:          11427.4     0.126152     0.126013     0.126538
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 14======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67260 microseconds.
   (= 67260 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:           10189.2     0.096847     0.094217     0.098090
Scale:          10269.2     0.096097     0.093483     0.096625
Add:            11819.0     0.125165     0.121838     0.126145
Triad:          11767.3     0.125777     0.122373     0.127161
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 15======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67354 microseconds.
   (= 67354 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9887.3     0.097259     0.097094     0.097442
Scale:           9969.3     0.096423     0.096296     0.096987
Add:            11482.8     0.125503     0.125405     0.126620
Triad:          11431.2     0.126132     0.125971     0.126526
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 16======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67382 microseconds.
   (= 67382 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9888.8     0.097235     0.097079     0.098461
Scale:           9967.5     0.096404     0.096313     0.096648
Add:            11478.8     0.125543     0.125449     0.126579
Triad:          11422.8     0.126197     0.126064     0.127689
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 17======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67371 microseconds.
   (= 67371 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9898.9     0.097107     0.096980     0.097972
Scale:           9973.3     0.096342     0.096257     0.096700
Add:            11482.2     0.125495     0.125412     0.126013
Triad:          11431.0     0.126083     0.125973     0.126456
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 18======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67307 microseconds.
   (= 67307 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9894.6     0.097132     0.097023     0.097338
Scale:           9972.1     0.096351     0.096269     0.096493
Add:            11482.4     0.125512     0.125409     0.125757
Triad:          11429.9     0.126109     0.125985     0.127160
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 19======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67434 microseconds.
   (= 67434 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9892.8     0.097279     0.097040     0.097436
Scale:           9963.3     0.096436     0.096354     0.097614
Add:            11480.7     0.125519     0.125428     0.125797
Triad:          11425.5     0.126170     0.126034     0.126714
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 20======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67445 microseconds.
   (= 67445 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9886.6     0.097272     0.097101     0.097496
Scale:           9962.0     0.096442     0.096366     0.096607
Add:            11482.2     0.125500     0.125411     0.126051
Triad:          11426.7     0.126167     0.126021     0.127306
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 21======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67507 microseconds.
   (= 67507 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9893.0     0.097228     0.097038     0.097623
Scale:           9969.4     0.096406     0.096295     0.096523
Add:            11484.1     0.125481     0.125391     0.125662
Triad:          11427.6     0.126119     0.126011     0.127159
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 22======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67448 microseconds.
   (= 67448 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9892.2     0.097274     0.097046     0.097468
Scale:           9965.3     0.096451     0.096334     0.096668
Add:            11469.8     0.125642     0.125547     0.126725
Triad:          11420.7     0.126219     0.126087     0.126618
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 23======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67224 microseconds.
   (= 67224 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9887.0     0.097252     0.097097     0.098438
Scale:           9964.6     0.096428     0.096341     0.096631
Add:            11480.0     0.125536     0.125435     0.126103
Triad:          11422.9     0.126189     0.126062     0.126552
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 24======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67420 microseconds.
   (= 67420 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9888.9     0.097261     0.097078     0.097975
Scale:           9967.2     0.096407     0.096316     0.096594
Add:            11477.1     0.125556     0.125467     0.126568
Triad:          11422.1     0.126206     0.126071     0.126573
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 25======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67126 microseconds.
   (= 67126 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9897.4     0.097116     0.096995     0.097392
Scale:           9971.8     0.096352     0.096271     0.096535
Add:            11478.9     0.125540     0.125447     0.125739
Triad:          11426.8     0.126139     0.126019     0.126988
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 26======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67435 microseconds.
   (= 67435 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9898.0     0.097104     0.096989     0.097311
Scale:           9973.8     0.096347     0.096252     0.096536
Add:            11481.5     0.125520     0.125419     0.126672
Triad:          11428.7     0.126119     0.125999     0.126574
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 27======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67382 microseconds.
   (= 67382 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9891.6     0.097267     0.097052     0.102940
Scale:           9967.3     0.096418     0.096315     0.097944
Add:            11481.2     0.125516     0.125422     0.125702
Triad:          11425.0     0.126172     0.126039     0.127177
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 28======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67154 microseconds.
   (= 67154 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9888.9     0.097230     0.097078     0.098311
Scale:           9974.0     0.096393     0.096250     0.096499
Add:            11491.7     0.125465     0.125308     0.125703
Triad:          11447.7     0.126096     0.125789     0.127210
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 29======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67430 microseconds.
   (= 67430 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9894.9     0.097190     0.097020     0.097605
Scale:           9970.7     0.096393     0.096282     0.096512
Add:            11482.7     0.125509     0.125406     0.125693
Triad:          11431.1     0.126159     0.125972     0.126639
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------
<<<======This is test : 30======>>>
-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 60000000 (elements), Offset = 0 (elements)
Memory per array = 457.8 MiB (= 0.4 GiB).
Total memory required = 1373.3 MiB (= 1.3 GiB).
Each kernel will be executed 200 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 67404 microseconds.
   (= 67404 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:            9897.3     0.097107     0.096996     0.098268
Scale:           9971.8     0.096347     0.096271     0.096531
Add:            11484.5     0.125490     0.125386     0.125652
Triad:          11432.0     0.126071     0.125962     0.126471
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------