---------- X-Sun-Data-Type: text X-Sun-Data-Description: text X-Sun-Data-Name: text X-Sun-Charset: us-ascii X-Sun-Content-Lines: 29 Hello John, I finally got my hands on an Ultra2. The system was running CDE with two users on it. The STREAM binary was _not_ compiled specifically for an Ultra, it rather is the very same that I used to test all the other machines that I sent results of in February. Therefore I included an Ultra1/170E result that shows lower numbers than what is already in your database to have a comparable set of results. The difference in the single CPU results is attributable to the difference in UPA clock speed (83MHz vs. 100MHz). I plan to compile the parallelized version (posted in the mailing list) with a new compiler soon and resubmit those results that may change. BTW, in the STREAM mail archive I found three postings attributed to me that I didn't originate. One is from you (was a posting in comp.lang.benchmarks that I replied to) and the others I haven't even seen before (Vectors vs. Superscalar vs. Streams). Could you please correct the attribution before someone claims copyright infringement against me ;-)? Results attached. Regards, Achim Gratz. --+<[ It's the small pleasures that make life so miserable. ]>+-- WWW: http://www.inf.tu-dresden.de/~ag7/ {english/} E-Mail: gratz@ite.inf.tu-dresden.de Phone: +49 351 463 - 8325 (new number as of 7/14/96) ---------- X-Sun-Data-Type: default X-Sun-Data-Description: default X-Sun-Data-Name: Ultra1_170E_single_69MB X-Sun-Charset: us-ascii X-Sun-Content-Lines: 192 STREAM benchmark, run 1 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 203 microseconds. Each test below will take on the order of 370348 microseconds. (= 1824 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 149.2811 0.3418 0.3215 0.4151 Scaling : 169.8790 0.3045 0.2826 0.4316 Summing : 180.8577 0.4244 0.3981 0.4547 SAXPYing : 158.2814 0.4776 0.4549 0.5754 STREAM benchmark, run 2 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 206 microseconds. Each test below will take on the order of 217232 microseconds. (= 1054 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 145.5887 0.3386 0.3297 0.3609 Scaling : 184.0335 0.2736 0.2608 0.3052 Summing : 168.6740 0.4546 0.4269 0.4869 SAXPYing : 158.9260 0.4781 0.4530 0.5141 STREAM benchmark, run 3 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 192 microseconds. Each test below will take on the order of 203935 microseconds. (= 1062 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 148.6478 0.3390 0.3229 0.4006 Scaling : 182.0388 0.2715 0.2637 0.2831 Summing : 168.9990 0.4452 0.4260 0.4963 SAXPYing : 159.4988 0.4796 0.4514 0.5131 STREAM benchmark, run 4 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 198 microseconds. Each test below will take on the order of 227185 microseconds. (= 1147 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 146.1588 0.3414 0.3284 0.3918 Scaling : 191.2122 0.2714 0.2510 0.2944 Summing : 171.6689 0.4448 0.4194 0.5115 SAXPYing : 158.7886 0.4850 0.4534 0.6402 STREAM benchmark, run 5 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 199 microseconds. Each test below will take on the order of 196630 microseconds. (= 988 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 149.3499 0.3446 0.3214 0.4043 Scaling : 197.2914 0.2886 0.2433 0.5006 Summing : 171.0291 0.4697 0.4210 0.7319 SAXPYing : 161.1073 0.5169 0.4469 0.9917 STREAM benchmark, run 6 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 208 microseconds. Each test below will take on the order of 192896 microseconds. (= 927 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 144.7632 0.3602 0.3316 0.3826 Scaling : 184.2709 0.2843 0.2605 0.3118 Summing : 160.8303 0.4753 0.4477 0.5082 SAXPYing : 155.3649 0.4979 0.4634 0.5248 STREAM benchmark, run 7 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 216 microseconds. Each test below will take on the order of 238289 microseconds. (= 1103 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 145.8350 0.3397 0.3291 0.3780 Scaling : 184.1627 0.2742 0.2606 0.2954 Summing : 170.3037 0.4371 0.4228 0.4727 SAXPYing : 155.4317 0.4823 0.4632 0.5176 STREAM benchmark, run 8 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 191 microseconds. Each test below will take on the order of 219074 microseconds. (= 1146 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 149.6572 0.3593 0.3207 0.5134 Scaling : 185.8786 0.2855 0.2582 0.4015 Summing : 164.1445 0.4528 0.4386 0.4832 SAXPYing : 159.2318 0.4885 0.4522 0.7125 ---------- X-Sun-Data-Type: default X-Sun-Data-Description: default X-Sun-Data-Name: Ultra2_2200_single_69MB X-Sun-Charset: us-ascii X-Sun-Content-Lines: 192 STREAM benchmark, run 1 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 165924 microseconds. (= 165924 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 181.8636 0.2644 0.2639 0.2651 Scaling : 231.3866 0.2085 0.2074 0.2204 Summing : 236.8257 0.3048 0.3040 0.3104 SAXPYing : 210.2687 0.3432 0.3424 0.3472 STREAM benchmark, run 2 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 168081 microseconds. (= 168081 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 180.5061 0.2669 0.2659 0.2723 Scaling : 229.7486 0.2099 0.2089 0.2158 Summing : 236.5861 0.3078 0.3043 0.3124 SAXPYing : 210.3277 0.3467 0.3423 0.3549 STREAM benchmark, run 3 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 166135 microseconds. (= 166135 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 181.8767 0.2667 0.2639 0.2726 Scaling : 231.4336 0.2100 0.2074 0.2158 Summing : 236.8047 0.3074 0.3040 0.3128 SAXPYing : 210.3615 0.3467 0.3423 0.3543 STREAM benchmark, run 4 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 168416 microseconds. (= 168416 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 180.7318 0.2661 0.2656 0.2678 Scaling : 229.8520 0.2095 0.2088 0.2173 Summing : 235.4180 0.3062 0.3058 0.3071 SAXPYing : 208.9616 0.3450 0.3446 0.3465 STREAM benchmark, run 5 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 166749 microseconds. (= 166749 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 181.8905 0.2674 0.2639 0.2763 Scaling : 231.4346 0.2097 0.2074 0.2129 Summing : 236.8554 0.3075 0.3040 0.3184 SAXPYing : 210.2743 0.3463 0.3424 0.3576 STREAM benchmark, run 6 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 167266 microseconds. (= 167266 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 181.8740 0.2681 0.2639 0.3063 Scaling : 231.3676 0.2099 0.2075 0.2271 Summing : 236.2886 0.3076 0.3047 0.3234 SAXPYing : 209.8171 0.3479 0.3432 0.3914 STREAM benchmark, run 7 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 165454 microseconds. (= 165454 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 181.8864 0.2653 0.2639 0.2680 Scaling : 231.4803 0.2090 0.2074 0.2123 Summing : 236.9177 0.3062 0.3039 0.3169 SAXPYing : 210.3646 0.3444 0.3423 0.3488 STREAM benchmark, run 8 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 175343 microseconds. (= 175343 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 181.8864 0.2672 0.2639 0.2772 Scaling : 231.4703 0.2110 0.2074 0.2217 Summing : 236.9083 0.3091 0.3039 0.3427 SAXPYing : 210.3405 0.3471 0.3423 0.3757 ---------- X-Sun-Data-Type: default X-Sun-Data-Description: default X-Sun-Data-Name: Ultra2_2200_dual_69MB X-Sun-Charset: us-ascii X-Sun-Content-Lines: 376 STREAM benchmark, run 1 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 237355 microseconds. (= 237355 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 140.0765 0.3489 0.3427 0.3651 Scaling : 144.2980 0.3401 0.3326 0.3828 Summing : 163.9498 0.4450 0.4392 0.4513 SAXPYing : 159.4875 0.4703 0.4514 0.4812 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 262472 microseconds. (= 262472 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 139.1458 0.3480 0.3450 0.3529 Scaling : 148.2539 0.3364 0.3238 0.3392 Summing : 163.4870 0.4473 0.4404 0.4566 SAXPYing : 154.8497 0.4668 0.4650 0.4715 STREAM benchmark, run 2 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 2 microseconds. Each test below will take on the order of 242380 microseconds. (= 121190 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 139.3429 0.3491 0.3445 0.3540 Scaling : 143.7793 0.3376 0.3338 0.3440 Summing : 164.3899 0.4442 0.4380 0.4544 SAXPYing : 154.9817 0.4727 0.4646 0.5180 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 242835 microseconds. (= 242835 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 137.9762 0.3501 0.3479 0.3539 Scaling : 143.1652 0.3386 0.3353 0.3419 Summing : 163.6970 0.4463 0.4398 0.4521 SAXPYing : 154.6923 0.4691 0.4654 0.4719 STREAM benchmark, run 3 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 241976 microseconds. (= 241976 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 138.4299 0.3518 0.3467 0.3660 Scaling : 145.8461 0.3353 0.3291 0.3398 Summing : 163.1691 0.4455 0.4413 0.4491 SAXPYing : 159.5929 0.4744 0.4511 0.4795 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 240719 microseconds. (= 240719 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 140.1660 0.3466 0.3425 0.3526 Scaling : 143.8745 0.3364 0.3336 0.3482 Summing : 164.9598 0.4528 0.4365 0.4995 SAXPYing : 155.5714 0.4657 0.4628 0.4719 STREAM benchmark, run 4 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 241446 microseconds. (= 241446 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 138.9327 0.3506 0.3455 0.3612 Scaling : 143.0338 0.3381 0.3356 0.3409 Summing : 163.4254 0.4453 0.4406 0.4509 SAXPYing : 155.1316 0.4702 0.4641 0.4755 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 238476 microseconds. (= 238476 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 139.1789 0.3512 0.3449 0.3937 Scaling : 143.7087 0.3372 0.3340 0.3444 Summing : 164.1628 0.4446 0.4386 0.4548 SAXPYing : 155.3573 0.4678 0.4634 0.4800 STREAM benchmark, run 5 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 243261 microseconds. (= 243261 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 138.9532 0.3500 0.3454 0.3650 Scaling : 145.2824 0.3379 0.3304 0.3413 Summing : 163.4855 0.4458 0.4404 0.4520 SAXPYing : 156.0597 0.4671 0.4614 0.4701 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 257581 microseconds. (= 257581 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 139.9674 0.3486 0.3429 0.3703 Scaling : 144.0689 0.3366 0.3332 0.3462 Summing : 165.2240 0.4425 0.4358 0.4573 SAXPYing : 156.5827 0.4716 0.4598 0.5209 STREAM benchmark, run 6 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 240620 microseconds. (= 240620 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 139.4899 0.3505 0.3441 0.3667 Scaling : 143.6446 0.3368 0.3342 0.3437 Summing : 164.8465 0.4460 0.4368 0.4961 SAXPYing : 155.5096 0.4676 0.4630 0.4868 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 245484 microseconds. (= 245484 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 138.3988 0.3503 0.3468 0.3546 Scaling : 143.2481 0.3373 0.3351 0.3393 Summing : 165.8895 0.4433 0.4340 0.4495 SAXPYing : 154.8078 0.4685 0.4651 0.4717 STREAM benchmark, run 7 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 239750 microseconds. (= 239750 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 138.7171 0.3502 0.3460 0.3603 Scaling : 149.4908 0.3372 0.3211 0.3399 Summing : 164.5116 0.4441 0.4377 0.4506 SAXPYing : 154.9801 0.4675 0.4646 0.4699 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 238018 microseconds. (= 238018 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 139.7185 0.3496 0.3435 0.3611 Scaling : 143.6111 0.3396 0.3342 0.3924 Summing : 165.3462 0.4417 0.4355 0.4505 SAXPYing : 155.4850 0.4687 0.4631 0.4843 STREAM benchmark, run 8 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 246059 microseconds. (= 246059 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 140.4865 0.3474 0.3417 0.3548 Scaling : 143.8935 0.3371 0.3336 0.3454 Summing : 164.1561 0.4475 0.4386 0.4582 SAXPYing : 155.5032 0.4688 0.4630 0.5148 ------------------------------------------------------------- This system uses 8 bytes per DOUBLE PRECISION word. ------------------------------------------------------------- Array size = 3000000, Offset = 0 Total memory required = 68.7 MB. Each test is run 20 times, but only the *best* time for each is used. ------------------------------------------------------------- Your clock granularity/precision appears to be 1 microseconds. Each test below will take on the order of 242951 microseconds. (= 242951 clock ticks) Increase the size of the arrays if this shows that you are not getting at least 20 clock ticks per test. ------------------------------------------------------------- WARNING: The above is only a rough guideline. For best results, please be sure you know the precision of your system timer. ------------------------------------------------------------- Function Rate (MB/s) RMS time Min time Max time Assignment: 138.7279 0.3502 0.3460 0.3557 Scaling : 143.7750 0.3369 0.3339 0.3391 Summing : 162.9730 0.4444 0.4418 0.4470 SAXPYing : 158.2383 0.4724 0.4550 0.4780