X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/loba.git/blobdiff_plain/b2a9557c04c983935ab89d840cdf652b392fb39b..3547772c2f2424e6b3f7d4b7414e939947e7c3f4:/ALGORITHMS?ds=inline

diff --git a/ALGORITHMS b/ALGORITHMS
index 69a2545..cc601b3 100644
--- a/ALGORITHMS
+++ b/ALGORITHMS
@@ -1,15 +1,45 @@
-DESCRIPTIONS DES ALGORITHMES
+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
 ============
-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.
+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
@@ -19,10 +49,29 @@ 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.