VL SOFT SERVICES mise à jour: 1 octobre 2009

VL soft met à 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:

• mymanager qui supervise la ferme
• mydispatcher qui gère les services en les découpant en morceaux, chaque morceau est calculé sur un myworker
• myworker qui effectue les calculs relatifs aux morceaux de services
• myclient qui est le point de contact entre un programme et la ferme
• L'API permet aux utilisateurs, à travers la surcharge de seulement 2 classes, d'inclure leurs propres services et de les distribuer sur myfarm

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:

• Java 1.6+ est, pour la partie calculatoire, aussi rapide que le C++.
• L'environnement Eclipse (mais aussi NetBeans IDE) est ultra performant. Les environnements C++ (comme Visual C++ ou Code::Blocks) font vraiment pâle figure et ont au moins 10 ans de retard.
• Java 1.6+ inclut par défaut une quantité de libraries (réseau, sérialisation, threads, ...) qui permet d'obtenir des résultats très rapidement.
• Le langage Java est bien plus rigoureux que le langage C++ avec ses héritages malsains du C, d'où une qualité du code réelle et par conséquent beaucoup moins d'erreurs hasardeuses.

Quels sont les principes de développement ?

• Garder toujours en tête ce principe: less is more.
• Les utilisateurs finaux de myfarm doivent pouvoir inclure ce framework simplement dans leurs programmes.

• Make sure that myfarm will never give up
  • catch all exceptions
  • reboot nodes if needed
  • when machine boot, don't forget to relaunch nodes
• Improve measure of load both on linux and windows
• Give progress infos to client
• First big test with 100 nodes
• Develop graphical monitor
• Include node version to avoid farm conflicts
• Improve socket management
• Improve thread management
• Improve serialization
• Allow farm backup when current farm is down

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.

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!