THE WILD MAN
solutions
myFarm
un grid computing open-source en Java

Mise à disposition de la communauté un projet de calcul distribué développé en Java 1.6+ qui fonctionne sous Windows, Linux et Solaris et probablement sur tous les environnements qui supportent Java.

Ce projet s'appelle myfarm. Il est disponible sous licence LGPL, c'est à dire que le projet lui-même est entièrement libre et qu'il peut être incorporé dans des projets commerciaux sans compromettre les droits et la propriété de ces projets.

myfarm est déjà opérationnel dans sa première version et contient un exemple de calcul d'option européenne avec la méthode Monte-Carlo. Il reste cependant un peu de travail pour l'incorporer dans une solution professionnelle.

Pour décrire rapidement ce projet, myfarm est constitué de 4 agents qui communiquent entre eux régulièrement et d'une API:

myfarm peut fonctionner dans un environnement hétérogène, gère la charge des ressources et répartit au mieux les services sur les différents noeuds. Il est aussi tolérant aux pannes.

Pourquoi le faire en Java et pas en C++ ? Pour plusieurs raisons, souvent objectives:

Quels sont les principes de développement ?


Voici une todo list qui n'est pas exhaustive mais qui donne les premiers axes de développement:

Ce projet sera géré avec Subversion (à mettre en place) et un wiki (à mettre en place également) sera dédié à son utilisation, son support et tout autre sujet qui peut le concerner.


Pour le télécharger, cliquer ici.

Voici un premier tutorial (en anglais) sur la manière de l'inclure dans un projet.

Suppose that you have a process that you want to split and distribute on several computers.
Let's take the evaluation of an european option with Monte-Carlo method as an example.

An option is described by its maturity, its strike and its spot.
The evaluation of this option needs the volatility of the spot and the risk free rate.

The basic algorithm consists in launching many simulations:

  1. for each simulation
    1. get a random spot at maturity
    2. computes the payoff i.e. Max(Spot at maturity - Strike, 0)
  2. compute average of all simulated payoff
  3. price of the option is the discounted average

It is obvious that we can split the simulation part so that each processor takes care of its range of simulations.
Then when all ranges are finished we can compute the average and the discount to get the price.

With myfarm, this process is encapsulated in 2 classes: Service and Job.
Service class takes care of splitting the process and to join or integrate individual results into one main result.
Job class is in charge of computing an individual part of the process.
To put the process on the farm, we need the Client class.

So, first thing to do is to extend the Service and Job classes and to override some methods by creating ServiceOption and JobOption classes.
ServiceOption owns an option, number of simulations and the option price.
JobOption will receive these parameters and also additionnal infos when the service will split the process.
Don't forget when you create structures like Option to add them Serializable property because it is necessary to transport the service through the farm.
Override:

  1. void ServiceOption.split(int _jobCount)
    According to a job count, divide the process and create a JobOption for each part
  2. void ServiceOption.integrate()
    This method will compute the average and the discount to get the option price.
  3. int ServiceOption.jobCount()
    This is not mandatory but you can control here the number of jobs allocated to the process.
  4. void JobOption.run()
    For a range of simulations, gets a random spot at the maturity and computes the payoff

Now we can run this process on the farm by using a Client class:

  1. Instanciate a Client and tell him where is the farm with a config file.
    Client client = new Client("myclient", null, 0, "client.ini");
  2. Instanciate a ServiceOption and sets all inputs.
    ServiceOption service = new ServiceOption("myoption", client.host);
  3. Put the service on the client.
    client.service = service;
  4. Attach the client to the farm.
    client.attach();
  5. The client sends the service to the farm and waits for result.
    client.run();
  6. Detach the client from the farm.
    client.detach();
  7. Get results from the service.
    ((ServiceOption) client.service).price

For more explanations, read ServiceOption.java, JobOption.java and Test.java codes.

That's all folks!

© 1998-2017