Calcium is part of the ProActive Grid Middleware for programming structured parallel and distributed applications. The framework provides a basic set of structured patterns (skeletons) that can be nested to represents more complex patterns. Skeletons are considered a high level programming model because all the parallelisms details are hidden from the programmer. In Calcium, distributed programming is achieved by using ProActive deployment framework and active object model.

The following steps must be performed for programming with the framework.

Problems inputed into the framework are treated as tasks. The tasks are interpreted by the remote skeleton interpreters as shown in the following Figure:

Figure 19.1. Task Flow in Calcium

The approach we will use corresponds to dividing the original search space into several smaller search spaces. Therefore, the most suitable pattern corresponds to Divide and Conquer.

// Dac(<Divide>,<Condition>,<Skeleton>,<Conquer>)
Skeleton<Challenge> root = new DaC<Challenge>( new ChallengeDivide(1),
                           new ChallengeDivideCondition(2), 
                           new Seq<Challenge>(new SolveChallenge(3)),
                           new ConquerChallenge(4));
        

We will call the problem as Challenge and we will represent it using the following class.

class Challenge implements Serializable{

public int max, min, solvableSize;

    public Vector<Integer> primes;

    /**
     * Creates a new challenge for finding primes.
     * @param min  The minimum of the interval.
     * @param max  The maximum of the interval.
     * @param solvableSize The size of the problems to be solved.
     */
    public Challenge(int min, int max, int solvableSize){
        this.min=min;
        this.max=max;
        this.solvableSize=solvableSize;
        primes=new Vector<Integer>();
    }
}

Note that the skeleton structure is parametrized using the Challenge class.

public class ChallengeDivide implements Divide<Challenge>{
    
    public Vector<Challenge> divide(Challenge param) {
        
        Challenge ttUp = new Challenge(1+param.min+(param.max-param.min)/2,param.max,param.solvableSize);

        Challenge ttDown = new Challenge(param.min,param.min+(param.max-param.min)/2, param.solvableSize);
        
        Vector<Challenge> v = new Vector<Challenge>();
        v.add(ttUp);
        v.add(ttDown);
        
        return v;
    }
}

public class ChallengeDivideCondition implements Condition<Challenge>{
    
    public boolean evalCondition(Challenge params) {
        
        return params.max-params.min > params.solvableSize;
    }
}

public class SolveChallenge implements Execute<Challenge>{

    public Challenge execute(Challenge param) {
        for(int i=param.min;i<=param.max;i++){
            if(isPrime(i)){
                param.primes.add(new Integer(i));
            }
        }
        
        return param;
    }
    //...
}

public class ConquerChallenge implements Conquer<Challenge>{
    
    public Challenge conquer(Challenge parent, Vector<Challenge> p) {
            
        for(Challenge param:p){
            parent.max=Math.max(parent.max, param.max);
            parent.min=Math.min(parent.min, param.min);
            parent.primes.addAll(param.primes);
        }

        Collections.sort(parent.primes);
        return parent;
    }
}

Skeleton<Challenge> root = ...; //Step 1
ResourceManager manager= new ProActiveManager(descriptor, "local");
Calcium<Challenge> calcium = new Calcium<Challenge>(manager);

Stream<Board> stream = calcium.newStream(root);

stream.input(new Challenge(1,6400,300));
stream.input(new Challenge(1,100,20));
stream.input(new Challenge(1,640,64));

calcium.boot(); //begin the evaluation

for(Challenge res = stream.getResult(); res != null; res = stream.getResult())
    System.out.println(res); //print results

calcium.shutdown(); //release the resources

Stats stats=stream.getStats(res);
System.out.println(stats);

These statistics refer to the global state of the framework by providing state information. The tasks can be in three different states: ready for execution, processing, waiting for other tasks to finish, and finished (ready to be collected by the user). The statistics corresponding to these states are:

Statistics for a specific moment can be directly retrieved from the Calcium instance:

StatsGlobal statsGlobal = calcium.getStatsGlobal()

An alternative is to create a monitor that can be performe functions based on the statistics. In the following example we activate a simple logger monitor that prints the statistics every 5 seconds.

Monitor monitor= new SimpleLogMonitor(calcium, 5);

monitor.start();
...
monitor.stop();

This statistics are specific for each result obtained from the framework. They provide information on how the result was obtained: