DESCRIPTIONS DES ALGORITHMES D'ÉQUILIBRAGE

2besteffort
===========
Calcule la moyenne des charges des voisins et de soi-même.
Ordonne ensuite les voisins du moins chargé au plus chargé, et
effectue les transferts en prenant les voisins dans cet ordre.  Les
transferts de charge sont faits en visant cette moyenne pour tous les
voisins.  On envoie une quantité de charge égale à
        min(moyenne - charge_du_voisin, charge_propre - moyenne),
tant que cette quantité est positive.

NB: Ceci est une variante de besteffort, la différence étant la
    moyenne visée.


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 faits en visant cette moyenne pour
tous les voisins sélectionnés.  On envoie une quantité de charge égale
à (moyenne - charge_du_voisin).


bulk
====
N'ordonne pas les voisins. Cherche le nombre de voisins de charge
minimum et le nombre de voisins de charge inférieure. En fonction de
leur égalité ou non, un paramètre alpha est calculé. En cas d'égalité,
        alpha = 1 / (NB_voisins_charge_minimale + 1),
sinon
        alpha = 1 / (NB_voisins_charge_minimale + 2).

Chaque voisin dont la charge est inférieure reçoit
        alpha * (myLoad - charge_du_voisin).
Ensuite, une correction est effectuée pour respecter la règle de
Bertsekas.


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 ?


lln pour Least Loaded Neighbors
===============================
À l'origine écrit par Raphaël.  Comme simple, mais tous les voisins de
charge inférieure reçoivent de la charge pas seulement un voisin de
charge minimale. N'ordonne pas les voisins, et ne respecte pas la
règle de Bertsekas. Le paramètre alpha vaut toujours
        1 / (NB_voisins_charge_inferieure + 1).


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


makhoul3
========
Comme makhoul mais, dans le ratio 1/(N+1), N correspond au nombre de
voisins moins chargés.


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)))