Skip to end of metadata
Go to start of metadata

The first test, was to find the best combination of the block size and the percentage of memory that will be used. (e.c if a node has a 20Gbyte memory, and the percentage is 80%, then only 16Gbytes are going to be used).

I first visited the http://hpl-calculator.sourceforge.net/ site. I submited my system's data which are the following:

Number of nodes: 1     -------  because i used only 1 core for my tests

Cores per node: 8

Speed per core: 2,27 GHz

Memory per node: 16GByte

Operations per cycle: 4

For this test, i didn't use any compiler optimizations e.t.c. That will be done in another test. For now, the only we care is to find the best combination of block size and memory percentage. 

I used these different combinations:

block size: 128,  memory percentage: 80%, 84%, 90%

block size: 152,  memory percentage: 80%, 84%, 90%

block size: 176,  memory percentage: 80%, 84%, 90%

block size: 200,  memory percentage: 80%, 84%, 90%

block size: 224,  memory percentage: 80%, 84%, 90%

block size: 256,  memory percentage: 80%, 84%, 90%

The time results for each combination are as follow:


     
the resulting graph is as follows:      

        

The x-axes on the graph represents the different block size and the y-axes represents the execution time in seconds.
Every different line colour is representing a different memory percentage (blue for 80%, red for 84% and green for 90%).
As we see, we have the best results when the memory percentage is 80%. As the used memory percentage increases, execution time also increases. 
Another observation, is that execution time is reduced for bigger block size (e.c for 80% memory percentage, if the block size is 128 execution time is 3351.53 seconds and for block size 256 execution time is 2893.64 seconds).

We have the smallest execution time for memory percentage 80% and block size 256, so we will proceed to our work with this combination as it gives as the best time results.

What about the number of Giga-Flops? The result is not the expected. The bigest number of Giga-Flops we have is 23.85, for a block size of 256 and memory percentage 90%.
The expected number of Giga-Flops we should have is 57 for 80% mem.percentage, 60 for 84% mem.percentage and 64 for 90% mem.percentage.

Labels:
None
Enter labels to add to this page:
Please wait 
Looking for a label? Just start typing.