Hazelcast 1.8 (comparison of the grid/cloud computing frameworks - part I)

Test environment

Hazelcast 1.8 nodes are multi-threaded. Because of that, we had to launch only one process on every machine in order to fully utilize available processing units. Hazelcast is fully distributed, so we didn't have to launch any additional processes. You can see the architecture of the test environment on the following figure:

Code

Hazelcast's distributed executor service operates on the Callable/Runnable interfaces. The main work was done in the Agent class, which implements Callable interface:

public class Agent implements Callable<FastBigInt128>, Serializable {
    private static final long serialVersionUID = 1L;
    private String[] imageDesc;
    private int z;

    public Agent(String[] imageDesc, int z) {
        this.imageDesc = imageDesc;
        this.z = z;
    }

    public FastBigInt128 call() {
        Worker cmbfWorker = new Worker();
        FastBigInt128 result = cmbfWorker.countInImage(imageDesc);
        System.out.println("\tResult from task #" + z + ", " + "\tvalue: " + result);
        return result;
    }
}

In order to perform computations, we had to divide problem into small tasks and submit them into executor service:

for (int i = 1; i <= n; i++) {
    for (final String[] imageDesc : cmbfWorker.generateImages(i, level)) {
        Future<FastBigInt128> future = executorService.submit(new Agent(imageDesc, ++count));
        tasks.add(future);
    }
}

After that we had to gather results:

for (Future<FastBigInt128> w : tasks) {
    results.add(w.get());
}

You can find all the above code in our code repository:  http://dacframe.org/lab

Results

You can see all the results with std deviation and average values on the following table:

Hazelcast 1.8 <-->

Average	348 716.70	321 922.70	335 363.30
Std Deviation	11 792.94	4 687.92	2 030.06
	Tasks: 341	Tasks: 2705	Tasks: 33700
	366 129	320 420	333 936
	330 710	318 858	333 163
	362 847	314 945	332 826
	356 169	326 624	336 702
	351 765	326 316	336 462
	346 890	324 684	334 228
	335 335	315 246	333 895
	336 553	319 551	337 206
	346 934	326 139	338 997
	353 835	326 444	336 218

As you can see on the above table, std deviation is quite big for 341 tasks test case. This means, that some sort of task pre-fetching took place and the load balancer could be improved. However, significant growth of number of tasks to compute (from 341 to 33700) didn't increase the time of computation -> margin for communication is small.

CPU

CPU usage (%user and %system) gathered on the intel1 machine:

Memory

Memory usage gathered on the intel1 machine:

Network

Network usage (received and transmitted bytes/s) gathered on the intel1 machine: