DESCRIPTIONS DES ALGORITHMES D'ÉQUILIBRAGE

bulk
====
N'ordonne pas les voisins. Cherche le nombre de voisins de charge minimum et 
le nombre de voisins de charge inferieure. En fonction de leur egalité ou non, 
un parametre alpha est caclulé. En cas d'egalité, alpha=1/(NB_voisins_charge_minimale +1) 
sinon alpha=1/(NB_voisins_charge_minimale +2). Chaque voisin dont la charge est inferieure 
recoit alpha*(myLoad - charge_du_voisin). Ensuite, une correction est effectuée
pour respecter la regle de Bertsekas.

lln pour Least Loaded Neighbors
===============================
A l'origine écrit par Raphaël.
Comme simple, mais tous les voisins de charge inferieure reçoivent de la charge 
pas seulement un voisin de charge minimale. N'ordonne pas les voisins, et ne respecte 
pas la regle de Bertsekas. Le parametre alpha vaut toujours (1/NB_voisins_charge_inferiure+1).

besteffort
==========
Ordonne les voisins du moins chargé au plus chargé.
Trouve ensuite, en les prenant dans ce ordre, le nombre maximal de
voisins tels que tous ont une charge inférieure à la moyenne des
charges des voisins sélectionnés, et de soi-même.

Les transferts de charge sont ensuite fait en visant cette moyenne pour
tous les voisins sélectionnés.  On envoie une quantité de charge égale
à (moyenne - charge_du_voisin).


fairstrategy
============
Ordonne les voisins du plus chargé au moins chargé.
Ensuite, tant qu'il reste un voisin moins chargé[*] que soi-même,
envoyer une certaine quantité de charge (delta = 0.001 dans le code) à
tous les voisins moins chargés que soi-même.
[*] en réalité, un voisin moins chargé à qui on peut envoyer delta de
    charge sans devenir moins chargé que lui.

Q: à quoi sert le tri du départ ?


makhoul
=======
Ordonne les voisins du moins chargé au plus chargé puis calcule les
différences de charge entre soi-même et chacun des voisins.

Ensuite, pour chaque voisin, dans l'ordre, et tant qu'on reste plus
chargé que le voisin en question, on lui envoie 1/(N+1) de la
différence calculée au départ, avec N le nombre de voisins.

Références:
    - Algorithm 2 dans
      http://portal.acm.org/citation.cfm?id=1459693.1459708
      http://info.iut-bm.univ-fcomte.fr/staff/giersch/biblio.html#bahi_giersch_makhoul.2008.scalable
ou bien
    - Algorithme 6 (p.111) dans la thèse de Abdallah Makhoul.


makhoul2
========
Comme makhoul, mais la différence est calculée avec la charge courante
(intégrant donc les envois déjà faits).

Références:
    - le code source :-(
      cf. MAKHOUL.txt


none
====
Aucun équilibrage.  Peut-être utile pour tester/déboguer le code.


simple
======
Tentative de respecter simplement les conditions de Bertsekas.
Parmi les voisins moins chargés que soi, on sélectionne :
    - un des moins chargés (vmin) ;
    - un des plus chargés (vmax),
puis on équilibre avec vmin en s'assurant que notre charge reste
toujours supérieure à celle de vmin et à celle de vmax.

On envoie donc (avec "self" pour soi-même) :
    min((load(self) - load(vmin)) / 2, (load(self) - load(vmax)))