Changed interface to isomalloc routines-- instead of making the user
authorOrion Lawlor <olawlor@acm.org>
Wed, 17 Jul 2002 23:19:11 +0000 (23:19 +0000)
committerOrion Lawlor <olawlor@acm.org>
Wed, 17 Jul 2002 23:19:11 +0000 (23:19 +0000)
drag around the "CmiIsomallocBlock" structure containing the mapped slot
and length, keep the CmiIsomallocBlock just before the start of the
mapped buffer.  This makes isomalloc have exactly the same programming
interface as malloc, which is easier to remember and more natural.

Also hoisted CmiIsomallocBlockList structure from inside memory-isomalloc.c
to isomalloc.c, since Chee Wai may be able to reuse this to keep track
of separately-allocated isomalloc blocks.

src/conv-core/converse.h
src/conv-core/isomalloc.c
src/conv-core/memory-isomalloc.c
src/conv-core/memory-isomalloc.h
src/conv-core/memory.c
src/conv-core/threads.c

index c363b148b4a91541b1b64042e87cd93a6dc534b5..c57357f65c8c97632d5fddbdfb2afd5adc2a3419 100644 (file)
@@ -676,18 +676,31 @@ void   CmiHandleMessage(void *msg);
 #define CQS_QUEUEING_BFIFO 6
 #define CQS_QUEUEING_BLIFO 7
 
-/****** Isomalloc Memory Allocation ********/
-struct CmiIsomallocBlock {
-       int slot; /*First mapped slot*/
-       int nslots; /*Number of mapped slots*/
-};
-typedef struct CmiIsomallocBlock CmiIsomallocBlock;
+/****** Isomalloc: Migratable Memory Allocation ********/
+/*Simple block-by-block interface:*/
+void *CmiIsomalloc(int sizeInBytes);
+void  CmiIsomallocPup(pup_er p,void **block);
+void  CmiIsomallocFree(void *block);
 
-void *CmiIsomalloc(int size,CmiIsomallocBlock *b);
-void *CmiIsomallocPup(pup_er p,CmiIsomallocBlock *b);
-void  CmiIsomallocFree(CmiIsomallocBlock *b);
+int   CmiIsomallocLength(void *block);
 int   CmiIsomallocInRange(void *addr);
 
+/*List-of-blocks interface:*/
+struct CmiIsomallocBlockList {/*Circular doubly-linked list of blocks:*/
+       struct CmiIsomallocBlockList *prev,*next;
+       /*actual data of block follows here...*/
+};
+typedef struct CmiIsomallocBlockList CmiIsomallocBlockList;
+
+/*Build/pup/destroy an entire blockList.*/
+CmiIsomallocBlockList *CmiIsomallocBlockListNew(void);
+void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **l);
+void CmiIsomallocBlockListDelete(CmiIsomallocBlockList *l);
+
+/*Allocate/free a block from this blockList*/
+void *CmiIsomallocBlockListMalloc(CmiIsomallocBlockList *l,int nBytes);
+void CmiIsomallocBlockListFree(void *doomedMallocedBlock);
+
 /****** CTH: THE LOW-LEVEL THREADS PACKAGE ******/
 
 typedef struct CthThreadStruct *CthThread;
index fa6160ad531323d626b8a93518bf6836da9118df..58fe015f58527b66ff9641faf566b7a03eff5ebe 100644 (file)
@@ -23,6 +23,20 @@ generalized by Orion Lawlor November 2001.
 #include <stdio.h>
 #include <stdlib.h>
 
+struct CmiIsomallocBlock {
+      int slot; /*First mapped slot*/
+      int length; /*Length of (user portion of) mapping, in bytes*/
+};
+typedef struct CmiIsomallocBlock CmiIsomallocBlock;
+
+/*Convert a heap block pointer to/from a CmiIsomallocBlock header*/
+static void *block2pointer(CmiIsomallocBlock *blockHeader) {
+       return (void *)(blockHeader+1);
+}
+static CmiIsomallocBlock *pointer2block(void *heapBlock) {
+       return ((CmiIsomallocBlock *)heapBlock)-1;
+}
+
 /*Integral type to be used for pointer arithmetic:*/
 typedef unsigned long memRange_t;
 
@@ -39,9 +53,6 @@ static char *isomallocStart=NULL;
 static char *isomallocEnd=NULL;
 
 /*Utility conversion functions*/
-static int addr2slot(void *addr) {
-       return (((char *)addr)-isomallocStart)/(memRange_t)slotsize;
-}
 static void *slot2addr(int slot) {
        return isomallocStart+((memRange_t)slotsize)*((memRange_t)slot);
 }
@@ -51,11 +62,9 @@ static int slot2pe(int slot) {
 static int pe2slot(int pe) {
        return pe*numslots;
 }
+//Return the number of slots in a block with n user data bytes
 static int length2slots(int nBytes) {
-       return (nBytes+slotsize-1)/slotsize;
-}
-static int slots2length(int nSlots) {
-       return nSlots*slotsize;
+       return (sizeof(CmiIsomallocBlock)+nBytes+slotsize-1)/slotsize;
 }
 
 typedef struct _slotblock
@@ -235,27 +244,25 @@ print_slots(slotset *ss)
 /*This version of the allocate/deallocate calls are used if the 
 real mmap versions are disabled.*/
 static int disabled_map_warned=0;
-static void *disabled_map(CmiIsomallocBlock *bk,int nBytes) {
-       void *ret;
+static void *disabled_map(int nBytes) 
+{
        if (!disabled_map_warned) {
                disabled_map_warned=1;
                if (CmiMyPe()==0)
                        CmiError("isomalloc.c> Warning: since mmap() doesn't work,"
                        " you won't be able to migrate threads\n");
        }
-       ret=malloc(nBytes);
-       *(void **)bk=ret; /*HACK: Stash the malloc'd pointer in the "block" object*/
-       return ret;
+       return malloc(nBytes);
 }
-static void *disabled_unmap(CmiIsomallocBlock *bk) {
-       free(*(void **)bk);
-       *(void **)bk=NULL;
+static void disabled_unmap(void *bk) {
+       free(bk);
 }
 
 /*Turn off isomalloc memory, for the given reason*/
 static void disable_isomalloc(const char *why)
 {
     isomallocStart=NULL;
+    isomallocEnd=NULL;
 #if CMK_THREADS_DEBUG
     CmiPrintf("[%d] isomalloc.c> Disabling isomalloc because %s\n",CmiMyPe(),why);
 #endif
@@ -263,7 +270,7 @@ static void disable_isomalloc(const char *why)
 
 #if ! CMK_HAS_MMAP
 /****************** Manipulate memory map (Win32 non-version) *****************/
-static void *
+static CmiIsomallocBlock *
 map_slots(int slot, int nslots)
 {
        CmiAbort("isomalloc.c: map_slots should never be called here.");
@@ -292,7 +299,7 @@ CpvStaticDeclare(int, zerofd); /*File descriptor for /dev/zero, for mmap*/
 /*
  * maps the virtual memory associated with slot using mmap
  */
-static void *
+static CmiIsomallocBlock *
 map_slots(int slot, int nslots)
 {
   void *pa;
@@ -325,7 +332,7 @@ map_slots(int slot, int nslots)
   CmiPrintf("[%d] mmap'd slots %d-%d to address %p\n",CmiMyPe(),
            slot,slot+nslots-1,addr);
 #endif
-  return pa;
+  return (CmiIsomallocBlock *)pa;
 }
 
 /*
@@ -505,7 +512,7 @@ static memRegion_t find_free_region(memRegion_t *used,int nUsed,int atLeast)
 static void init_ranges(char **argv)
 {
   /*Largest value a signed int can hold*/
-  memRange_t intMax=((memRange_t)1)<<(sizeof(int)*8-1)-1;
+  memRange_t intMax=(((memRange_t)1)<<(sizeof(int)*8-1))-1;
 
   /*Round slot size up to nearest page size*/
   slotsize=16*1024;
@@ -697,11 +704,11 @@ static void all_slotOP(const slotOP *op,int s,int n)
 }
 
 /************** External interface ***************/
-void *CmiIsomalloc(int size,CmiIsomallocBlock *b)
+void *CmiIsomalloc(int size)
 {
        int s,n;
-       void *ret;
-       if (isomallocStart==NULL) return disabled_map(b,size);
+       CmiIsomallocBlock *blk;
+       if (isomallocStart==NULL) return disabled_map(size);
        n=length2slots(size);
        /*Always satisfy mallocs with local slots:*/
        s=get_slots(CpvAccess(myss),n);
@@ -711,58 +718,75 @@ void *CmiIsomalloc(int size,CmiIsomallocBlock *b)
                CmiAbort("Out of virtual address space for isomalloc");
        }
        grab_slots(CpvAccess(myss),s,n);
-       b->slot=s;
-       b->nslots=n;
-       ret=map_slots(s,n);
-       if (!ret) map_failed(s,n);
-       return ret;
+       blk=map_slots(s,n);
+       if (!blk) map_failed(s,n);
+       blk->slot=s;
+       blk->length=size;
+       return block2pointer(blk);
 }
 
-void *CmiIsomallocPup(pup_er p,CmiIsomallocBlock *b)
+void CmiIsomallocPup(pup_er p,void **blockPtrPtr)
 {
-       int s,n;
+       CmiIsomallocBlock *blk;
+       int s,n,length;
        if (isomallocStart==NULL) CmiAbort("isomalloc is disabled-- cannot use IsomallocPup");
-       pup_int(p,&b->slot);
-       pup_int(p,&b->nslots);
-       s=b->slot, n=b->nslots;
+
+       if (!pup_isUnpacking(p)) 
+       { /*We have an existing block-- unpack start slot & length*/
+               blk=pointer2block(*blockPtrPtr);
+               s=blk->slot;
+               length=blk->length;
+       }
+       
+       pup_int(p,&s);
+       pup_int(p,&length);
+       n=length2slots(length);
+       
        if (pup_isUnpacking(p)) 
-       { /*Allocate block in its old location*/
+       { /*Must allocate a new block in its old location*/
                if (pup_isUserlevel(p))
                        /*Checkpoint: must grab old slots (even remote!)*/
                        all_slotOP(&grabOP,s,n);
-               if (!map_slots(s,n)) map_failed(s,n);
+               blk=map_slots(s,n);
+               if (!blk) map_failed(s,n);
+               blk->slot=s;
+               blk->length=length;
+               *blockPtrPtr=block2pointer(blk);
        }
        
        /*Pup the allocated data*/
-       pup_bytes(p,slot2addr(s),slots2length(n));
-
+       pup_bytes(p,*blockPtrPtr,length);
+       
        if (pup_isDeleting(p)) 
        { /*Unmap old slots, but do not mark as free*/
                unmap_slots(s,n);
-               b->nslots=0;/*Mark as unmapped*/
+               *blockPtrPtr=NULL; /*Zero out user's pointer*/
        }
-       return slot2addr(s);
 }
 
-void CmiIsomallocFree(CmiIsomallocBlock *b)
+void CmiIsomallocFree(void *blockPtr)
 {
        if (isomallocStart==NULL) {
-               disabled_unmap(b);
+               disabled_unmap(blockPtr);
        }
-       else
+       else if (blockPtr!=NULL)
        {
-               int s=b->slot, n=b->nslots;
-               if (n==0) return;
+               CmiIsomallocBlock *blk=pointer2block(blockPtr);
+               int s=blk->slot, n=length2slots(blk->length);
                unmap_slots(s,n);
                /*Mark used slots as free*/
                all_slotOP(&freeOP,s,n);
        }
 }
+int   CmiIsomallocLength(void *block)
+{
+       return pointer2block(block)->length;
+}
 
 /*Return true if this address is in the region managed by isomalloc*/
 int CmiIsomallocInRange(void *addr)
 {
-       if (isomallocStart==NULL) return 1;
+       if (isomallocStart==NULL) return 0; /* There is no range we manage! */
        return pointer_ge((char *)addr,isomallocStart) && 
               pointer_lt((char*)addr,isomallocEnd);
 }
@@ -778,3 +802,109 @@ void CmiIsomallocInit(char **argv)
   }
 }
 
+/***************** BlockList interface *********
+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.
+*/
+
+typedef CmiIsomallocBlockList Slot;
+
+/*Convert a slot to a user address*/
+static char *Slot_toUser(Slot *s) {return (char *)(s+1);}
+static Slot *Slot_fmUser(void *s) {return ((Slot *)s)-1;}
+
+
+/*Build a new blockList.*/
+CmiIsomallocBlockList *CmiIsomallocBlockListNew(void)
+{
+       CmiIsomallocBlockList *ret;
+       ret=(CmiIsomallocBlockList *)CmiIsomalloc(sizeof(*ret));
+       ret->next=ret; /*1-entry circular linked list*/
+       ret->prev=ret;
+       return ret;
+}
+
+/*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!
+*/
+void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp)
+{
+       int i,nBlocks=0;
+       Slot *cur=NULL, *start=*lp;
+#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;
+               }
+               CmiIsomallocPup(p,&newBlock);
+               if (i==0 && pup_isUnpacking(p))
+                       *lp=(Slot *)newBlock;
+       }
+       if (pup_isDeleting(p))
+               *lp=NULL;
+}
+
+/*Delete all the blocks in this list.*/
+void CmiIsomallocBlockListDelete(CmiIsomallocBlockList *l)
+{
+       Slot *start=l;
+       Slot *cur=start;
+       if (cur==NULL) return; /*Already deleted*/
+       do {
+               Slot *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,int nBytes)
+{
+       Slot *n; /*Newly created slot*/
+       n=(Slot *)CmiIsomalloc(sizeof(Slot)+nBytes);
+       /*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)
+{
+       Slot *n=Slot_fmUser(block);
+#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");
+#endif
+       /*Link ourselves out of the blocklist*/
+       n->prev->next=n->next;
+       n->next->prev=n->prev;
+       CmiIsomallocFree(n);
+}
+
+
+
+
+
index 6a51ee683d8110efafefca46ac4adf1baa26d906..fe16489a3eb04194b139ef2a2c72f7f412bb5833 100644 (file)
@@ -14,37 +14,21 @@ be wrapped in CmiMemLock.  (Doesn't hurt, tho')
 
 static int memInit=0;
 
-struct CmiIsomallocBlockList_tag {
-       /*Prev and next form a circular doubly-linked list of blocks*/
-       struct CmiIsomallocBlockList_tag *prev,*next;
-       CmiIsomallocBlock block; /*So we can isofree this block*/
-       unsigned int userSize; /*Bytes of user data in this block*/
-# define MAGIC1 0xcabba7e0
-       int magic; /*Magic number (to detect corruption & pad block)*/
-       /*actual data of block follows here...*/
-};
-
-typedef struct CmiIsomallocBlockList_tag Slot;
-
-/*Convert a slot to a user address*/
-static char *Slot_toUser(Slot *s) {return (char *)(s+1);}
-static Slot *Slot_fmUser(void *s) {return ((Slot *)s)-1;}
-
 /*The current allocation arena */
-CpvStaticDeclare(Slot *,isomalloc_blocklist);
+CpvStaticDeclare(CmiIsomallocBlockList *,isomalloc_blocklist);
 
 #define ISOMALLOC_PUSH \
-       Slot *isomalloc_blocklist=CpvAccess(isomalloc_blocklist);\
+       CmiIsomallocBlockList *pushed_blocklist=CpvAccess(isomalloc_blocklist);\
        CpvAccess(isomalloc_blocklist)=NULL;\
        rank_holding_CmiMemLock=CmiMyRank();\
 
 #define ISOMALLOC_POP \
-       CpvAccess(isomalloc_blocklist)=isomalloc_blocklist;\
+       CpvAccess(isomalloc_blocklist)=pushed_blocklist;\
        rank_holding_CmiMemLock=-1;\
 
 static void meta_init(char **argv)
 {
-   CpvInitialize(Slot *,isomalloc_blocklist);
+   CpvInitialize(CmiIsomallocBlockList *,isomalloc_blocklist);
 }
 
 static void *meta_malloc(size_t size)
@@ -52,22 +36,9 @@ static void *meta_malloc(size_t size)
        void *ret=NULL;
        if (CpvInitialized(isomalloc_blocklist) && CpvAccess(isomalloc_blocklist)) 
        { /*Isomalloc a new block and link it in*/
-               CmiIsomallocBlock blk;
-               Slot *n; /*Newly created slot*/
                ISOMALLOC_PUSH /*Disable isomalloc while inside isomalloc*/
-               n=(Slot *)CmiIsomalloc(sizeof(Slot)+size,&blk);
+               ret=CmiIsomallocBlockListMalloc(pushed_blocklist,size);
                ISOMALLOC_POP
-               n->block=blk;
-               n->userSize=size;
-#ifndef CMK_OPTIMIZE
-               n->magic=MAGIC1;
-#endif
-               n->prev=isomalloc_blocklist;
-               n->next=isomalloc_blocklist->next;
-               isomalloc_blocklist->next->prev=n;
-               isomalloc_blocklist->next=n;
-               ret=Slot_toUser(n);
-               CmiPrintf("Isomalloc'd %p: %d\n",ret,size);
        }
        else /*Just use regular malloc*/
                ret=mm_malloc(size);
@@ -78,17 +49,8 @@ static void meta_free(void *mem)
 {
        if (CmiIsomallocInRange(mem)) 
        { /*Unlink this slot and isofree*/
-               Slot *n=Slot_fmUser(mem);
-               CmiIsomallocBlock blk=n->block;
                ISOMALLOC_PUSH
-#ifndef CMK_OPTIMIZE
-               if (n->magic!=MAGIC1) 
-                       CmiAbort("Heap corruption detected!  Run with ++debug to find out hwere");
-#endif
-               CmiPrintf("Isofree'd %p\n",mem);
-               n->prev->next=n->next;
-               n->next->prev=n->prev;
-               CmiIsomallocFree(&blk);
+               CmiIsomallocBlockListFree(mem);
                ISOMALLOC_POP
        }
        else /*Just use regular malloc*/
@@ -116,9 +78,10 @@ static void *meta_realloc(void *oldBuffer, size_t newSize)
        
        newBuffer = meta_malloc(newSize);
        if ( newBuffer && oldBuffer ) {
-               /*Preserve old buffer contents*/
-               Slot *o=Slot_fmUser(oldBuffer);
-               size_t size=o->userSize;
+               /*Must preserve old buffer contents, so we need the size of the
+                 buffer.  SILLY HACK: muck with internals of blocklist header.*/
+               size_t size=CmiIsomallocLength(((CmiIsomallocBlockList *)oldBuffer)-1)-
+                       sizeof(CmiIsomallocBlockList);
                if (size<newSize) size=newSize;
                if (size > 0)
                        memcpy(newBuffer, oldBuffer, size);
@@ -156,82 +119,17 @@ void free_nomigrate(void *mem)
 }
 
 #define CMK_MEMORY_HAS_ISOMALLOC
-/*Build a new blockList.*/
-CmiIsomallocBlockList *CmiIsomallocBlockListNew(void)
-{
-       CmiIsomallocBlockList *ret;
-       CmiIsomallocBlock blk;
-       ret=(CmiIsomallocBlockList *)CmiIsomalloc(sizeof(*ret),&blk);
-       ret->next=ret; /*1-entry circular linked list*/
-       ret->prev=ret;
-       ret->block=blk;
-       ret->userSize=0;
-       ret->magic=MAGIC1;
-       return ret;
-}
 
 /*Make this blockList "active"-- the recipient of incoming
 mallocs.  Returns the old blocklist.*/
 CmiIsomallocBlockList *CmiIsomallocBlockListActivate(CmiIsomallocBlockList *l)
 {
-       register Slot **s=&CpvAccess(isomalloc_blocklist);
+       register CmiIsomallocBlockList **s=&CpvAccess(isomalloc_blocklist);
        CmiIsomallocBlockList *ret=*s;
        *s=l;
        return ret;
 }
 
-/*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!
-*/
-void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp)
-{
-       CmiIsomallocBlock blk;
-       int i,nBlocks=0;
-       Slot *cur=NULL, *start=*lp;
-#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;
-               if (!pup_isUnpacking(p)) {
-                       blk=cur->block;
-                       cur=cur->next;
-               }
-               newBlock=CmiIsomallocPup(p,&blk);
-               if (i==0 && pup_isUnpacking(p))
-                       *lp=(Slot *)newBlock;
-       }
-       if (pup_isDeleting(p))
-               *lp=NULL;
-}
-
-/*Delete all the blocks in this list.*/
-void CmiIsomallocBlockListFree(CmiIsomallocBlockList *l)
-{
-       Slot *start=l;
-       Slot *cur=start;
-       if (cur==NULL) return; /*Already deleted*/
-       do {
-               Slot *doomed=cur;
-               cur=cur->next; /*Have to stash next before deleting cur*/
-               CmiIsomallocFree(&doomed->block);
-       } while (cur!=start);
-}
-
 
 
 
index b04a7c65bd63005e4a773da3854a550628ad1aca..53bcbdfc422637d572d5384ac5c4fbbe9d4ca18e 100644 (file)
@@ -21,21 +21,9 @@ void free_nomigrate(void *mem);
 void *malloc_reentrant(size_t size);
 void free_reentrant(void *mem);
 
-/*A linked list of allocated migratable memory blocks:*/
-struct CmiIsomallocBlockList_tag;
-typedef struct CmiIsomallocBlockList_tag CmiIsomallocBlockList;
-
-/*Build a new blockList.*/
-CmiIsomallocBlockList *CmiIsomallocBlockListNew(void);
-
 /*Make this blockList active (returns the old blocklist).*/
 CmiIsomallocBlockList *CmiIsomallocBlockListActivate(CmiIsomallocBlockList *l);
 
-/*Pup all the blocks in this list.*/
-void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **l);
-
-/*Delete all the blocks in this list.*/
-void CmiIsomallocBlockListFree(CmiIsomallocBlockList *l);
 
 #ifdef __cplusplus
 };
index b03e7b20ecc4fc6342742d5ade73da2a92477539..9c3ecc7a524e13cde986982190453071e97a64e9 100644 (file)
@@ -23,6 +23,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h> /*For memset, memcpy*/
 #include "converse.h"
 
 /*Choose the proper default configuration*/
@@ -226,14 +227,8 @@ void free_nomigrate(void *mem) { free(mem); }
 
 #ifndef CMK_MEMORY_HAS_ISOMALLOC
 #include "memory-isomalloc.h"
-/*Empty implementations of the CmiIsomallocBlockList API*/
-CmiIsomallocBlockList *CmiIsomallocBlockListNew(void) 
-   {return NULL;}
+/*Not using isomalloc heaps, so forget about activating block list:*/
 CmiIsomallocBlockList *CmiIsomallocBlockListActivate(CmiIsomallocBlockList *l)
    {return l;}
-void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **l)
-   {}
-void CmiIsomallocBlockListFree(CmiIsomallocBlockList *l)
-   {}
 #endif
 
index e00289d6049a7916d9581b07f1d6e73b4bdd22ad..ba5f2a704f229c4f71ba492e8f3f3d35009244ab 100644 (file)
@@ -129,7 +129,6 @@ typedef struct CthThreadBase
   int        datasize;   /* size of thread-private data, in bytes */
 
   int isIsomalloc; /* thread stack was isomalloc'd*/
-  CmiIsomallocBlock isostack;
   void      *stack; /*Pointer to thread stack*/
   int        stacksize; /*Size of thread stack (bytes)*/
 } CthThreadBase;
@@ -220,7 +219,7 @@ static void *CthAllocateStack(CthThreadBase *th,int *stackSize,int useIsomalloc)
     ret=malloc(*stackSize); 
   } else {
     th->isIsomalloc=1;
-    ret=CmiIsomalloc(*stackSize,&th->isostack);
+    ret=CmiIsomalloc(*stackSize);
   }
   _MEMCHECK(ret);
   th->stack=ret;
@@ -230,12 +229,12 @@ static void CthThreadBaseFree(CthThreadBase *th)
 {
   free(th->data);
   if (th->isIsomalloc) {
-         CmiIsomallocFree(&th->isostack);
+         CmiIsomallocFree(th->stack);
   } 
   else if (th->stack!=NULL) {
          free(th->stack);
-         th->stack=NULL;
   }
+  th->stack=NULL;
 }
 
 CpvDeclare(int, _numSwitches); /*Context switch count*/
@@ -283,10 +282,12 @@ void CthPupBase(pup_er p,CthThreadBase *t,int useIsomalloc)
        pup_int(p,&t->isIsomalloc);
        pup_int(p,&t->stacksize);       
        if (t->isIsomalloc) {
-               t->stack=CmiIsomallocPup(p,&t->isostack);
+               CmiIsomallocPup(p,&t->stack);
        } else {
                if (useIsomalloc)
                        CmiAbort("You must use CthCreateMigratable to use CthPup!\n");
+               /*Pup the stack pointer as raw bytes*/
+               pup_bytes(p,&t->stack,sizeof(t->stack));
        }
 }
 
@@ -1210,7 +1211,6 @@ CthThread CthPup(pup_er p, CthThread t)
   CthPupBase(p,&t->base,1);
   
   /*Pup the stack pointer as bytes-- this works because stack is isomalloc'd*/
-  pup_bytes(p,&t->stack,sizeof(t->stack));
   pup_bytes(p,&t->stackp,sizeof(t->stackp));
 
   /*Don't worry about stack protection on migration*/