Difference between revisions of "HCL Cluster Specifications"

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

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

Difference between revisions of "HCL Cluster Specifications"

Latest revision as of 16:38, 13 June 2011

Contents

Cluster Specifications

Cluster Benchmarks

Stream

Cluster Performance

Individual Node Performance

Navigation menu

Views

Personal tools

Navigation

Search

Tools

@@ Line 1: / Line 1: @@
+==Cluster Specifications==
 {|  border="1" cellspacing="1" cellpadding="5"
 | Name
@@ Line 48: / Line 50: @@
 | 1 – 2
 |-
-|  ALIGN=LEFT | Hcl01 (NIC1)
+|  ALIGN=LEFT | [[Hcl01]] (NIC1)
 |  ALIGN=LEFT | Dell Poweredge 750
 |  ALIGN=LEFT | 192.168.21.3
@@ Line 72: / Line 74: @@
 | 3
 |-
-|  ALIGN=LEFT | Hcl02 (NIC1)
+|  ALIGN=LEFT | [[Hcl02]] (NIC1)
 |  ALIGN=LEFT | Dell Poweredge 750
 |  ALIGN=LEFT | 192.168.21.4
@@ Line 78: / Line 80: @@
 |  ALIGN=LEFT | 800MHz
 |  ALIGN=LEFT | 1MB
-|  ALIGN=LEFT | 1GB
+|  ALIGN=LEFT | 1GB (4x256)
 |  ALIGN=LEFT | 80GB SATA
 |  ALIGN=LEFT | 250GB SATA
@@ Line 96: / Line 98: @@
 | 4
 |-
-|  ALIGN=LEFT | Hcl03 (NIC1)
+|  ALIGN=LEFT | [[Hcl03]] (NIC1)
 |  ALIGN=LEFT | Dell Poweredge 750
 |  ALIGN=LEFT | 192.168.21.5
@@ Line 102: / Line 104: @@
 |  ALIGN=LEFT | 800MHz
 |  ALIGN=LEFT | 1MB
-|  ALIGN=LEFT | 1GB
+|  ALIGN=LEFT | 1GB (2x512)
 |  ALIGN=LEFT | 80GB SATA
 |  ALIGN=LEFT | N/A
@@ Line 120: / Line 122: @@
 | 5
 |-
-|  ALIGN=LEFT | Hcl04 (NIC1)
+|  ALIGN=LEFT | [[Hcl04]] (NIC1)
 |  ALIGN=LEFT | Dell Poweredge 750
 |  ALIGN=LEFT | 192.168.21.6
@@ Line 144: / Line 146: @@
 | 6
 |-
-|  ALIGN=LEFT | Hcl05 (NIC1)
+|  ALIGN=LEFT | [[Hcl05]] (NIC1)
 |  ALIGN=LEFT | Dell Poweredge SC1425
 |  ALIGN=LEFT | 192.168.21.7
@@ Line 168: / Line 170: @@
 | 7
 |-
-|  ALIGN=LEFT | Hcl06 (NIC1)
+|  ALIGN=LEFT | [[Hcl06]] (NIC1)
 |  ALIGN=LEFT | Dell Poweredge SC1425
 |  ALIGN=LEFT | 192.168.21.8
@@ Line 192: / Line 194: @@
 | 8
 |-
-|  ALIGN=LEFT | Hcl07 (NIC1)
+|  ALIGN=LEFT | [[Hcl07]](NIC1)
 |  ALIGN=LEFT | Dell Poweredge 750
 |  ALIGN=LEFT | 192.168.21.9
@@ Line 198: / Line 200: @@
 |  ALIGN=LEFT | 800MHz
 |  ALIGN=LEFT | 1MB
-|  ALIGN=LEFT | 256MB
+|  ALIGN=LEFT | 256MB (1x256)
 |  ALIGN=LEFT | 80GB SATA
 |  ALIGN=LEFT | N/A
@@ Line 216: / Line 218: @@
 | 9
 |-
-|  ALIGN=LEFT | Hcl08 (NIC1)
+|  ALIGN=LEFT | [[Hcl08]] (NIC1)
 |  ALIGN=LEFT | Dell Poweredge 750
 |  ALIGN=LEFT | 192.168.21.10
@@ Line 222: / Line 224: @@
 |  ALIGN=LEFT | 800MHz
 |  ALIGN=LEFT | 1MB
-|  ALIGN=LEFT | 256MB
+|  ALIGN=LEFT | 256MB (1x256)
 |  ALIGN=LEFT | 80GB SATA
 |  ALIGN=LEFT | N/A
@@ Line 240: / Line 242: @@
 | 10
 |-
-|  ALIGN=LEFT | Hcl09 (NIC1)
+|  ALIGN=LEFT | [[Hcl09]] (NIC1)
 |  ALIGN=LEFT | IBM E-server 326
 |  ALIGN=LEFT | 192.168.21.11
@@ Line 264: / Line 266: @@
 | 11
 |-
-|  ALIGN=LEFT | Hcl10 (NIC1)
+|  ALIGN=LEFT | [[Hcl10]] (NIC1)
 |  ALIGN=LEFT | IBM E-server 326
 |  ALIGN=LEFT | 192.168.21.12
@@ Line 288: / Line 290: @@
 | 12
 |-
-|  ALIGN=LEFT | Hcl11 (NIC1)
+|  ALIGN=LEFT | [[Hcl11]] (NIC1)
 |  ALIGN=LEFT | IBM X-Series 306
 |  ALIGN=LEFT | 192.168.21.13
@@ Line 312: / Line 314: @@
 | 13
 |-
-|  ALIGN=LEFT | Hcl12 (NIC1)
+|  ALIGN=LEFT | [[Hcl12]] (NIC1)
 |  ALIGN=LEFT | HP Proliant DL 320 G3
 |  ALIGN=LEFT | 192.168.21.14
@@ Line 336: / Line 338: @@
 | 14
 |-
-|  ALIGN=LEFT | Hcl13 (NIC1)
+|  ALIGN=LEFT | [[Hcl13]] (NIC1)
 |  ALIGN=LEFT | HP Proliant DL 320 G3
 |  ALIGN=LEFT | 192.168.21.15
@@ Line 360: / Line 362: @@
 | 15
 |-
-|  ALIGN=LEFT | Hcl14 (NIC1)
+|  ALIGN=LEFT | [[Hcl14]] (NIC1)
 |  ALIGN=LEFT | HP Proliant DL 140 G2
 |  ALIGN=LEFT | 192.168.21.16
@@ Line 384: / Line 386: @@
 | 16
 |-
-|  ALIGN=LEFT | Hcl15 (NIC1)
+|  ALIGN=LEFT | [[Hcl15]] (NIC1)
 |  ALIGN=LEFT | HP Proliant DL 140 G2
 |  ALIGN=LEFT | 192.168.21.17
@@ Line 408: / Line 410: @@
 | 17
 |-
-|  ALIGN=LEFT | Hcl16 (NIC1)
+|  ALIGN=LEFT | [[Hcl16]] (NIC1)
 |  ALIGN=LEFT | HP Proliant DL 140 G2
 |  ALIGN=LEFT | 192.168.21.18
@@ Line 414: / Line 416: @@
 |  ALIGN=LEFT | 800MHz
 |  ALIGN=LEFT | 2MB
-|  ALIGN=LEFT | 1GB
+|  ALIGN=LEFT | 384MB
 |  ALIGN=LEFT | 80GB SATA
 |  ALIGN=LEFT | N/A
@@ Line 432: / Line 434: @@
 | 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
+ -------------------------------------------------------------