Missing loba_lln.h and loba_lln.cpp added. ALGORITHMS updated to include bulk and...

diff --git a/ALGORITHMS b/ALGORITHMS
index e9f07fa41595757e514f255939c6684b2d9e61cb..cc601b3848663f68cc21851e123a8b151480b385 100644 (file)
--- a/ALGORITHMS
+++ b/ALGORITHMS
@@ -1,5 +1,21 @@
 DESCRIPTIONS DES ALGORITHMES D'ÉQUILIBRAGE
 
 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é.
 besteffort
 ==========
 Ordonne les voisins du moins chargé au plus chargé.

diff --git a/loba_lln.cpp b/loba_lln.cpp
new file mode 100644 (file)
index 0000000..fa762c8
--- /dev/null
+++ b/loba_lln.cpp
@@ -0,0 +1,40 @@
+#include <algorithm>
+#include <xbt/log.h>
+
+XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(loba);
+
+#include "loba_lln.h"
+
+void loba_lln::load_balance()
+{
+       std::vector<int>  listLessLoadedNeighbors;
+       unsigned i;
+       double myLoad = get_load();
+       unsigned size = pneigh.size();
+       double *S = new double[size];
+       double lessLoad = get_load();
+
+       listLessLoadedNeighbors.clear();
+               for(i=0;i<size;++i) {
+                       S[i]=0.0;
+                       if( pneigh[i]->get_load()< lessLoad ) 
+                                       listLessLoadedNeighbors.push_back(i);
+               }
+               int nbLessLoadedNeighbors=listLessLoadedNeighbors.size();
+               for( i=0; i<listLessLoadedNeighbors.size(); ++i) {
+                       double delta = (myLoad-pneigh[listLessLoadedNeighbors[i]]->get_load())/(nbLessLoadedNeighbors+1);
+                       if(myLoad-delta > pneigh[listLessLoadedNeighbors[i]]->get_load()) {
+                               S[i]=delta;
+                               myLoad-=delta;
+                       }
+               }
+               for(i=0; i<size; ++i) {
+                       send(pneigh[i], S[i]);
+                       XBT_DEBUG("sent to %s", pneigh[i]->get_name());
+               }
+       delete[] S;
+}
+
+// Local variables:
+// mode: c++
+// End:

diff --git a/loba_lln.h b/loba_lln.h
new file mode 100644 (file)
index 0000000..eac3a89
--- /dev/null
+++ b/loba_lln.h
@@ -0,0 +1,19 @@
+#ifndef LOBA_LLN_H
+#define LOBA_LLN_H
+
+#include "process.h"
+
+class loba_lln: public process {
+public:
+    loba_lln(int argc, char* argv[]): process(argc, argv) { }
+    ~loba_lln()                                           { }
+
+private:
+    void load_balance();
+};
+
+#endif //!LOBA_LLN_H
+
+// Local variables:
+// mode: c++
+// End: