fix for migration
[charm.git] / src / conv-core / isomalloc.c
index 524d2c6dc732d740d124414ed1f591753bd30431..e784d44271d99d39c60676cc0a6aad446853911e 100644 (file)
@@ -120,7 +120,7 @@ static CmiInt8 numslots=0;
 
 /* Start and end of isomalloc-managed addresses.
    If isomallocStart==NULL, isomalloc is disabled.
 
 /* Start and end of isomalloc-managed addresses.
    If isomallocStart==NULL, isomalloc is disabled.
- */
  */
 static char *isomallocStart=NULL;
 static char *isomallocEnd=NULL;
 
 static char *isomallocStart=NULL;
 static char *isomallocEnd=NULL;
 
@@ -1704,7 +1704,7 @@ static void *__static_data_loc(void)
 
 /*Pointer comparison is in these subroutines, because
   comparing arbitrary pointers is nonportable and tricky.
 
 /*Pointer comparison is in these subroutines, because
   comparing arbitrary pointers is nonportable and tricky.
- */
 */
 static int pointer_lt(const char *a,const char *b) {
   return ((memRange_t)a)<((memRange_t)b);
 }
 static int pointer_lt(const char *a,const char *b) {
   return ((memRange_t)a)<((memRange_t)b);
 }
@@ -1720,7 +1720,7 @@ const static memRange_t gig=1024u*1024u*1024u; /*One gigabyte*/
 
 /*Check if this memory location is usable.  
   If not, return 1.
 
 /*Check if this memory location is usable.  
   If not, return 1.
- */
 */
 static int bad_location(char *loc) {
   void *addr;
   addr=call_mmap_fixed(loc,slotsize);
 static int bad_location(char *loc) {
   void *addr;
   addr=call_mmap_fixed(loc,slotsize);
@@ -1750,7 +1750,7 @@ static int partially_good(char *start,memRange_t len,int n) {
 }
 
 /* Return if this memory region is usable at n samples.  
 }
 
 /* Return if this memory region is usable at n samples.  
- */
+*/
 static int good_range(char *start,memRange_t len,int n) {
   int i;
   memRange_t quant=divide_range(len,n);
 static int good_range(char *start,memRange_t len,int n) {
   int i;
   memRange_t quant=divide_range(len,n);
@@ -1767,7 +1767,7 @@ static int good_range(char *start,memRange_t len,int n) {
 
 /*Check if this entire memory range, or some subset 
   of the range, is usable.  If so, write it into max.
 
 /*Check if this entire memory range, or some subset 
   of the range, is usable.  If so, write it into max.
- */
 */
 static void check_range(char *start,char *end,memRegion_t *max)
 {
   memRange_t len;
 static void check_range(char *start,char *end,memRegion_t *max)
 {
   memRange_t len;
@@ -1829,7 +1829,7 @@ static void check_range(char *start,char *end,memRegion_t *max)
 
 /*Find the first available memory region of at least the
   given size not touching any data in the used list.
 
 /*Find the first available memory region of at least the
   given size not touching any data in the used list.
- */
 */
 static memRegion_t find_free_region(memRegion_t *used,int nUsed,int atLeast) 
 {
   memRegion_t max;
 static memRegion_t find_free_region(memRegion_t *used,int nUsed,int atLeast) 
 {
   memRegion_t max;
@@ -1860,7 +1860,7 @@ static memRegion_t find_free_region(memRegion_t *used,int nUsed,int atLeast)
 /*
    By looking at the address range carefully, try to find 
    the largest usable free region on the machine.
 /*
    By looking at the address range carefully, try to find 
    the largest usable free region on the machine.
- */
  */
 static int find_largest_free_region(memRegion_t *destRegion) {
   char *staticData =(char *) __static_data_loc();
   char *code = (char *)&find_free_region;
 static int find_largest_free_region(memRegion_t *destRegion) {
   char *staticData =(char *) __static_data_loc();
   char *code = (char *)&find_free_region;
@@ -2076,7 +2076,7 @@ static void init_ranges(char **argv)
      on some machines, isomalloc memory regions on different nodes 
      can be different. use +isomalloc_sync to calculate the
      intersect of all memory regions on all nodes.
      on some machines, isomalloc memory regions on different nodes 
      can be different. use +isomalloc_sync to calculate the
      intersect of all memory regions on all nodes.
-   */
+     */
   if (_sync_iso == 1)
   {
 #ifdef __FAULT__
   if (_sync_iso == 1)
   {
 #ifdef __FAULT__
@@ -2114,12 +2114,12 @@ static void init_ranges(char **argv)
       {
         CmiUInt8 s = (CmiUInt8)freeRegion.start;
         CmiUInt8 e = (CmiUInt8)(freeRegion.start+freeRegion.len);
       {
         CmiUInt8 s = (CmiUInt8)freeRegion.start;
         CmiUInt8 e = (CmiUInt8)(freeRegion.start+freeRegion.len);
-        int fd, i;
+        int fd, i,j;
         char fname[128];
 
         if (CmiMyNode()==0) printf("Charm++> synchronizing isomalloc memory region...\n");
 
         char fname[128];
 
         if (CmiMyNode()==0) printf("Charm++> synchronizing isomalloc memory region...\n");
 
-        sprintf(fname,".isomalloc.%d", CmiMyNode());
+        sprintf(fname,".isomalloc.%d.%d", CmiMyPartition(),CmiMyNode());
 
         /* remove file before writing for safe */
         unlink(fname);
 
         /* remove file before writing for safe */
         unlink(fname);
@@ -2144,34 +2144,35 @@ static void init_ranges(char **argv)
 #endif
 
         CmiBarrier();
 #endif
 
         CmiBarrier();
-
-        for (i=0; i<CmiNumNodes(); i++) {
-          CmiUInt8 ss, ee; 
-          int try_count;
-          char fname[128];
-          if (i==CmiMyNode()) continue;
-          sprintf(fname,".isomalloc.%d", i);
-          try_count = 0;
-          while ((fd = open(fname, O_RDONLY)) == -1 && try_count<10000)
-          {
-            try_count++;
+        for(j=0;j<CmiNumPartition();j++){
+          for (i=0; i<CmiNumNodes(); i++) {
+            CmiUInt8 ss, ee; 
+            int try_count;
+            char fname[128];
+            //if (i==CmiMyNode()) continue;
+            sprintf(fname,".isomalloc.%d.%d",j, i);
+            try_count = 0;
+            while ((fd = open(fname, O_RDONLY)) == -1 && try_count<10000)
+            {
+              try_count++;
 #ifndef __MINGW_H
 #ifndef __MINGW_H
-            CMK_CPV_IS_SMP
+              CMK_CPV_IS_SMP
 #endif
 #endif
-              ;
-          }
-          if (fd == -1) {
-            CmiAbort("isomalloc_sync failed, make sure you have a shared file system.");
-          }
-          read(fd, &ss, sizeof(CmiUInt8));
-          read(fd, &ee, sizeof(CmiUInt8));
+                ;
+            }
+            if (fd == -1) {
+              CmiAbort("isomalloc_sync failed, make sure you have a shared file system.");
+            }
+            read(fd, &ss, sizeof(CmiUInt8));
+            read(fd, &ee, sizeof(CmiUInt8));
 #if ISOMALLOC_DEBUG
 #if ISOMALLOC_DEBUG
-          if (CmiMyPe() == 0) CmiPrintf("[%d] load node %d isomalloc region: %lx %lx. \n",
-              CmiMyPe(), i, ss, ee);
+            if (CmiMyPe() == 0) CmiPrintf("[%d] load node %d isomalloc region: %lx %lx. \n",
+                CmiMyPe(), i, ss, ee);
 #endif
 #endif
-          close(fd);
-          if (ss>s) s = ss;
-          if (ee<e) e = ee;
+            close(fd);
+            if (ss>s) s = ss;
+            if (ee<e) e = ee;
+          }
         }
 
         CmiBarrier();
         }
 
         CmiBarrier();
@@ -2194,7 +2195,7 @@ static void init_ranges(char **argv)
               freeRegion.start,freeRegion.start+freeRegion.len,
               freeRegion.len/meg);
 #if __FAULT__
               freeRegion.start,freeRegion.start+freeRegion.len,
               freeRegion.len/meg);
 #if __FAULT__
-        if(CmiMyPe() == 0){
+        if(CmiMyPe() == 0 && CmiMyPartition() == 0){
           int fd;
           char fname[128];
           CmiUInt8 s = (CmiUInt8)freeRegion.start;
           int fd;
           char fname[128];
           CmiUInt8 s = (CmiUInt8)freeRegion.start;
@@ -2326,7 +2327,7 @@ static void one_slotOP(const slotOP *op,int pe,CmiInt8 s,CmiInt8 n)
 /*Apply the given operation to all slots in the range [s, s+n) 
   After a restart from checkpoint, a slotset can cross an 
   arbitrary set of processors.
 /*Apply the given operation to all slots in the range [s, s+n) 
   After a restart from checkpoint, a slotset can cross an 
   arbitrary set of processors.
- */
 */
 static void all_slotOP(const slotOP *op,CmiInt8 s,CmiInt8 n)
 {
   int spe=slot2pe(s), epe=slot2pe(s+n-1);
 static void all_slotOP(const slotOP *op,CmiInt8 s,CmiInt8 n)
 {
   int spe=slot2pe(s), epe=slot2pe(s+n-1);
@@ -2561,7 +2562,7 @@ void CmiIsomallocInit(char **argv)
   This was moved here from memory-isomalloc.c when it 
   was realized that a list-of-isomalloc'd-blocks is useful for
   more than just isomalloc heaps.
   This was moved here from memory-isomalloc.c when it 
   was realized that a list-of-isomalloc'd-blocks is useful for
   more than just isomalloc heaps.
- */
 */
 
 /*Convert a slot to a user address*/
 static char *Slot_toUser(CmiIsomallocBlockList *s) {return (char *)(s+1);}
 
 /*Convert a slot to a user address*/
 static char *Slot_toUser(CmiIsomallocBlockList *s) {return (char *)(s+1);}
@@ -2583,7 +2584,7 @@ static void print_myslots();
 /*Pup all the blocks in this list.  This amounts to two circular
   list traversals.  Because everything's isomalloc'd, we don't even
   have to restore the pointers-- they'll be restored automatically!
 /*Pup all the blocks in this list.  This amounts to two circular
   list traversals.  Because everything's isomalloc'd, we don't even
   have to restore the pointers-- they'll be restored automatically!
- */
 */
 #if CMK_USE_MEMPOOL_ISOMALLOC
 void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp, CthThread tid)
 {
 #if CMK_USE_MEMPOOL_ISOMALLOC
 void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp, CthThread tid)
 {
@@ -2601,7 +2602,7 @@ void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp, CthThread tid
   printf("[%d] My rank is %lld Pupping for %lld with isUnpack %d isDelete %d \n",CmiMyPe(),CthSelf(),tid,pup_isUnpacking(p),pup_isDeleting(p));
 #endif
   flags[0] = 0; flags[1] = 1;
   printf("[%d] My rank is %lld Pupping for %lld with isUnpack %d isDelete %d \n",CmiMyPe(),CthSelf(),tid,pup_isUnpacking(p),pup_isDeleting(p));
 #endif
   flags[0] = 0; flags[1] = 1;
-//  if(!pup_isUnpacking(p)&& !pup_isChecking(p)) {
+  //  if(!pup_isUnpacking(p)&& !pup_isChecking(p)) {
   int first = 1;
   i = 0; j = 0;
   //if(!pup_isUnpacking(p)) {
   int first = 1;
   i = 0; j = 0;
   //if(!pup_isUnpacking(p)) {
@@ -2654,10 +2655,10 @@ void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp, CthThread tid
             }else{
               first = 0;
             }
             }else{
               first = 0;
             }
-      //      printf("[%d][%d]checking block %d slot %d check isomalloc header %d\n",CmiMyPartition(),CmiMyPe(),i,j,MEMPOOL_GetSlotSize(currSlot));
+            //      printf("[%d][%d]checking block %d slot %d check isomalloc header %d\n",CmiMyPartition(),CmiMyPe(),i,j,MEMPOOL_GetSlotSize(currSlot));
           }
           }
- //         else
-   //         printf("[%d][%d]block %d slot %d check isomalloc header %d\n",CmiMyPartition(),CmiMyPe(),i,j,MEMPOOL_GetSlotSize(currSlot));
         //         else
+          //         printf("[%d][%d]block %d slot %d check isomalloc header %d\n",CmiMyPartition(),CmiMyPe(),i,j,MEMPOOL_GetSlotSize(currSlot));
           //pup_bytes(p,(void*)currSlot+sizeof(slot_header),MEMPOOL_GetSlotSize(currSlot)-sizeof(slot_header));
           pup_bytes(p,(void*)currSlot,MEMPOOL_GetSlotSize(currSlot));
           if(pup_isChecking(p)){
           //pup_bytes(p,(void*)currSlot+sizeof(slot_header),MEMPOOL_GetSlotSize(currSlot)-sizeof(slot_header));
           pup_bytes(p,(void*)currSlot,MEMPOOL_GetSlotSize(currSlot));
           if(pup_isChecking(p)){
@@ -2673,7 +2674,7 @@ void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp, CthThread tid
   }
 
   if(pup_isUnpacking(p)||(pup_isChecking(p)&&!pup_isCalChecking(p))) {
   }
 
   if(pup_isUnpacking(p)||(pup_isChecking(p)&&!pup_isCalChecking(p))) {
-  //if(pup_isUnpacking(p)) {
+    //if(pup_isUnpacking(p)) {
     pup_int(p,&numBlocks);
 #if ISOMALLOC_DEBUG
     printf("Number of blocks to be unpacked %d\n",numBlocks);
     pup_int(p,&numBlocks);
 #if ISOMALLOC_DEBUG
     printf("Number of blocks to be unpacked %d\n",numBlocks);
@@ -2707,7 +2708,7 @@ void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp, CthThread tid
             }else{
               first = 0;
             }
             }else{
               first = 0;
             }
-     //       printf("[%d][%d]unpack block %d slot %d check isomalloc header %d\n",CmiMyPartition(),CmiMyPe(),i,j,flags[0]);
+            //       printf("[%d][%d]unpack block %d slot %d check isomalloc header %d\n",CmiMyPartition(),CmiMyPe(),i,j,flags[0]);
           }
           pup_bytes(p,newblock,flags[0]);
           if(pup_isChecking(p)){
           }
           pup_bytes(p,newblock,flags[0]);
           if(pup_isChecking(p)){
@@ -2726,108 +2727,108 @@ void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp, CthThread tid
     mempool_destroy(CtvAccessOther(tid,threadpool));
     *lp=NULL;
   }
     mempool_destroy(CtvAccessOther(tid,threadpool));
     *lp=NULL;
   }
-}
+  }
 #else
 #else
-void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp, CthThread tid)
-{
-  /* BIGSIM_OOC DEBUGGING */
-  /* if(!pup_isUnpacking(p)) print_myslots(); */
+  void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp, CthThread tid)
+  {
+    /* BIGSIM_OOC DEBUGGING */
+    /* if(!pup_isUnpacking(p)) print_myslots(); */
 
 
-  int i,nBlocks=0;
-  CmiIsomallocBlockList *cur=NULL, *start=*lp;
+    int i,nBlocks=0;
+    CmiIsomallocBlockList *cur=NULL, *start=*lp;
 #if 0 /*#ifndef CMK_OPTIMIZE*/
 #if 0 /*#ifndef CMK_OPTIMIZE*/
-  if (CpvAccess(isomalloc_blocklist)!=NULL)
-    CmiAbort("Called CmiIsomallocBlockListPup while a blockList is active!\n"
-        "You should swap out the active blocklist before pupping.\n");
-#endif
-  /*Count the number of blocks in the list*/
-  if (!pup_isUnpacking(p)) {
-    nBlocks=1; /*<- Since we have to skip the start block*/
-    for (cur=start->next; cur!=start; cur=cur->next) 
-      nBlocks++;
-    /*Prepare for next trip around list:*/
-    cur=start;
-  }
-  pup_int(p,&nBlocks);
-
-  /*Pup each block in the list*/
-  for (i=0;i<nBlocks;i++) {
-    void *newBlock=cur;
-    if (!pup_isUnpacking(p)) 
-    { /*While packing, we traverse the list to find our blocks*/
-      cur=cur->next;
+    if (CpvAccess(isomalloc_blocklist)!=NULL)
+      CmiAbort("Called CmiIsomallocBlockListPup while a blockList is active!\n"
+          "You should swap out the active blocklist before pupping.\n");
+#endif
+    /*Count the number of blocks in the list*/
+    if (!pup_isUnpacking(p)) {
+      nBlocks=1; /*<- Since we have to skip the start block*/
+      for (cur=start->next; cur!=start; cur=cur->next) 
+        nBlocks++;
+      /*Prepare for next trip around list:*/
+      cur=start;
     }
     }
-    CmiIsomallocPup(p,&newBlock);
-    if (i==0 && pup_isUnpacking(p))
-      *lp=(CmiIsomallocBlockList *)newBlock;
-  }
-  if (pup_isDeleting(p))
-    *lp=NULL;
+    pup_int(p,&nBlocks);
+
+    /*Pup each block in the list*/
+    for (i=0;i<nBlocks;i++) {
+      void *newBlock=cur;
+      if (!pup_isUnpacking(p)) 
+      { /*While packing, we traverse the list to find our blocks*/
+        cur=cur->next;
+      }
+      CmiIsomallocPup(p,&newBlock);
+      if (i==0 && pup_isUnpacking(p))
+        *lp=(CmiIsomallocBlockList *)newBlock;
+    }
+    if (pup_isDeleting(p))
+      *lp=NULL;
 
 
-  /* BIGSIM_OOC DEBUGGING */
-  /* if(pup_isUnpacking(p)) print_myslots(); */
-}
+    /* BIGSIM_OOC DEBUGGING */
+    /* if(pup_isUnpacking(p)) print_myslots(); */
+  }
 #endif
 
 #endif
 
-/*Delete all the blocks in this list.*/
-void CmiIsomallocBlockListDelete(CmiIsomallocBlockList *l)
-{
-  CmiIsomallocBlockList *start=l;
-  CmiIsomallocBlockList *cur=start;
-  if (cur==NULL) return; /*Already deleted*/
-  do {
-    CmiIsomallocBlockList *doomed=cur;
-    cur=cur->next; /*Have to stash next before deleting cur*/
-    CmiIsomallocFree(doomed);
-  } while (cur!=start);
-}
-
-/*Allocate a block from this blockList*/
-void *CmiIsomallocBlockListMalloc(CmiIsomallocBlockList *l,size_t nBytes)
-{
-  CmiIsomallocBlockList *n; /*Newly created slot*/
-  n=(CmiIsomallocBlockList *)CmiIsomalloc(sizeof(CmiIsomallocBlockList)+nBytes,NULL);
-  /*Link the new block into the circular blocklist*/
-  n->prev=l;
-  n->next=l->next;
-  l->next->prev=n;
-  l->next=n;
-  return Slot_toUser(n);
-}
-
-/*Allocate a block from this blockList with alighment */
-void *CmiIsomallocBlockListMallocAlign(CmiIsomallocBlockList *l,size_t align,size_t nBytes)
-{
-  CmiIsomallocBlockList *n; /*Newly created slot*/
-  n=(CmiIsomallocBlockList *)_isomallocAlign(align,nBytes,sizeof(CmiIsomallocBlockList),NULL);
-  /*Link the new block into the circular blocklist*/
-  n->prev=l;
-  n->next=l->next;
-  l->next->prev=n;
-  l->next=n;
-  return Slot_toUser(n);
-}
-
-/*Remove this block from its list and memory*/
-void CmiIsomallocBlockListFree(void *block)
-{
-  CmiIsomallocBlockList *n=Slot_fmUser(block);
+  /*Delete all the blocks in this list.*/
+  void CmiIsomallocBlockListDelete(CmiIsomallocBlockList *l)
+  {
+    CmiIsomallocBlockList *start=l;
+    CmiIsomallocBlockList *cur=start;
+    if (cur==NULL) return; /*Already deleted*/
+    do {
+      CmiIsomallocBlockList *doomed=cur;
+      cur=cur->next; /*Have to stash next before deleting cur*/
+      CmiIsomallocFree(doomed);
+    } while (cur!=start);
+  }
+
+  /*Allocate a block from this blockList*/
+  void *CmiIsomallocBlockListMalloc(CmiIsomallocBlockList *l,size_t nBytes)
+  {
+    CmiIsomallocBlockList *n; /*Newly created slot*/
+    n=(CmiIsomallocBlockList *)CmiIsomalloc(sizeof(CmiIsomallocBlockList)+nBytes,NULL);
+    /*Link the new block into the circular blocklist*/
+    n->prev=l;
+    n->next=l->next;
+    l->next->prev=n;
+    l->next=n;
+    return Slot_toUser(n);
+  }
+
+  /*Allocate a block from this blockList with alighment */
+  void *CmiIsomallocBlockListMallocAlign(CmiIsomallocBlockList *l,size_t align,size_t nBytes)
+  {
+    CmiIsomallocBlockList *n; /*Newly created slot*/
+    n=(CmiIsomallocBlockList *)_isomallocAlign(align,nBytes,sizeof(CmiIsomallocBlockList),NULL);
+    /*Link the new block into the circular blocklist*/
+    n->prev=l;
+    n->next=l->next;
+    l->next->prev=n;
+    l->next=n;
+    return Slot_toUser(n);
+  }
+
+  /*Remove this block from its list and memory*/
+  void CmiIsomallocBlockListFree(void *block)
+  {
+    CmiIsomallocBlockList *n=Slot_fmUser(block);
 #if DOHEAPCHECK
 #if DOHEAPCHECK
-  if (n->prev->next!=n || n->next->prev!=n) 
-    CmiAbort("Heap corruption detected in isomalloc block list header!\n"
-        "  Run with ++debug and look for writes to negative array indices");
+    if (n->prev->next!=n || n->next->prev!=n) 
+      CmiAbort("Heap corruption detected in isomalloc block list header!\n"
+          "  Run with ++debug and look for writes to negative array indices");
 #endif
 #endif
-  /*Link ourselves out of the blocklist*/
-  n->prev->next=n->next;
-  n->next->prev=n->prev;
-  CmiIsomallocFree(n);
-}
+    /*Link ourselves out of the blocklist*/
+    n->prev->next=n->next;
+    n->next->prev=n->prev;
+    CmiIsomallocFree(n);
+  }
 
 
-/* BIGSIM_OOC DEBUGGING */
-static void print_myslots(){
-  CmiPrintf("[%d] my slot set=%p\n", CmiMyPe(), CpvAccess(myss));
-  print_slots(CpvAccess(myss));
-}
+  /* BIGSIM_OOC DEBUGGING */
+  static void print_myslots(){
+    CmiPrintf("[%d] my slot set=%p\n", CmiMyPe(), CpvAccess(myss));
+    print_slots(CpvAccess(myss));
+  }