Difference between revisions of "HCL Cluster Specifications"

From HCL
Jump to: navigation, search
(Cluster Specifications)
 
(8 intermediate revisions by 3 users not shown)
Line 1: Line 1:
 +
==Cluster Specifications==
 +
 
{|  border="1" cellspacing="1" cellpadding="5"  
 
{|  border="1" cellspacing="1" cellpadding="5"  
 
| Name
 
| Name
Line 48: Line 50:
 
| 1 – 2
 
| 1 – 2
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl01 (NIC1)
+
|  ALIGN=LEFT | [[Hcl01]] (NIC1)
 
|  ALIGN=LEFT | Dell Poweredge 750
 
|  ALIGN=LEFT | Dell Poweredge 750
 
|  ALIGN=LEFT | 192.168.21.3
 
|  ALIGN=LEFT | 192.168.21.3
Line 72: Line 74:
 
| 3
 
| 3
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl02 (NIC1)
+
|  ALIGN=LEFT | [[Hcl02]] (NIC1)
 
|  ALIGN=LEFT | Dell Poweredge 750
 
|  ALIGN=LEFT | Dell Poweredge 750
 
|  ALIGN=LEFT | 192.168.21.4
 
|  ALIGN=LEFT | 192.168.21.4
Line 78: Line 80:
 
|  ALIGN=LEFT | 800MHz
 
|  ALIGN=LEFT | 800MHz
 
|  ALIGN=LEFT | 1MB
 
|  ALIGN=LEFT | 1MB
|  ALIGN=LEFT | 1GB
+
|  ALIGN=LEFT | 1GB (4x256)
 
|  ALIGN=LEFT | 80GB SATA
 
|  ALIGN=LEFT | 80GB SATA
 
|  ALIGN=LEFT | 250GB SATA
 
|  ALIGN=LEFT | 250GB SATA
Line 96: Line 98:
 
| 4
 
| 4
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl03 (NIC1)
+
|  ALIGN=LEFT | [[Hcl03]] (NIC1)
 
|  ALIGN=LEFT | Dell Poweredge 750
 
|  ALIGN=LEFT | Dell Poweredge 750
 
|  ALIGN=LEFT | 192.168.21.5
 
|  ALIGN=LEFT | 192.168.21.5
Line 102: Line 104:
 
|  ALIGN=LEFT | 800MHz
 
|  ALIGN=LEFT | 800MHz
 
|  ALIGN=LEFT | 1MB
 
|  ALIGN=LEFT | 1MB
|  ALIGN=LEFT | 1GB
+
|  ALIGN=LEFT | 1GB (2x512)
 
|  ALIGN=LEFT | 80GB SATA
 
|  ALIGN=LEFT | 80GB SATA
 
|  ALIGN=LEFT | N/A
 
|  ALIGN=LEFT | N/A
Line 120: Line 122:
 
| 5
 
| 5
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl04 (NIC1)
+
|  ALIGN=LEFT | [[Hcl04]] (NIC1)
 
|  ALIGN=LEFT | Dell Poweredge 750
 
|  ALIGN=LEFT | Dell Poweredge 750
 
|  ALIGN=LEFT | 192.168.21.6
 
|  ALIGN=LEFT | 192.168.21.6
Line 144: Line 146:
 
| 6
 
| 6
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl05 (NIC1)
+
|  ALIGN=LEFT | [[Hcl05]] (NIC1)
 
|  ALIGN=LEFT | Dell Poweredge SC1425
 
|  ALIGN=LEFT | Dell Poweredge SC1425
 
|  ALIGN=LEFT | 192.168.21.7
 
|  ALIGN=LEFT | 192.168.21.7
Line 168: Line 170:
 
| 7
 
| 7
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl06 (NIC1)
+
|  ALIGN=LEFT | [[Hcl06]] (NIC1)
 
|  ALIGN=LEFT | Dell Poweredge SC1425
 
|  ALIGN=LEFT | Dell Poweredge SC1425
 
|  ALIGN=LEFT | 192.168.21.8
 
|  ALIGN=LEFT | 192.168.21.8
Line 192: Line 194:
 
| 8
 
| 8
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl07 (NIC1)
+
|  ALIGN=LEFT | [[Hcl07]](NIC1)
 
|  ALIGN=LEFT | Dell Poweredge 750
 
|  ALIGN=LEFT | Dell Poweredge 750
 
|  ALIGN=LEFT | 192.168.21.9
 
|  ALIGN=LEFT | 192.168.21.9
Line 198: Line 200:
 
|  ALIGN=LEFT | 800MHz
 
|  ALIGN=LEFT | 800MHz
 
|  ALIGN=LEFT | 1MB
 
|  ALIGN=LEFT | 1MB
|  ALIGN=LEFT | 256MB
+
|  ALIGN=LEFT | 256MB (1x256)
 
|  ALIGN=LEFT | 80GB SATA
 
|  ALIGN=LEFT | 80GB SATA
 
|  ALIGN=LEFT | N/A
 
|  ALIGN=LEFT | N/A
Line 216: Line 218:
 
| 9
 
| 9
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl08 (NIC1)
+
|  ALIGN=LEFT | [[Hcl08]] (NIC1)
 
|  ALIGN=LEFT | Dell Poweredge 750
 
|  ALIGN=LEFT | Dell Poweredge 750
 
|  ALIGN=LEFT | 192.168.21.10
 
|  ALIGN=LEFT | 192.168.21.10
Line 222: Line 224:
 
|  ALIGN=LEFT | 800MHz
 
|  ALIGN=LEFT | 800MHz
 
|  ALIGN=LEFT | 1MB
 
|  ALIGN=LEFT | 1MB
|  ALIGN=LEFT | 256MB
+
|  ALIGN=LEFT | 256MB (1x256)
 
|  ALIGN=LEFT | 80GB SATA
 
|  ALIGN=LEFT | 80GB SATA
 
|  ALIGN=LEFT | N/A
 
|  ALIGN=LEFT | N/A
Line 240: Line 242:
 
| 10
 
| 10
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl09 (NIC1)
+
|  ALIGN=LEFT | [[Hcl09]] (NIC1)
 
|  ALIGN=LEFT | IBM E-server 326
 
|  ALIGN=LEFT | IBM E-server 326
 
|  ALIGN=LEFT | 192.168.21.11
 
|  ALIGN=LEFT | 192.168.21.11
Line 264: Line 266:
 
| 11
 
| 11
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl10 (NIC1)
+
|  ALIGN=LEFT | [[Hcl10]] (NIC1)
 
|  ALIGN=LEFT | IBM E-server 326
 
|  ALIGN=LEFT | IBM E-server 326
 
|  ALIGN=LEFT | 192.168.21.12
 
|  ALIGN=LEFT | 192.168.21.12
Line 288: Line 290:
 
| 12
 
| 12
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl11 (NIC1)
+
|  ALIGN=LEFT | [[Hcl11]] (NIC1)
 
|  ALIGN=LEFT | IBM X-Series 306
 
|  ALIGN=LEFT | IBM X-Series 306
 
|  ALIGN=LEFT | 192.168.21.13
 
|  ALIGN=LEFT | 192.168.21.13
Line 312: Line 314:
 
| 13
 
| 13
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl12 (NIC1)
+
|  ALIGN=LEFT | [[Hcl12]] (NIC1)
 
|  ALIGN=LEFT | HP Proliant DL 320 G3
 
|  ALIGN=LEFT | HP Proliant DL 320 G3
 
|  ALIGN=LEFT | 192.168.21.14
 
|  ALIGN=LEFT | 192.168.21.14
Line 336: Line 338:
 
| 14
 
| 14
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl13 (NIC1)
+
|  ALIGN=LEFT | [[Hcl13]] (NIC1)
 
|  ALIGN=LEFT | HP Proliant DL 320 G3
 
|  ALIGN=LEFT | HP Proliant DL 320 G3
 
|  ALIGN=LEFT | 192.168.21.15
 
|  ALIGN=LEFT | 192.168.21.15
Line 360: Line 362:
 
| 15
 
| 15
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl14 (NIC1)
+
|  ALIGN=LEFT | [[Hcl14]] (NIC1)
 
|  ALIGN=LEFT | HP Proliant DL 140 G2
 
|  ALIGN=LEFT | HP Proliant DL 140 G2
 
|  ALIGN=LEFT | 192.168.21.16
 
|  ALIGN=LEFT | 192.168.21.16
Line 384: Line 386:
 
| 16
 
| 16
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl15 (NIC1)
+
|  ALIGN=LEFT | [[Hcl15]] (NIC1)
 
|  ALIGN=LEFT | HP Proliant DL 140 G2
 
|  ALIGN=LEFT | HP Proliant DL 140 G2
 
|  ALIGN=LEFT | 192.168.21.17
 
|  ALIGN=LEFT | 192.168.21.17
Line 408: Line 410:
 
| 17
 
| 17
 
|-  
 
|-  
|  ALIGN=LEFT | Hcl16 (NIC1)
+
|  ALIGN=LEFT | [[Hcl16]] (NIC1)
 
|  ALIGN=LEFT | HP Proliant DL 140 G2
 
|  ALIGN=LEFT | HP Proliant DL 140 G2
 
|  ALIGN=LEFT | 192.168.21.18
 
|  ALIGN=LEFT | 192.168.21.18
Line 414: Line 416:
 
|  ALIGN=LEFT | 800MHz
 
|  ALIGN=LEFT | 800MHz
 
|  ALIGN=LEFT | 2MB
 
|  ALIGN=LEFT | 2MB
|  ALIGN=LEFT | 1GB
+
|  ALIGN=LEFT | 384MB
 
|  ALIGN=LEFT | 80GB SATA
 
|  ALIGN=LEFT | 80GB SATA
 
|  ALIGN=LEFT | N/A
 
|  ALIGN=LEFT | N/A
Line 432: Line 434:
 
| 18
 
| 18
 
|}
 
|}
 +
 +
==Cluster Benchmarks==
 +
===Stream===
 +
====Cluster Performance====
 +
----------------------------------------------
 +
Double precision appears to have 16 digits of accuracy
 +
Assuming 8 bytes per DOUBLE PRECISION word
 +
----------------------------------------------
 +
Number of processors =          18
 +
Array size =    2000000
 +
Offset    =          0
 +
The total memory requirement is    824.0 MB (    45.8MB/task)
 +
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:      24589.1750      0.0235      0.0234      0.0237
 +
Scale:    24493.9786      0.0237      0.0235      0.0245
 +
Add:      27594.1797      0.0314      0.0313      0.0315
 +
Triad:    27695.7938      0.0313      0.0312      0.0315
 +
-----------------------------------------------
 +
Solution Validates!
 +
-----------------------------------------------
 +
 +
====Individual Node Performance====
 +
[[Image:stream_bench_results.png]]
 +
 +
hcl01.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity appears to be less than one microsecond.
 +
Each test below will take on the order of 8386 microseconds.
 +
    (= 8386 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)  Avg time    Min time    Max time
 +
Copy:        2615.4617      0.0125      0.0122      0.0132
 +
Scale:      2609.2783      0.0125      0.0123      0.0133
 +
Add:        3046.4707      0.0161      0.0158      0.0168
 +
Triad:      3064.7322      0.0160      0.0157      0.0166
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl02.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity appears to be less than one microsecond.
 +
Each test below will take on the order of 7790 microseconds.
 +
    (= 7790 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)  Avg time    Min time    Max time
 +
Copy:        2740.6840      0.0117      0.0117      0.0120
 +
Scale:      2745.3930      0.0117      0.0117      0.0117
 +
Add:        3063.1599      0.0157      0.0157      0.0157
 +
Triad:      3075.3572      0.0156      0.0156      0.0159
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl03.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity appears to be less than one microsecond.
 +
Each test below will take on the order of 8382 microseconds.
 +
    (= 8382 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)  Avg time    Min time    Max time
 +
Copy:        2788.6728      0.0115      0.0115      0.0115
 +
Scale:      2722.0144      0.0118      0.0118      0.0121
 +
Add:        3266.6166      0.0148      0.0147      0.0150
 +
Triad:      3287.4249      0.0146      0.0146      0.0147
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl04.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity appears to be less than one microsecond.
 +
Each test below will take on the order of 8378 microseconds.
 +
    (= 8378 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)  Avg time    Min time    Max time
 +
Copy:        2815.4071      0.0114      0.0114      0.0114
 +
Scale:      2751.5270      0.0116      0.0116      0.0117
 +
Add:        3260.1979      0.0148      0.0147      0.0150
 +
Triad:      3274.2183      0.0147      0.0147      0.0150
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl05.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity appears to be less than one microsecond.
 +
Each test below will take on the order of 14916 microseconds.
 +
    (= 14916 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)  Avg time    Min time    Max time
 +
Copy:        1581.8068      0.0203      0.0202      0.0204
 +
Scale:      1557.1081      0.0207      0.0206      0.0215
 +
Add:        1807.7015      0.0266      0.0266      0.0266
 +
Triad:      1832.9646      0.0263      0.0262      0.0265
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl06.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity appears to be less than one microsecond.
 +
Each test below will take on the order of 14824 microseconds.
 +
    (= 14824 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)  Avg time    Min time    Max time
 +
Copy:        1558.3835      0.0206      0.0205      0.0206
 +
Scale:      1550.3951      0.0207      0.0206      0.0209
 +
Add:        1863.4239      0.0258      0.0258      0.0259
 +
Triad:      1885.3916      0.0255      0.0255      0.0259
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl07.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity appears to be less than one microsecond.
 +
Each test below will take on the order of 13642 microseconds.
 +
    (= 13642 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)  Avg time    Min time    Max time
 +
Copy:        1759.4014      0.0183      0.0182      0.0186
 +
Scale:      1740.2731      0.0184      0.0184      0.0185
 +
Add:        2036.4962      0.0236      0.0236      0.0238
 +
Triad:      2045.5920      0.0235      0.0235      0.0235
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl08.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity appears to be less than one microsecond.
 +
Each test below will take on the order of 13476 microseconds.
 +
    (= 13476 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)  Avg time    Min time    Max time
 +
Copy:        1809.6454      0.0177      0.0177      0.0177
 +
Scale:      1784.8271      0.0179      0.0179      0.0179
 +
Add:        2085.3320      0.0231      0.0230      0.0232
 +
Triad:      2095.7094      0.0231      0.0229      0.0239
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl09.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 2
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity/precision appears to be 2 microseconds.
 +
Each test below will take on the order of 7890 microseconds.
 +
    (= 3945 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)  Avg time    Min time    Max time
 +
Copy:        2838.6204      0.0114      0.0113      0.0115
 +
Scale:      2774.6396      0.0116      0.0115      0.0117
 +
Add:        3144.0396      0.0155      0.0153      0.0156
 +
Triad:      3160.7905      0.0153      0.0152      0.0156
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl10.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 2
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity/precision appears to be 2 microseconds.
 +
Each test below will take on the order of 7959 microseconds.
 +
    (= 3979 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)  Avg time    Min time    Max time
 +
Copy:        2864.2732      0.0113      0.0112      0.0114
 +
Scale:      2784.2952      0.0116      0.0115      0.0118
 +
Add:        3162.2553      0.0153      0.0152      0.0155
 +
Triad:      3223.8430      0.0151      0.0149      0.0153
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl11.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity/precision appears to be 1 microseconds.
 +
Each test below will take on the order of 13082 microseconds.
 +
    (= 13082 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)  Avg time    Min time    Max time
 +
Copy:        1842.8984      0.0174      0.0174      0.0174
 +
Scale:      1818.1816      0.0177      0.0176      0.0179
 +
Add:        2109.8918      0.0228      0.0227      0.0231
 +
Triad:      2119.0161      0.0227      0.0227      0.0227
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl12.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity appears to be less than one microsecond.
 +
Each test below will take on the order of 12621 microseconds.
 +
    (= 12621 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)  Avg time    Min time    Max time
 +
Copy:        1805.0657      0.0178      0.0177      0.0179
 +
Scale:      1795.5385      0.0179      0.0178      0.0182
 +
Add:        2089.9636      0.0230      0.0230      0.0230
 +
Triad:      2097.5313      0.0229      0.0229      0.0231
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl13.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity appears to be less than one microsecond.
 +
Each test below will take on the order of 12203 microseconds.
 +
    (= 12203 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)  Avg time    Min time    Max time
 +
Copy:        1768.9387      0.0181      0.0181      0.0182
 +
Scale:      1765.9100      0.0182      0.0181      0.0184
 +
Add:        2000.5875      0.0241      0.0240      0.0244
 +
Triad:      2001.0897      0.0240      0.0240      0.0241
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl14.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity appears to be less than one microsecond.
 +
Each test below will take on the order of 9576 microseconds.
 +
    (= 9576 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)  Avg time    Min time    Max time
 +
Copy:        2254.3285      0.0142      0.0142      0.0142
 +
Scale:      2291.6040      0.0140      0.0140      0.0140
 +
Add:        2779.5354      0.0173      0.0173      0.0173
 +
Triad:      2804.8951      0.0177      0.0171      0.0215
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl15.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity appears to be less than one microsecond.
 +
Each test below will take on the order of 9788 microseconds.
 +
    (= 9788 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)  Avg time    Min time    Max time
 +
Copy:        2223.0043      0.0146      0.0144      0.0161
 +
Scale:      2264.6703      0.0142      0.0141      0.0142
 +
Add:        2740.5171      0.0176      0.0175      0.0178
 +
Triad:      2762.2584      0.0174      0.0174      0.0174
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------
 +
hcl16.heterogeneous.ucd.ie
 +
-------------------------------------------------------------
 +
STREAM version $Revision: 5.9 $
 +
-------------------------------------------------------------
 +
This system uses 8 bytes per DOUBLE PRECISION word.
 +
-------------------------------------------------------------
 +
Array size = 2000000, Offset = 0
 +
Total memory required = 45.8 MB.
 +
Each test is run 10 times, but only
 +
the *best* time for each is used.
 +
-------------------------------------------------------------
 +
Number of Threads requested = 1
 +
-------------------------------------------------------------
 +
Printing one line per active thread....
 +
-------------------------------------------------------------
 +
Your clock granularity appears to be less than one microsecond.
 +
Each test below will take on the order of 9590 microseconds.
 +
    (= 9590 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)  Avg time    Min time    Max time
 +
Copy:        2285.3882      0.0140      0.0140      0.0143
 +
Scale:      2294.5687      0.0140      0.0139      0.0140
 +
Add:        2800.9568      0.0172      0.0171      0.0172
 +
Triad:      2823.2048      0.0170      0.0170      0.0171
 +
-------------------------------------------------------------
 +
Solution Validates
 +
-------------------------------------------------------------

Latest revision as of 16:38, 13 June 2011

Cluster Specifications

Name Make/Model IP Processor Front Side Bus L2 Cache RAM HDD 1 HDD 2 NIC Rack
hclswitch1 Cisco Catalyst 3560G 192.168.21.252 N/A N/A N/A N/A N/A N/A 24 x Gigabit 42
hclswitch2 Cisco Catalyst 3560G 192.168.21.253 N/A N/A N/A N/A N/A N/A 24 x Gigabit 41
N/A APC Smart UPS 1500 N/A N/A N/A N/A N/A N/A N/A N/A 1 – 2
Hcl01 (NIC1) Dell Poweredge 750 192.168.21.3 3.4 Xeon 800MHz 1MB 1GB 80GB SATA 250GB SATA 2 x Gigabit 3
Hcl01 (NIC2)
192.168.21.103






3
Hcl02 (NIC1) Dell Poweredge 750 192.168.21.4 3.4 Xeon 800MHz 1MB 1GB (4x256) 80GB SATA 250GB SATA 2 x Gigabit 4
Hcl02 (NIC2)
192.168.21.104






4
Hcl03 (NIC1) Dell Poweredge 750 192.168.21.5 3.4 Xeon 800MHz 1MB 1GB (2x512) 80GB SATA N/A 2 x Gigabit 5
Hcl03 (NIC2)
192.168.21.105






5
Hcl04 (NIC1) Dell Poweredge 750 192.168.21.6 3.4 Xeon 800MHz 1MB 1GB 80GB SATA N/A 2 x Gigabit 6
Hcl04 (NIC2)
192.168.21.106






6
Hcl05 (NIC1) Dell Poweredge SC1425 192.168.21.7 3.6 Xeon 800MHz 2MB 256MB 80GB SATA N/A 2 x Gigabit 7
Hcl05 (NIC2)
192.168.21.107






7
Hcl06 (NIC1) Dell Poweredge SC1425 192.168.21.8 3.0 Xeon 800MHz 2MB 256MB 80GB SATA N/A 2 x Gigabit 8
Hcl06 (NIC2)
192.168.21.108






8
Hcl07(NIC1) Dell Poweredge 750 192.168.21.9 3.4 Xeon 800MHz 1MB 256MB (1x256) 80GB SATA N/A 2 x Gigabit 9
Hcl07 (NIC2)
192.168.21.109






9
Hcl08 (NIC1) Dell Poweredge 750 192.168.21.10 3.4 Xeon 800MHz 1MB 256MB (1x256) 80GB SATA N/A 2 x Gigabit 10
Hcl08 (NIC2)
192.168.21.110






10
Hcl09 (NIC1) IBM E-server 326 192.168.21.11 1.8 AMD Opteron 1GHz 1MB 1GB 80GB SATA N/A 2 x Gigabit 11
Hcl09 (NIC2)
192.168.21.111






11
Hcl10 (NIC1) IBM E-server 326 192.168.21.12 1.8 AMD Opteron 1GHz 1MB 1GB 80GB SATA N/A 2 x Gigabit 12
Hcl10 (NIC2)
192.168.21.112






12
Hcl11 (NIC1) IBM X-Series 306 192.168.21.13 3.2 P4 800MHz 1MB 512MB 80GB SATA N/A 2 x Gigabit 13
Hcl11 (NIC2)
192.168.21.113






13
Hcl12 (NIC1) HP Proliant DL 320 G3 192.168.21.14 3.4 P4 800MHz 1MB 512MB 80GB SATA N/A 2 x Gigabit 14
Hcl12 (NIC2)
192.168.21.114






14
Hcl13 (NIC1) HP Proliant DL 320 G3 192.168.21.15 2.9 Celeron 533MHz 256KB 1GB 80GB SATA N/A 2 x Gigabit 15
Hcl13 (NIC2)
192.168.21.115






15
Hcl14 (NIC1) HP Proliant DL 140 G2 192.168.21.16 3.4 Xeon 800MHz 1MB 1GB 80GB SATA N/A 2 x Gigabit 16
Hcl14 (NIC2)
192.168.21.116






16
Hcl15 (NIC1) HP Proliant DL 140 G2 192.168.21.17 2.8 Xeon 800MHz 1MB 1GB 80GB SATA N/A 2 x Gigabit 17
Hcl15 (NIC2)
192.168.21.117






17
Hcl16 (NIC1) HP Proliant DL 140 G2 192.168.21.18 3.6 Xeon 800MHz 2MB 384MB 80GB SATA N/A 2 x Gigabit 18
Hcl16 (NIC2)
192.168.21.118






18

Cluster Benchmarks

Stream

Cluster Performance

----------------------------------------------
Double precision appears to have 16 digits of accuracy
Assuming 8 bytes per DOUBLE PRECISION word
----------------------------------------------
Number of processors =           18
Array size =    2000000
Offset     =          0
The total memory requirement is     824.0 MB (     45.8MB/task)
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:      24589.1750      0.0235      0.0234      0.0237
Scale:     24493.9786      0.0237      0.0235      0.0245
Add:       27594.1797      0.0314      0.0313      0.0315
Triad:     27695.7938      0.0313      0.0312      0.0315
-----------------------------------------------
Solution Validates!
-----------------------------------------------

Individual Node Performance

Stream bench results.png

hcl01.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity appears to be less than one microsecond.
Each test below will take on the order of 8386 microseconds.
   (= 8386 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)   Avg time     Min time     Max time
Copy:        2615.4617       0.0125       0.0122       0.0132
Scale:       2609.2783       0.0125       0.0123       0.0133
Add:         3046.4707       0.0161       0.0158       0.0168
Triad:       3064.7322       0.0160       0.0157       0.0166
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl02.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity appears to be less than one microsecond.
Each test below will take on the order of 7790 microseconds.
   (= 7790 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)   Avg time     Min time     Max time
Copy:        2740.6840       0.0117       0.0117       0.0120
Scale:       2745.3930       0.0117       0.0117       0.0117
Add:         3063.1599       0.0157       0.0157       0.0157
Triad:       3075.3572       0.0156       0.0156       0.0159
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl03.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity appears to be less than one microsecond.
Each test below will take on the order of 8382 microseconds.
   (= 8382 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)   Avg time     Min time     Max time
Copy:        2788.6728       0.0115       0.0115       0.0115
Scale:       2722.0144       0.0118       0.0118       0.0121
Add:         3266.6166       0.0148       0.0147       0.0150
Triad:       3287.4249       0.0146       0.0146       0.0147
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl04.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity appears to be less than one microsecond.
Each test below will take on the order of 8378 microseconds.
   (= 8378 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)   Avg time     Min time     Max time
Copy:        2815.4071       0.0114       0.0114       0.0114
Scale:       2751.5270       0.0116       0.0116       0.0117
Add:         3260.1979       0.0148       0.0147       0.0150
Triad:       3274.2183       0.0147       0.0147       0.0150
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl05.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity appears to be less than one microsecond.
Each test below will take on the order of 14916 microseconds.
   (= 14916 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)   Avg time     Min time     Max time
Copy:        1581.8068       0.0203       0.0202       0.0204
Scale:       1557.1081       0.0207       0.0206       0.0215
Add:         1807.7015       0.0266       0.0266       0.0266
Triad:       1832.9646       0.0263       0.0262       0.0265
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl06.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity appears to be less than one microsecond.
Each test below will take on the order of 14824 microseconds.
   (= 14824 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)   Avg time     Min time     Max time
Copy:        1558.3835       0.0206       0.0205       0.0206
Scale:       1550.3951       0.0207       0.0206       0.0209
Add:         1863.4239       0.0258       0.0258       0.0259
Triad:       1885.3916       0.0255       0.0255       0.0259
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl07.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity appears to be less than one microsecond.
Each test below will take on the order of 13642 microseconds.
   (= 13642 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)   Avg time     Min time     Max time
Copy:        1759.4014       0.0183       0.0182       0.0186
Scale:       1740.2731       0.0184       0.0184       0.0185
Add:         2036.4962       0.0236       0.0236       0.0238
Triad:       2045.5920       0.0235       0.0235       0.0235
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl08.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity appears to be less than one microsecond.
Each test below will take on the order of 13476 microseconds.
   (= 13476 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)   Avg time     Min time     Max time
Copy:        1809.6454       0.0177       0.0177       0.0177
Scale:       1784.8271       0.0179       0.0179       0.0179
Add:         2085.3320       0.0231       0.0230       0.0232
Triad:       2095.7094       0.0231       0.0229       0.0239
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl09.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 2
-------------------------------------------------------------
Printing one line per active thread....
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 7890 microseconds.
   (= 3945 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)   Avg time     Min time     Max time
Copy:        2838.6204       0.0114       0.0113       0.0115
Scale:       2774.6396       0.0116       0.0115       0.0117
Add:         3144.0396       0.0155       0.0153       0.0156
Triad:       3160.7905       0.0153       0.0152       0.0156
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl10.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 2
-------------------------------------------------------------
Printing one line per active thread....
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 7959 microseconds.
   (= 3979 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)   Avg time     Min time     Max time
Copy:        2864.2732       0.0113       0.0112       0.0114
Scale:       2784.2952       0.0116       0.0115       0.0118
Add:         3162.2553       0.0153       0.0152       0.0155
Triad:       3223.8430       0.0151       0.0149       0.0153
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl11.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 13082 microseconds.
   (= 13082 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)   Avg time     Min time     Max time
Copy:        1842.8984       0.0174       0.0174       0.0174
Scale:       1818.1816       0.0177       0.0176       0.0179
Add:         2109.8918       0.0228       0.0227       0.0231
Triad:       2119.0161       0.0227       0.0227       0.0227
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl12.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity appears to be less than one microsecond.
Each test below will take on the order of 12621 microseconds.
   (= 12621 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)   Avg time     Min time     Max time
Copy:        1805.0657       0.0178       0.0177       0.0179
Scale:       1795.5385       0.0179       0.0178       0.0182
Add:         2089.9636       0.0230       0.0230       0.0230
Triad:       2097.5313       0.0229       0.0229       0.0231
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl13.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity appears to be less than one microsecond.
Each test below will take on the order of 12203 microseconds.
   (= 12203 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)   Avg time     Min time     Max time
Copy:        1768.9387       0.0181       0.0181       0.0182
Scale:       1765.9100       0.0182       0.0181       0.0184
Add:         2000.5875       0.0241       0.0240       0.0244
Triad:       2001.0897       0.0240       0.0240       0.0241
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl14.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity appears to be less than one microsecond.
Each test below will take on the order of 9576 microseconds.
   (= 9576 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)   Avg time     Min time     Max time
Copy:        2254.3285       0.0142       0.0142       0.0142
Scale:       2291.6040       0.0140       0.0140       0.0140
Add:         2779.5354       0.0173       0.0173       0.0173
Triad:       2804.8951       0.0177       0.0171       0.0215
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl15.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity appears to be less than one microsecond.
Each test below will take on the order of 9788 microseconds.
   (= 9788 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)   Avg time     Min time     Max time
Copy:        2223.0043       0.0146       0.0144       0.0161
Scale:       2264.6703       0.0142       0.0141       0.0142
Add:         2740.5171       0.0176       0.0175       0.0178
Triad:       2762.2584       0.0174       0.0174       0.0174
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------

hcl16.heterogeneous.ucd.ie

-------------------------------------------------------------
STREAM version $Revision: 5.9 $
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 2000000, Offset = 0
Total memory required = 45.8 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Number of Threads requested = 1
-------------------------------------------------------------
Printing one line per active thread....
-------------------------------------------------------------
Your clock granularity appears to be less than one microsecond.
Each test below will take on the order of 9590 microseconds.
   (= 9590 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)   Avg time     Min time     Max time
Copy:        2285.3882       0.0140       0.0140       0.0143
Scale:       2294.5687       0.0140       0.0139       0.0140
Add:         2800.9568       0.0172       0.0171       0.0172
Triad:       2823.2048       0.0170       0.0170       0.0171
-------------------------------------------------------------
Solution Validates
-------------------------------------------------------------