  n offset ntimes?
  n =  128000000 offset =  0 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =          0
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19870.5848       .1032       .1031       .1034
Scale:     20238.6353       .1016       .1012       .1029
Add:       24557.1473       .1253       .1251       .1254
Triad:     24732.7829       .1245       .1242       .1249
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  32 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =         32
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19252.1084       .1067       .1064       .1072
Scale:     20241.9022       .1014       .1012       .1015
Add:       23833.3886       .1293       .1289       .1298
Triad:     24794.8934       .1242       .1239       .1244
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  64 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =         64
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      18392.5645       .1118       .1113       .1122
Scale:     20367.1680       .1007       .1006       .1010
Add:       21966.2396       .1404       .1399       .1407
Triad:     24968.8045       .1233       .1230       .1235
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  96 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =         96
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19269.2536       .1065       .1063       .1067
Scale:     20470.7708       .1002       .1000       .1004
Add:       22654.9518       .1359       .1356       .1364
Triad:     24911.0212       .1235       .1233       .1236
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  128 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        128
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19775.9581       .1039       .1036       .1041
Scale:     20532.5220       .0999       .0997       .1001
Add:       22838.2009       .1348       .1345       .1352
Triad:     25218.3293       .1219       .1218       .1220
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  160 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        160
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19521.6025       .1051       .1049       .1053
Scale:     20561.5441       .0997       .0996       .0998
Add:       23597.1007       .1306       .1302       .1312
Triad:     25146.3749       .1223       .1222       .1224
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  192 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        192
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19945.6531       .1028       .1027       .1032
Scale:     20537.0383       .1000       .0997       .1011
Add:       24505.4686       .1255       .1254       .1256
Triad:     24675.6839       .1247       .1245       .1248
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  224 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        224
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20205.4778       .1015       .1014       .1017
Scale:     20886.0077       .0984       .0981       .0991
Add:       25047.8253       .1228       .1226       .1231
Triad:     25230.1560       .1219       .1218       .1220
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  256 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        256
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20433.8834       .1005       .1002       .1008
Scale:     20808.9753       .0987       .0984       .0989
Add:       25299.3621       .1217       .1214       .1220
Triad:     25317.4319       .1215       .1213       .1216
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  288 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        288
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19791.4272       .1037       .1035       .1039
Scale:     20866.5251       .0984       .0981       .0987
Add:       24951.0355       .1235       .1231       .1237
Triad:     25251.3432       .1219       .1217       .1222
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  320 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        320
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19664.9484       .1044       .1041       .1045
Scale:     20583.1981       .0997       .0995       .0998
Add:       24624.2351       .1250       .1248       .1252
Triad:     24951.3013       .1234       .1231       .1236
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  352 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        352
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19845.0379       .1035       .1032       .1038
Scale:     20502.8967       .1001       .0999       .1003
Add:       24866.9591       .1237       .1235       .1240
Triad:     24130.0465       .1275       .1273       .1278
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  384 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        384
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20221.6027       .1017       .1013       .1021
Scale:     20085.4505       .1021       .1020       .1024
Add:       25138.6232       .1223       .1222       .1225
Triad:     23330.8651       .1322       .1317       .1326
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  416 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        416
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19528.0376       .1052       .1049       .1054
Scale:     20217.0575       .1016       .1013       .1019
Add:       24795.7522       .1241       .1239       .1243
Triad:     23238.0004       .1325       .1322       .1326
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  448 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        448
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19950.7257       .1028       .1027       .1034
Scale:     20199.8236       .1016       .1014       .1018
Add:       25019.2998       .1230       .1228       .1232
Triad:     22748.3859       .1354       .1350       .1357
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  480 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        480
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19813.3394       .1037       .1034       .1039
Scale:     20591.4627       .0996       .0995       .0998
Add:       24936.9110       .1234       .1232       .1237
Triad:     24494.3348       .1256       .1254       .1258
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  512 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        512
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20088.0574       .1021       .1020       .1023
Scale:     20446.5294       .1003       .1002       .1005
Add:       25162.8015       .1222       .1221       .1223
Triad:     25322.7061       .1214       .1213       .1215
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  544 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        544
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19295.7657       .1064       .1061       .1066
Scale:     20548.0181       .0998       .0997       .1000
Add:       24329.9340       .1266       .1263       .1270
Triad:     25128.0583       .1224       .1223       .1226
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  576 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        576
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      18601.2865       .1106       .1101       .1110
Scale:     20614.5649       .0995       .0993       .0999
Add:       22489.4675       .1370       .1366       .1375
Triad:     25136.2447       .1224       .1222       .1225
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  608 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        608
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19339.1860       .1063       .1059       .1069
Scale:     20926.3822       .0980       .0979       .0981
Add:       23029.5828       .1336       .1334       .1340
Triad:     25047.8009       .1228       .1226       .1229
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  640 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        640
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19862.7278       .1033       .1031       .1036
Scale:     20759.9921       .0987       .0987       .0988
Add:       23321.0261       .1321       .1317       .1322
Triad:     25283.9722       .1216       .1215       .1218
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  672 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        672
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19424.3312       .1056       .1054       .1059
Scale:     20865.6888       .0983       .0982       .0985
Add:       23903.4687       .1286       .1285       .1288
Triad:     25122.8894       .1224       .1223       .1224
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  704 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        704
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20019.0744       .1025       .1023       .1027
Scale:     20750.6893       .0990       .0987       .0992
Add:       24802.8641       .1240       .1239       .1242
Triad:     24747.2713       .1242       .1241       .1244
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  736 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        736
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20214.5835       .1016       .1013       .1018
Scale:     20931.3284       .0980       .0978       .0981
Add:       25108.1048       .1225       .1224       .1227
Triad:     25251.8628       .1219       .1217       .1222
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  768 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        768
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20412.7363       .1005       .1003       .1006
Scale:     20881.3367       .0982       .0981       .0985
Add:       25271.7482       .1218       .1216       .1221
Triad:     25368.1998       .1212       .1211       .1213
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  800 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        800
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19854.3952       .1034       .1032       .1037
Scale:     20932.3230       .0980       .0978       .0983
Add:       25013.3258       .1230       .1228       .1232
Triad:     25259.7835       .1217       .1216       .1218
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  832 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        832
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19643.1833       .1045       .1043       .1046
Scale:     20529.4305       .1000       .0998       .1003
Add:       24594.2949       .1250       .1249       .1252
Triad:     24735.6317       .1244       .1242       .1245
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  864 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        864
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19833.9491       .1035       .1033       .1036
Scale:     20319.1829       .1010       .1008       .1013
Add:       24918.5126       .1235       .1233       .1236
Triad:     23688.6384       .1300       .1297       .1304
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  896 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        896
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20099.8321       .1021       .1019       .1024
Scale:     19741.8704       .1040       .1037       .1044
Add:       25130.7293       .1223       .1222       .1224
Triad:     22528.3760       .1369       .1364       .1373
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  928 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        928
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19510.0744       .1054       .1050       .1057
Scale:     19794.3232       .1037       .1035       .1039
Add:       24640.1985       .1249       .1247       .1251
Triad:     22491.1752       .1369       .1366       .1373
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  960 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        960
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19840.5917       .1034       .1032       .1035
Scale:     19951.6293       .1029       .1026       .1032
Add:       24707.1493       .1245       .1243       .1248
Triad:     22088.7188       .1398       .1391       .1403
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  992 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =        992
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19818.7564       .1036       .1033       .1038
Scale:     20319.6155       .1010       .1008       .1012
Add:       24611.6532       .1251       .1248       .1254
Triad:     24154.0206       .1274       .1272       .1275
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1024 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1024
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20055.2506       .1025       .1021       .1028
Scale:     20249.5370       .1014       .1011       .1016
Add:       24870.1989       .1237       .1235       .1239
Triad:     25016.5067       .1230       .1228       .1233
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1056 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1056
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19223.3497       .1068       .1065       .1069
Scale:     20250.9692       .1013       .1011       .1014
Add:       23927.0167       .1285       .1284       .1286
Triad:     24731.8335       .1244       .1242       .1245
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1088 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1088
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      18560.4312       .1109       .1103       .1115
Scale:     20384.7130       .1007       .1005       .1008
Add:       21878.1232       .1410       .1404       .1414
Triad:     24870.7030       .1237       .1235       .1238
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1120 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1120
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19231.9360       .1068       .1065       .1073
Scale:     20476.5289       .1002       .1000       .1003
Add:       22415.6006       .1372       .1370       .1374
Triad:     24894.3925       .1235       .1234       .1236
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1152 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1152
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19725.5953       .1040       .1038       .1044
Scale:     20529.8721       .0999       .0998       .1001
Add:       22694.3755       .1360       .1354       .1363
Triad:     25276.7802       .1217       .1215       .1221
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1184 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1184
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19297.5646       .1064       .1061       .1069
Scale:     20647.8885       .0993       .0992       .0996
Add:       23525.7313       .1308       .1306       .1313
Triad:     25137.8385       .1223       .1222       .1224
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1216 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1216
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19964.5901       .1029       .1026       .1034
Scale:     20515.8488       .0999       .0998       .1000
Add:       24608.9739       .1251       .1248       .1252
Triad:     24780.1109       .1241       .1240       .1245
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1248 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1248
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20166.8167       .1017       .1016       .1018
Scale:     20807.4379       .0985       .0984       .0987
Add:       25081.6633       .1226       .1225       .1228
Triad:     25235.2950       .1219       .1217       .1220
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1280 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1280
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20455.4884       .1004       .1001       .1007
Scale:     20818.7088       .0985       .0984       .0987
Add:       25286.2299       .1217       .1215       .1220
Triad:     25277.7719       .1217       .1215       .1219
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1312 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1312
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19811.6029       .1035       .1034       .1038
Scale:     20907.0786       .0981       .0980       .0982
Add:       24966.2887       .1232       .1230       .1234
Triad:     25292.4592       .1216       .1215       .1217
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1344 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1344
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19672.8299       .1045       .1041       .1052
Scale:     20551.9265       .0998       .0997       .1000
Add:       24603.0767       .1250       .1249       .1251
Triad:     24903.9675       .1235       .1234       .1238
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1376 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1376
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19756.6500       .1039       .1037       .1041
Scale:     20569.6190       .0998       .0996       .1001
Add:       24846.5794       .1237       .1236       .1239
Triad:     24166.5241       .1273       .1271       .1274
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1408 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1408
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20173.9212       .1019       .1015       .1023
Scale:     19995.1923       .1026       .1024       .1028
Add:       25070.8778       .1228       .1225       .1229
Triad:     23245.4418       .1325       .1322       .1330
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1440 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1440
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19516.3910       .1054       .1049       .1057
Scale:     20206.1433       .1015       .1014       .1017
Add:       24764.6559       .1242       .1240       .1243
Triad:     23260.1079       .1326       .1321       .1329
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1472 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1472
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19957.4932       .1028       .1026       .1031
Scale:     20176.1956       .1017       .1015       .1019
Add:       25043.5411       .1229       .1227       .1231
Triad:     22758.3707       .1353       .1350       .1357
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1504 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1504
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19856.4834       .1036       .1031       .1038
Scale:     20529.3569       .0999       .0998       .1002
Add:       24940.6277       .1235       .1232       .1236
Triad:     24526.0860       .1255       .1253       .1256
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1536 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1536
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20037.0995       .1025       .1022       .1027
Scale:     20458.9231       .1002       .1001       .1005
Add:       25088.3295       .1225       .1224       .1226
Triad:     25361.1594       .1213       .1211       .1214
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1568 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1568
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19255.3666       .1067       .1064       .1072
Scale:     20593.0177       .0996       .0995       .0998
Add:       24308.2003       .1267       .1264       .1270
Triad:     25107.7623       .1225       .1224       .1226
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1600 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1600
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      18612.8139       .1105       .1100       .1109
Scale:     20652.0833       .0993       .0992       .0996
Add:       22447.5056       .1371       .1369       .1377
Triad:     25155.8010       .1223       .1221       .1225
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1632 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1632
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19278.5732       .1065       .1062       .1068
Scale:     20828.7798       .0985       .0983       .0987
Add:       23098.2177       .1333       .1330       .1335
Triad:     25064.3915       .1228       .1226       .1230
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1664 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1664
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19821.6833       .1039       .1033       .1043
Scale:     20767.3199       .0989       .0986       .0991
Add:       23327.0214       .1321       .1317       .1323
Triad:     25287.0735       .1216       .1215       .1218
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1696 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1696
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19481.6450       .1054       .1051       .1058
Scale:     20821.4339       .0985       .0984       .0987
Add:       23965.8911       .1285       .1282       .1288
Triad:     25076.5622       .1227       .1225       .1228
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1728 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1728
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20044.5337       .1023       .1022       .1025
Scale:     20651.8599       .0994       .0992       .0997
Add:       24841.0707       .1239       .1237       .1240
Triad:     24714.9452       .1245       .1243       .1247
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1760 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1760
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20117.8616       .1019       .1018       .1022
Scale:     20892.8149       .0981       .0980       .0982
Add:       25060.8572       .1227       .1226       .1229
Triad:     25129.6020       .1224       .1222       .1225
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1792 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1792
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20462.5296       .1003       .1001       .1006
Scale:     20768.1734       .0987       .0986       .0988
Add:       25275.4910       .1217       .1215       .1217
Triad:     25388.0688       .1211       .1210       .1213
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1824 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1824
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19747.4300       .1039       .1037       .1041
Scale:     20827.6182       .0986       .0983       .0988
Add:       24922.3444       .1234       .1233       .1235
Triad:     25220.7234       .1220       .1218       .1222
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1856 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1856
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19578.6447       .1048       .1046       .1051
Scale:     20347.1226       .1008       .1007       .1010
Add:       24579.7975       .1252       .1250       .1253
Triad:     24712.2907       .1246       .1243       .1249
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1888 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1888
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19845.6798       .1035       .1032       .1039
Scale:     20166.6274       .1017       .1016       .1020
Add:       24894.6089       .1236       .1234       .1238
Triad:     23563.3979       .1306       .1304       .1309
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1920 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1920
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      20120.0763       .1021       .1018       .1023
Scale:     19589.1148       .1048       .1045       .1050
Add:       25121.9097       .1225       .1223       .1226
Triad:     22438.1629       .1373       .1369       .1376
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1952 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1952
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19422.6403       .1064       .1054       .1120
Scale:     19691.3649       .1044       .1040       .1045
Add:       24578.0158       .1251       .1250       .1253
Triad:     22414.2553       .1375       .1371       .1385
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  1984 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       1984
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19933.0176       .1029       .1027       .1031
Scale:     19932.3238       .1029       .1027       .1031
Add:       24755.1639       .1243       .1241       .1245
Triad:     21953.0283       .1404       .1399       .1407
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
  n offset ntimes?
  n =  128000000 offset =  2016 ntimes= 10
----------------------------------------------
 Double precision appears to have 16 digits of accuracy
 Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
 Array size =  128000000
 Offset     =       2016
 The total memory requirement is 2929 MB
 You are running each test  10 times
 --
 The *best* time for each test is used
 *EXCLUDING* the first and last iterations
 ----------------------------------------------------
 Your clock granularity appears to be less than one microsecond
 Your clock granularity/precision appears to be      1 microseconds
 ----------------------------------------------------
Function     Rate (MB/s)  Avg time   Min time  Max time
Copy:      19803.8838       .1037       .1034       .1039
Scale:     20336.4527       .1009       .1007       .1012
Add:       24549.3570       .1254       .1251       .1256
Triad:     24128.5779       .1275       .1273       .1278
 ----------------------------------------------------
 Solution Validates!
 ----------------------------------------------------
