Added communication tracking for load balancing
authorRobert Brunner <rbrunner@uiuc.edu>
Wed, 6 Oct 1999 23:17:00 +0000 (23:17 +0000)
committerRobert Brunner <rbrunner@uiuc.edu>
Wed, 6 Oct 1999 23:17:00 +0000 (23:17 +0000)
18 files changed:
src/arch/net-sol-cc/conv-mach.csh
src/ck-core/ckarray.C
src/ck-core/ckarray.h
src/ck-ldb/CentralLB.C
src/ck-ldb/CentralLB.h
src/ck-ldb/LBComm.C [new file with mode: 0644]
src/ck-ldb/LBComm.h [new file with mode: 0644]
src/ck-ldb/LBDB.C
src/ck-ldb/LBDB.h
src/ck-ldb/LBDatabase.C
src/ck-ldb/RandCentLB.C
src/ck-ldb/lbdb.C
src/ck-ldb/lbdb.h
src/conv-core/queueing.c
src/conv-ldb/cldb.rand.c
src/conv-ldb/cldb.spray.c
src/conv-ldb/cldb.test.c
src/scripts/Makefile

index 1f10f25f64690e75e4a8e2f8c847299483c58e8b..ca86d8e5715f8b35b0d7bf2f3fc35a1835d201a8 100755 (executable)
@@ -16,7 +16,7 @@ set CMK_LDXX='CC -library=Cstd'
 set CMK_LD77=''
 set CMK_M4='m4'
 set CMK_SUF='o'
-set CMK_AR='ar q'
+set CMK_AR='CC -xar -o'
 set CMK_RANLIB='true'
 set CMK_LIBS='-lnsl -lsocket -lckqt'
 set CMK_SEQ_LIBS='-lnsl -lsocket'
index 2dfa28fa264d072b4dcd8510febccb5c9a8809d3..92252fc783d9446be3ef71a56fbb002fd5477643 100644 (file)
@@ -89,9 +89,10 @@ Array1D::Array1D(ArrayCreateMessage *msg)
   myId.id = (int)thisgroup;
 
   LDCallbacks myCallbacks;
-  myCallbacks.migrate = staticMigrate;
-  myCallbacks.setStats = staticSetStats;
-  myCallbacks.queryEstLoad = staticQueryLoad;
+  myCallbacks.migrate = reinterpret_cast<LDMigrateFn>(staticMigrate);
+  myCallbacks.setStats = reinterpret_cast<LDStatsFn>(staticSetStats);
+  myCallbacks.queryEstLoad =
+    reinterpret_cast<LDQueryEstLoadFn>(staticQueryLoad);
   
   myHandle = the_lbdb->RegisterOM(myId,this,myCallbacks);
 #endif
@@ -216,6 +217,13 @@ void Array1D::send(ArrayMessage *msg, int index, EntryIndexType ei)
   msg->serial_num = 1000*serial_num+CkMyPe();
   serial_num++;
 
+#if CMK_LBDB_ON
+  LDObjid dest;
+  dest.id[0] = index; dest.id[1] = dest.id[2] = dest.id[3] = 0;
+  
+  LDSend(myHandle,dest,UsrToEnv(msg)->getTotalsize());
+
+#endif
   if (elementIDs[index].state == here) {
 #if 0
     CPrintf("PE %d sending local message to index %d\n",CMyPe(),index);
@@ -492,8 +500,9 @@ void Array1D::RegisterElementForSync(int index)
   if (elementIDsReported == 1) { // This is the first element reported
     // If this is a sync array, register a sync callback so I can
     // inform the db when I start registering objects 
-    the_lbdb->AddLocalBarrierReceiver(staticRecvAtSync,
-                                     static_cast<void*>(this));
+    the_lbdb->
+      AddLocalBarrierReceiver(reinterpret_cast<LDBarrierFn>(staticRecvAtSync),
+                             static_cast<void*>(this));
   }
     
   elementIDs[index].uses_barrier = CmiTrue;  
@@ -501,7 +510,7 @@ void Array1D::RegisterElementForSync(int index)
   elementIDs[index].barrierData.index = index;
 
   elementIDs[index].barrierHandle = the_lbdb->
-    AddLocalBarrierClient(staticResumeFromSync,
+    AddLocalBarrierClient(reinterpret_cast<LDResumeFn>(staticResumeFromSync),
                          static_cast<void*>(&elementIDs[index].barrierData));
 
 }
@@ -550,6 +559,7 @@ ArrayElement::ArrayElement(ArrayElementCreateMessage *msg)
   thisArray = msg->arrayPtr;
   thisAID._setAid(thisArray->ckGetGroupId());
   thisAID._elem = (-1);
+  thisArrayID = thisAID;
   thisIndex = msg->index;
 }
 
@@ -561,6 +571,7 @@ ArrayElement::ArrayElement(ArrayElementMigrateMessage *msg)
   thisArray = msg->arrayPtr;
   thisAID._setAid(thisArray->ckGetGroupId());
   thisAID._elem = (-1);
+  thisArrayID = thisAID;
   thisIndex = msg->index;
 }
 
index 76e39cd192f8b4bcb56e565a81ca63a7e968e1c4..aba62d15daec51a6e0bf8ce8a88f75b7d7eb42de 100644 (file)
@@ -69,7 +69,8 @@ protected:
   };
 
   int thisIndex;
-  CkArrayID thisAID;
+  CkArrayID thisAID;     // thisArrayID is preferred
+  CkArrayID thisArrayID; // A duplicate of thisAID
   int numElements;
 
 public:
index b7dd18866f7e4151986a19808b23933acb4103a3..16f70babbf356e83a5f52f0c9154bc1f0d870b0a 100644 (file)
@@ -12,14 +12,14 @@ void CreateCentralLB()
   loadbalancer = CProxy_CentralLB::ckNew();
 }
 
-void CentralLB::staticMigrated(void* data, LDObjHandle h)
+extern "C" void CentralLB::staticMigrated(void* data, LDObjHandle h)
 {
   CentralLB *me = static_cast<CentralLB*>(data);
 
   me->Migrated(h);
 }
 
-void CentralLB::staticAtSync(void* data)
+extern "C" void CentralLB::staticAtSync(void* data)
 {
   CentralLB *me = static_cast<CentralLB*>(data);
 
@@ -30,8 +30,12 @@ CentralLB::CentralLB()
 {
   step = 0;
   theLbdb = CProxy_LBDatabase(lbdb).ckLocalBranch();
-  theLbdb->AddLocalBarrierReceiver(staticAtSync,static_cast<void*>(this));
-  theLbdb->NotifyMigrated(staticMigrated,static_cast<void*>(this));
+  theLbdb->
+    AddLocalBarrierReceiver(reinterpret_cast<LDBarrierFn>(staticAtSync),
+                           static_cast<void*>(this));
+  theLbdb->
+    NotifyMigrated(reinterpret_cast<LDMigratedFn>(staticMigrated),
+                  static_cast<void*>(this));
 
   stats_msg_count = 0;
   statsMsgsList = new CLBStatsMsg*[CkNumPes()];
@@ -39,6 +43,7 @@ CentralLB::CentralLB()
     statsMsgsList[i] = 0;
 
   statsDataList = new LDStats[CkNumPes()];
+  theLbdb->CollectStatsOn();
 }
 
 CentralLB::~CentralLB()
@@ -69,7 +74,8 @@ void CentralLB::AtSync()
   msg->n_comm = csz;
   theLbdb->GetCommData(msg->commData);
   theLbdb->ClearLoads();
-  CkPrintf("PE %d sending %d to ReceiveStats\n",CkMyPe(),msg->serial);
+  CkPrintf("PE %d sending %d to ReceiveStats %d objs, %d comm\n",
+          CkMyPe(),msg->serial,msg->n_objs,msg->n_comm);
   CProxy_CentralLB(thisgroup).ReceiveStats(msg,0);
 }
 
@@ -118,7 +124,7 @@ void CentralLB::ReceiveStats(CLBStatsMsg *m)
 
 void CentralLB::ReceiveMigration(CLBMigrateMsg *m)
 {
-  CkPrintf("[%d] in ReceiveMigration %d moves\n",CkMyPe(),m->n_moves);
+  //  CkPrintf("[%d] in ReceiveMigration %d moves\n",CkMyPe(),m->n_moves);
   migrates_expected = 0;
   for(int i=0; i < m->n_moves; i++) {
     MigrateInfo& move = m->moves[i];
@@ -157,7 +163,7 @@ CLBMigrateMsg* CentralLB::Strategy(LDStats* stats,int count)
     for(i=0; i < osz; i++) {
       CkPrintf("Object %d\n",i);
       CkPrintf("     id = %d\n",odata[i].id.id[0]);
-      CkPrintf("  OM id = %d\n",odata[i].omID);
+      CkPrintf("  OM id = %d\n",odata[i].omID.id);
       CkPrintf("    CPU = %f\n",odata[i].cpuTime);
       CkPrintf("   Wall = %f\n",odata[i].wallTime);
     }
@@ -166,13 +172,24 @@ CLBMigrateMsg* CentralLB::Strategy(LDStats* stats,int count)
     const int csz = stats[j].n_comm;
 
     CkPrintf("------------- Comm Data: PE %d: %d records -------------\n",
-            i,csz);
+            j,csz);
     for(i=0; i < csz; i++) {
-      CkPrintf("Object %d\n",i);
-      CkPrintf("    sender id = %d\n",cdata[i].sender);
-      CkPrintf("  receiver id = %d\n",cdata[i].receiver);
-      CkPrintf("     messages = %d\n",cdata[i].nMessages);
-      CkPrintf("        bytes = %d\n",cdata[i].nBytes);
+      CkPrintf("Link %d\n",i);
+      
+      if (cdata[i].from_proc)
+       CkPrintf("    sender PE = %d\n",cdata[i].src_proc);
+      else
+       CkPrintf("    sender id = %d:%d\n",
+                cdata[i].senderOM.id,cdata[i].sender.id[0]);
+
+      if (cdata[i].to_proc)
+       CkPrintf("  receiver PE = %d\n",cdata[i].dest_proc);
+      else     
+       CkPrintf("  receiver id = %d:%d\n",
+                cdata[i].receiverOM.id,cdata[i].receiver.id[0]);
+      
+      CkPrintf("     messages = %d\n",cdata[i].messages);
+      CkPrintf("        bytes = %d\n",cdata[i].bytes);
     }
   }
 
index f49c2a75ace23d6b9c86add87bea924cc6b65ea0..4c44ab572d244ae25000f7e63d5efa40147e8ddf 100644 (file)
@@ -43,10 +43,10 @@ public:
 protected:
   virtual CmiBool QueryBalanceNow(int) { return CmiTrue; };  
   virtual CLBMigrateMsg* Strategy(LDStats* stats,int count);
+  LBDatabase* theLbdb;
 
 private:  
   int step;
-  LBDatabase* theLbdb;
   int stats_msg_count;
   CLBStatsMsg** statsMsgsList;
   LDStats* statsDataList;
diff --git a/src/ck-ldb/LBComm.C b/src/ck-ldb/LBComm.C
new file mode 100644 (file)
index 0000000..49596d3
--- /dev/null
@@ -0,0 +1,164 @@
+#include <converse.h>
+
+#if CMK_LBDB_ON
+
+#include <stdio.h>
+#include <math.h>
+#include "LBComm.h"
+
+// Hash table mostly based on open hash table from Introduction to
+// Algorithms by Cormen, Leiserson, and Rivest
+
+static inline CmiBool ObjIDEqual(const LDObjid i1, const LDObjid i2)
+{
+  return static_cast<CmiBool>(i1.id[0] == i2.id[0] 
+        && i1.id[1] == i2.id[1] && i1.id[2] == i2.id[2] 
+        && i1.id[3] == i2.id[3]);
+};
+
+LBCommData* LBCommTable::HashInsert(const LBCommData data)
+{
+  if (in_use > cur_sz/2)
+    Resize();
+  int i = 0;
+  int j;
+  do {
+    j = data.hash(i,cur_sz);
+    //    CmiPrintf("Hashing to %d, %d %d\n",j,i,cur_sz);
+    if (state[j] == nil) {
+      state[j] = InUse;
+      set[j] = data;
+      in_use++;
+      return &set[j];
+    } else i++;
+  } while (i != cur_sz);
+
+  // No room for item, but I should never get here, because I would have
+  // resized the list
+  CmiPrintf("HashInsert Couldn't insert!\n");
+  return 0;
+}
+
+LBCommData* LBCommTable::HashSearch(const LBCommData data)
+{
+  int i=0;
+  int j;
+  do {
+    j = data.hash(i,cur_sz);
+    if (state[j] != nil && set[j].equal(data)) {
+      return &set[j];
+    }
+    i++;
+  } while (state[j] != nil && i != cur_sz);
+  return 0;
+}
+
+LBCommData* LBCommTable::HashInsertUnique(const LBCommData data)
+{
+  //  LBCommData* item = HashSearch(data);
+  LBCommData* item = 0;
+  if (!item) {
+    item = HashInsert(data);
+  }
+  return item;
+}
+
+void LBCommTable::Resize()
+{
+  LBCommData* old_set = set;
+  TableState* old_state = state;
+  int old_sz = cur_sz;
+
+  NewTable(old_sz*2);
+  for(int i=0; i < old_sz; i++) {
+    if (old_state[i] == InUse)
+      HashInsert(old_set[i]);
+  }
+  delete [] old_set;
+  delete [] old_state;
+}      
+
+CmiBool LBCommData::equal(const LBCommData d2) const
+{
+  if (from_proc) {
+    if (src_proc != d2.src_proc)
+      return CmiFalse;
+  } else {
+    if (srcObj.omhandle.id.id != d2.srcObj.omhandle.id.id 
+       || !ObjIDEqual(srcObj.id,d2.srcObj.id) )
+      return CmiFalse;
+  }
+  if (destOM.id != d2.destOM.id 
+      || !ObjIDEqual(destObj,d2.destObj))
+    return CmiFalse;
+  else return CmiTrue;
+}
+
+int LBCommData::compute_key()
+{
+  int kstring[80];
+  char* kptr = static_cast<char*>(static_cast<void*>(&(kstring[0])));
+  int pcount;
+
+  if (from_proc) {
+    pcount = sprintf(kptr,"%d",src_proc);
+    kptr += pcount;
+  } else {
+    pcount = sprintf(kptr,"%d%d%d%d%d",srcObj.omhandle.id.id,
+                    srcObj.id.id[0],srcObj.id.id[1],
+                    srcObj.id.id[2],srcObj.id.id[3]);
+    kptr += pcount;
+  }
+  pcount += sprintf(kptr,"%d%d%d%d%d",destOM.id,
+                   destObj.id[0],destObj.id[1],
+                   destObj.id[2],destObj.id[3]);
+  int k;
+  for(int i=0; i < (pcount+3)/4; i++)
+    k ^= kstring[i];
+
+  return k;
+}
+
+int LBCommData::hash(const int i, const int m) const
+{
+  const double a = 0.6803398875;
+  const int k = key();
+  const double ka = k * a;
+
+  int h1 = floor(m*(ka-floor(ka)));
+  int h2 = 1;  // Should be odd, to guarantee that h2 and size of table
+              // are relatively prime.
+
+  //  CmiPrintf("k=%d h1=%d h2=%d m=%d\n",k,h1,h2,m);
+  return (h1 + i * h2) % m;
+}
+
+void LBCommTable::GetCommData(LDCommData* data)
+{
+  LDCommData* out=data;
+  LBCommData* curtable=set;
+  TableState* curstate=state;
+  int i;
+
+  for(i=0; i < cur_sz; i++, curtable++, curstate++) {
+    if (*curstate == InUse) {
+      out->to_proc = CmiFalse;
+      if (curtable->from_proc) {
+       out->from_proc = CmiTrue;
+       out->src_proc = curtable->src_proc;
+      } else {
+       out->from_proc = CmiFalse;
+       out->src_proc = -1;
+       out->senderOM = curtable->srcObj.omhandle.id;
+       out->sender = curtable->srcObj.id;
+      }
+      out->receiverOM = curtable->destOM;
+      out->receiver = curtable->destObj;
+      out->messages = curtable->n_messages;
+      out->bytes = curtable->n_bytes;
+      out++;
+    }
+  }
+}
+
+#endif // CMK_LBDB_ON
diff --git a/src/ck-ldb/LBComm.h b/src/ck-ldb/LBComm.h
new file mode 100644 (file)
index 0000000..845b99e
--- /dev/null
@@ -0,0 +1,120 @@
+#ifndef LBCOMM_H
+#define LBCOMM_H
+
+#include "converse.h"
+#include "lbdb.h"
+
+class LBCommData {
+
+friend class LBCommTable;
+
+public:
+  LBCommData(int _src_proc, LDOMid _destOM, LDObjid _destObj) {
+    from_proc = CmiTrue;
+    src_proc = _src_proc;
+    destOM = _destOM;
+    destObj = _destObj;
+    n_messages = 0;
+    n_bytes = 0;
+    mykey = compute_key();
+  };
+
+  LBCommData(LDObjHandle _srcObj, LDOMid _destOM, LDObjid _destObj) {
+    from_proc = CmiFalse;
+    srcObj = _srcObj;
+    destOM = _destOM;
+    destObj = _destObj;
+    n_messages = 0;
+    n_bytes = 0;
+    mykey = compute_key();
+  };
+
+  LBCommData(const LBCommData& d) {
+    if (from_proc = d.from_proc)
+      src_proc = d.src_proc;
+    else srcObj = d.srcObj;
+    destOM = d.destOM;
+    destObj = d.destObj;
+    n_messages = d.n_messages;
+    n_bytes = d.n_messages;
+    mykey = d.mykey;
+  };
+
+  ~LBCommData() { };
+
+  LBCommData& operator=(const LBCommData& d) {
+    if (from_proc = d.from_proc)
+      src_proc = d.src_proc;
+    else srcObj = d.srcObj;
+    destOM = d.destOM;
+    destObj = d.destObj;
+    n_messages = d.n_messages;
+    n_bytes = d.n_messages;
+    mykey = d.mykey;
+    return *this;
+  };
+
+  void addMessage(int bytes) {
+    n_messages++;
+    n_bytes += bytes;
+  };
+
+  int key() const { return mykey; };
+  CmiBool equal(const LBCommData _d2) const;
+
+private:
+  LBCommData() {};
+  
+  int compute_key();
+  int hash(int i, int m) const;
+
+  int mykey;
+  CmiBool from_proc;
+  int src_proc;
+  LDObjHandle srcObj;
+  LDOMid destOM;
+  LDObjid destObj;
+  int n_messages;
+  int n_bytes;
+};
+
+class LBCommTable {
+public:
+
+  LBCommTable() {
+    NewTable(initial_sz);
+  };
+
+  ~LBCommTable() {
+    delete [] set;
+    delete [] state;
+  };
+
+  LBCommData* HashInsert(const LBCommData data);
+  LBCommData* HashInsertUnique(const LBCommData data);
+  LBCommData* HashSearch(const LBCommData data);
+  int CommCount() { CmiPrintf("Returning %d records\n",in_use); return in_use; };
+  void GetCommData(LDCommData* data);
+       
+private:
+  void NewTable(int _sz) {
+    set = new LBCommData[_sz];
+    state = new TableState[_sz];
+    cur_sz = _sz;
+    in_use = 0;
+    for(int i=0; i < _sz; i++)
+      state[i] = nil;
+  };
+  
+  void Resize();
+
+  enum { initial_sz = 1024 };
+  enum TableState { nil, InUse } ;
+  LBCommData* set;
+  TableState* state;
+  int cur_sz;
+  int in_use;
+};
+
+
+#endif
index d3c56cc6eed89d506211aa143fe3edfc0067651f..a9904103616fff97b139b0cabbde46d28e4224e5 100644 (file)
@@ -92,6 +92,41 @@ void LBDB::DoneRegisteringObjects(LDOMHandle _h)
   }
 }
 
+
+void LBDB::Send(LDOMHandle destOM, LDObjid destid, unsigned int bytes)
+{
+  LBCommData* item_ptr;
+
+  if (obj_running) {
+    LBCommData item(runningObj,destOM.id,destid);
+    item_ptr = commTable->HashInsertUnique(item);
+
+//     CmiPrintf("[%d] Sending %d from object manager %d, object {%d,%d,%d,%d}\n"
+//           "     to object manager %d, object {%d,%d,%d,%d}\n",
+//           CmiMyPe(),bytes,
+//           runningObj.omhandle.id.id,
+//           runningObj.id.id[0],runningObj.id.id[1],
+//           runningObj.id.id[2],runningObj.id.id[3],
+//           destOM.id.id,
+//           destid.id[0],destid.id[1],
+//           destid.id[2],destid.id[3]
+//           );
+  } else {
+    LBCommData item(CmiMyPe(),destOM.id,destid);
+    item_ptr = commTable->HashInsertUnique(item);
+
+//     CmiPrintf("[%d] Sending %d from processor %d\n"
+//           "     to object manager %d, object {%d,%d,%d,%d}\n",
+//           CmiMyPe(),bytes,
+//           CmiMyPe(),
+//           destOM.id.id,
+//           destid.id[0],destid.id[1],
+//           destid.id[2],destid.id[3]
+//           );
+  }  
+  item_ptr->addMessage(bytes);
+}
+
 void LBDB::ClearLoads(void)
 {
   int i;
@@ -101,6 +136,8 @@ void LBDB::ClearLoads(void)
       objs[i]->data.wallTime = 
        objs[i]->data.cpuTime = 0.;
     }
+  delete commTable;
+  commTable = new LBCommTable;
 }
 
 int LBDB::ObjDataCount()
@@ -164,7 +201,6 @@ void LBDB::DumpDatabase()
 
 LDBarrierClient LocalBarrier::AddClient(LDResumeFn fn, void* data)
 {
-  CmiPrintf("[%d] LocalBarrier Adding client\n",CmiMyPe());
   client* new_client = new client;
   new_client->fn = fn;
   new_client->data = data;
@@ -182,7 +218,6 @@ LDBarrierClient LocalBarrier::AddClient(LDResumeFn fn, void* data)
 
 void LocalBarrier::RemoveClient(LDBarrierClient c)
 {
-  CmiPrintf("[%d] LocalBarrier Removing client\n",CmiMyPe());
   const int cnum = c.serial;
   if (cnum < max_client && clients[cnum] != 0) {
     delete clients[cnum];
@@ -242,8 +277,6 @@ void LocalBarrier::CheckBarrier()
 
 void LocalBarrier::CallReceivers(void)
 {
-  CmiPrintf("All at barrier, calling receviers for %d clients\n",
-           client_count);
   CmiBool called_receiver=CmiFalse;
 
   for(int i=0; i < max_receiver; i++)
@@ -259,7 +292,6 @@ void LocalBarrier::CallReceivers(void)
 
 void LocalBarrier::ResumeClients(void)
 {
-  CmiPrintf("[%d] Resuming %d clients\n",CmiMyPe(),client_count);
   for(int i=0; i < max_client; i++)
     if (clients[i] != 0) 
       clients[i]->fn(clients[i]->data);
index f350d25688804a537f6c7d907d9196c92ac5fbbd..5c7d35456c5cca31a7e4beffa167e04e40c3fd36 100644 (file)
@@ -12,6 +12,7 @@
 
 #include "LBObj.h"
 #include "LBOM.h"
+#include "LBComm.h"
 
 class LocalBarrier {
 friend class LBDB;
@@ -64,6 +65,8 @@ public:
   LBDB() {
     statsAreOn = CmiFalse;
     omCount = objCount = oms_registering = 0;
+    obj_running = CmiFalse;
+    commTable = new LBCommTable;
   }
 
   ~LBDB() { }
@@ -85,13 +88,26 @@ public:
   void TurnStatsOn(void) { statsAreOn = CmiTrue; };
   void TurnStatsOff(void) { statsAreOn = CmiFalse; };
   CmiBool StatsOn(void) { return statsAreOn; };
+  void Send(LDOMHandle destOM, LDObjid destid, unsigned int bytes);
   int ObjDataCount();
   void GetObjData(LDObjData *data);
-  LDObjData *FetchData(int *nitems);
+  int CommDataCount() { 
+    if (commTable)
+      return commTable->CommCount();
+    else return 0;
+  }
+  void GetCommData(LDCommData *data) { 
+    if (commTable) commTable->GetCommData(data);
+  };
+
   void Migrate(LDObjHandle h, int dest);
   void Migrated(LDObjHandle h);
   void NotifyMigrated(LDMigratedFn fn, void* data);
   void ClearLoads(void);
+  void RunningObj(LDObjHandle _h) {
+    runningObj = _h; obj_running = CmiTrue;
+  };
+  void NoRunningObj() { obj_running = CmiFalse; };
   
   LDBarrierClient AddLocalBarrierClient(LDResumeFn fn, void* data) { 
     return localBarrier.AddClient(fn,data);
@@ -128,7 +144,7 @@ private:
   typedef std::vector<LBObj*> ObjList;
   typedef std::vector<MigrateCB*> MigrateCBList;
 #endif
-
+  LBCommTable* commTable;
   OMList oms;
   int omCount;
   int oms_registering;
@@ -136,6 +152,8 @@ private:
   int objCount;
   CmiBool statsAreOn;
   MigrateCBList migrateCBList;
+  CmiBool obj_running;
+  LDObjHandle runningObj;
 
   LocalBarrier localBarrier;
 };
index f5941f7854b9538a54e5ac8c13fbc22539ba8e3d..9b48165dc86ff0cfe7e675bfd32913122af5b1ad 100644 (file)
@@ -15,7 +15,6 @@ LBDBInit::LBDBInit(CkArgMsg *m)
 {
 #if CMK_LBDB_ON
   lbdb = CProxy_LBDatabase::ckNew();
-  CkPrintf("[%d] New database created\n",CkMyPe());
 #endif
   delete m;
 }
index 5c324094a98ce915c247722a5537fcd185f65eb5..87b9c890dd6faead770e1fa86d3078173fc6cdc9 100644 (file)
@@ -31,9 +31,9 @@ RandCentLB::RandCentLB()
   CkPrintf("[%d] RandCentLB created\n",CkMyPe());
 }
 
-CmiBool RandCentLB::QueryBalanceNow(int step)
+CmiBool RandCentLB::QueryBalanceNow(int _step)
 {
-  CkPrintf("[%d] Balancing on step %d\n",CkMyPe(),step);
+  CkPrintf("[%d] Balancing on step %d\n",CkMyPe(),_step);
   return CmiTrue;
 }
 
@@ -51,8 +51,7 @@ CLBMigrateMsg* RandCentLB::Strategy(CentralLB::LDStats* stats, int count)
     CkPrintf("[%d] PE %d : %d Objects : %d Communication\n",
             CkMyPe(),pe,stats[pe].n_objs,stats[pe].n_comm);
     for(int obj=0; obj < stats[pe].n_objs; obj++) {
-      const int dest = (int)((static_cast<double>(random()) * count) 
-                            / RAND_MAX);
+      const int dest = static_cast<int>(drand48()*(CmiNumPes()-1) + 0.5);
       if (dest != pe) {
        CkPrintf("[%d] Obj %d migrating from %d to %d\n",
                 CkMyPe(),obj,pe,dest);
index 567b841d7b6b5b5c767839b835ddec99bde8d996..dd1a86ad76b9be89fc7b92139a0a0901eb71b20f 100644 (file)
@@ -83,6 +83,7 @@ extern "C" void LDObjectStart(LDObjHandle _h)
 {
   LBDB *const db = static_cast<LBDB*>(_h.omhandle.ldb.handle);
   if (db->StatsOn()) {
+    db->RunningObj(_h);
     LBObj *const obj = db->LbObj(_h);
     obj->StartTimer();
   }
@@ -96,9 +97,17 @@ extern "C" void LDObjectStop(LDObjHandle _h)
     double walltime, cputime;
     obj->StopTimer(&walltime,&cputime);
     obj->IncrementTime(walltime,cputime);
+    db->NoRunningObj();
   }
 }
 
+extern "C" void LDSend(LDOMHandle destOM, LDObjid destid, unsigned int bytes)
+{
+  LBDB *const db = static_cast<LBDB*>(destOM.ldb.handle);
+  if (db->StatsOn())
+    db->Send(destOM,destid,bytes);
+}
+
 extern "C" void LDClearLoads(LDHandle _db)
 {
   LBDB *const db = static_cast<LBDB*>(_db.handle);
@@ -122,22 +131,16 @@ extern "C" void LDGetObjData(LDHandle _db, LDObjData *data)
 
 extern "C" int LDGetCommDataSz(LDHandle _db)
 {
-  /*
   LBDB *const db = static_cast<LBDB*>(_db.handle);
 
-  return db->objDataCount();
-  */
-
-  return 0;
+  return db->CommDataCount();
 }
 
 extern "C" void LDGetCommData(LDHandle _db, LDCommData *data)
 {
-  /*
   LBDB *const db = static_cast<LBDB*>(_db.handle);
 
-  db->getObjData(data);
-  */
+  db->GetCommData(data);
   return;
 }
 
index 4c18d2f5c4cfae2285f25ea4418f04ebabf97535..341086c5f3e40ec3b1fd1f0fd6b52c3b3fcc1dcb 100644 (file)
@@ -5,6 +5,9 @@
 extern "C" {
 #endif
 
+typedef void* cvoid; /* To eliminate warnings, because a C void* is not
+                       the same as a C++ void* */
+
   /*  User-defined object IDs will be 4 ints long */
 #define OBJ_ID_SZ 4
 
@@ -48,10 +51,16 @@ typedef struct {
 } LDObjData;
 
 typedef struct {
+  CmiBool from_proc;
+  int src_proc;
+  LDOMid senderOM;
   LDObjid sender;
+  CmiBool to_proc;
+  int dest_proc;
+  LDOMid receiverOM;
   LDObjid receiver;
-  int nMessages;
-  int nBytes;
+  int messages;
+  int bytes;
 } LDCommData;
 
 /*
@@ -95,6 +104,7 @@ void LDUnregisterObj(LDObjHandle h);
 void LDObjTime(LDObjHandle h, double walltime, double cputime);
 void LDObjectStart(LDObjHandle _h);
 void LDObjectStop(LDObjHandle _h);
+void LDSend(LDOMHandle destOM, LDObjid destid, unsigned int bytes);
 
 void LDMessage(LDObjHandle from, 
               LDOMid toOM, LDObjid *toID, int bytes);
index c1f94eb38a52f5a8ef3b800ca00fd892118a0e15..107cb79ebea0a087ab51f3a56bc350f9671cfd9e 100644 (file)
@@ -261,14 +261,14 @@ Queue q; void *data; unsigned int strategy, priobits, *prioptr;
     CqsDeqEnqueueLifo(&(q->zeroprio), data); 
     break;
   case CQS_QUEUEING_IFIFO:
-    iprio=prioptr[0]+(1<<(CINTBITS-1));
+    iprio=prioptr[0]+(1U<<(CINTBITS-1));
     if ((int)iprio<0)
       d=CqsPrioqGetDeq(&(q->posprioq), CINTBITS, &iprio);
     else d=CqsPrioqGetDeq(&(q->negprioq), CINTBITS, &iprio);
     CqsDeqEnqueueFifo(d, data);
     break;
   case CQS_QUEUEING_ILIFO:
-    iprio=prioptr[0]+(1<<(CINTBITS-1));
+    iprio=prioptr[0]+(1U<<(CINTBITS-1));
     if ((int)iprio<0)
       d=CqsPrioqGetDeq(&(q->posprioq), CINTBITS, &iprio);
     else d=CqsPrioqGetDeq(&(q->negprioq), CINTBITS, &iprio);
index 365ed92fdd2c1e60092e86d3c26fcc3321f308be..1ae6558bbed7c334fef507230f5428dba7a9703c 100644 (file)
@@ -1,6 +1,10 @@
 #include "converse.h"
 #include "cldb.h"
 
+void LoadNotifyFn(int l)
+{
+}
+
 char *CldGetStrategy(void)
 {
   return "rand";
index 828565ff1bfe33a33c5595d690a63c4572e1b003..424d39925b72b45ac98cfcaf3fee734af60be8ff 100644 (file)
@@ -1,6 +1,10 @@
 #include "converse.h"
 #include <math.h>
 
+void LoadNotifyFn(int l)
+{
+}
+
 char *CldGetStrategy(void)
 {
   return "spray";
index 74cfba7c3d8ee7f9a878836a099b3faa742ffc4c..9699f45abcf1343226de938fc3464cbee4ffbc49 100644 (file)
@@ -3,6 +3,10 @@
 #define PERIOD 100
 #define MAXMSGBFRSIZE 100000
 
+void LoadNotifyFn(int l)
+{
+}
+
 char *CldGetStrategy(void)
 {
   return "test";
index 8796370eb14d225f2c2eea159c8168d116f589b7..a65f0302421bc3a1b1f3a110cdf7c462ee95e4a4 100644 (file)
@@ -59,7 +59,7 @@ SEQCHARMC=../bin/charmc -seq $(CHARMOPTS)
 #
 ###############################################################################
 
-ALLHEADERS=charm++.h ckstream.h charm.h cpthreads.h converse.h conv-trace.h conv-mach.h simplemsg.h sm.h trace.h pvmc.h pvm3.h sdag.h CDep.h CCounter.h CMsgBuffer.h CWhenTrigger.h TList.h idl.h ckarray.h tempo.h waitqd.h LBDatabase.h lbdb.h LBDB.h LBOM.h LBObj.h CentralLB.h RandCentLB.h conv-ccs.h
+ALLHEADERS=charm++.h ckstream.h charm.h cpthreads.h converse.h conv-trace.h conv-mach.h simplemsg.h sm.h trace.h pvmc.h pvm3.h sdag.h CDep.h CCounter.h CMsgBuffer.h CWhenTrigger.h TList.h idl.h ckarray.h tempo.h waitqd.h LBDatabase.h lbdb.h LBDB.h LBComm.h LBOM.h LBObj.h CentralLB.h RandCentLB.h conv-ccs.h
 
 ALLINTERFACES=idl.ci
 
@@ -236,7 +236,7 @@ libldb-test.o: cldb.test.c $(CVHEADERS)
 
 CKHEADERS=ck.h ckstream.h envelope.h init.h qd.h charm.h charm++.h trace.h \
           ckfutures.h ckarray.h tempo.h waitqd.h \
-         LBDatabase.h lbdb.h LBDB.h LBOM.h LBObj.h \
+         LBDatabase.h lbdb.h LBDB.h LBComm.h LBOM.h LBObj.h \
          CentralLB.h RandCentLB.h \
          $(CVHEADERS)
 
@@ -244,7 +244,7 @@ CK_LIBS_CORE=libck.a
 
 LIBCK_CORE=init.o register.o qd.o ck.o main.o msgalloc.o ckfutures.o \
            ckarray.o tempo.o waitqd.o \
-          LBDatabase.o lbdb.o LBDB.o LBObj.o CentralLB.o RandCentLB.o
+          LBDatabase.o lbdb.o LBDB.o LBComm.o LBObj.o CentralLB.o RandCentLB.o
 
 charmlibs: converse $(CK_LIBS_CORE)
        cd libs; make charmlibs OPTS='$(OPTS)'
@@ -329,6 +329,9 @@ lbdb.o: lbdb.C $(CKHEADERS)
 LBDB.o:        LBDB.C $(CKHEADERS)
        $(CHARMC) -o LBDB.o LBDB.C
 
+LBComm.o:      LBComm.C $(CKHEADERS)
+       $(CHARMC) -o LBComm.o LBComm.C
+
 LBObj.o: LBObj.C $(CKHEADERS)
        $(CHARMC) -o LBObj.o LBObj.C