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! ----------------------------------------------------