HCL Cluster Specifications

From HCL
Revision as of 13:28, 29 July 2010 by Rhiggins (talk | contribs) (Stream)

Jump to: navigation, search
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

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