DESCRIPTIONS DES ALGORITHMES D'ÉQUILIBRAGE

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