Difference between revisions of "HCL Cluster Specifications"

From HCL
Jump to: navigation, search
Line 432: Line 432:
 
| 18
 
| 18
 
|}
 
|}
 +
 +
==Cluster Benchmarks==
 +
===Stream===
 +
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
 +
-------------------------------------------------------------

Revision as of 12:13, 29 July 2010

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 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 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 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 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 1GB 80GB SATA N/A 2 x Gigabit 18
Hcl16 (NIC2)
192.168.21.118






18

Cluster Benchmarks

Stream

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
-------------------------------------------------------------
Retrieved from "https://hcl.ucd.ie/wiki/index.php?title=HCL_Cluster_Specifications&oldid=453"