committing as i want these changes on my local machine, version is unstable and buggy...
authorNikhil Jain <nikhil@illinois.edu>
Fri, 7 Oct 2011 23:16:55 +0000 (18:16 -0500)
committerNikhil Jain <nikhil@illinois.edu>
Fri, 7 Oct 2011 23:16:55 +0000 (18:16 -0500)
src/arch/util/mempool.c
src/arch/util/mempool.h
src/conv-core/converse.h
src/conv-core/global-elfcopy.C
src/conv-core/isomalloc.c
src/conv-core/threads.c

index a277d080762fe86d342c29e4a2c7ae0c2d158b52..64d3d4c4cc7798f5e7aa7a1dbb877486d51956e7 100644 (file)
@@ -24,7 +24,8 @@ Generalized by Gengbin Zheng  10/5/2011
 
 #include "mempool.h"
 
-static      size_t     expand_mem = 1024ll*1024*16;
+//static      size_t     expand_mem = 1024*16;
+//static      size_t     expand_mem = 1024ll*1024*16;
 
 mempool_type *mempool_init(size_t pool_size, mempool_newblockfn allocfn, mempool_freeblock freefn)
 {
@@ -32,7 +33,7 @@ mempool_type *mempool_init(size_t pool_size, mempool_newblockfn allocfn, mempool
     mempool_header *header;
     gni_mem_handle_t  mem_hndl;
 
-    void *pool = allocfn(pool_size, &mem_hndl);
+    void *pool = allocfn(&pool_size, &mem_hndl);
     mptr = (mempool_type*)pool;
     mptr->newblockfn = allocfn;
     mptr->freeblockfn = freefn;
@@ -42,14 +43,19 @@ mempool_type *mempool_init(size_t pool_size, mempool_newblockfn allocfn, mempool
     mptr->mempools_head.next = NULL;
     header = (mempool_header *) ((char*)pool+sizeof(mempool_type));
     mptr->freelist_head = sizeof(mempool_type);
-//printf("[%d] pool: %p  free: %p\n", myrank, pool, header);
+#if MEMPOOL_DEBUG
+    printf("[%d] pool: %p  free: %p\n", myrank, pool, header);
+#endif 
     header->size = pool_size-sizeof(mempool_type)-sizeof(mempool_header);
     header->mem_hndl = mem_hndl;
     header->next_free = 0;
+#if 1 || MEMPOOL_DEBUG 
+    printf("[%d] Initiated mempool with %d memory at %p\n",CmiMyPe(),pool_size,pool);
+#endif
     return mptr;
 }
 
-void mempool_destory(mempool_type *mptr)
+void mempool_destroy(mempool_type *mptr)
 {
     mempool_block *current, *mempools_head;
     mempool_freeblock   freefn = mptr->freeblockfn;
@@ -124,15 +130,18 @@ void*  mempool_malloc(mempool_type *mptr, int size, int expand)
 
         if (!expand) return NULL;
 
-        expand_size = expand_mem>size ? expand_mem:2*size; 
-        pool = mptr->newblockfn(expand_size, &mem_hndl);
+        expand_size = size;
+//      expand_size = expand_mem>size ? expand_mem:2*size; 
+        pool = mptr->newblockfn(&expand_size, &mem_hndl);
         expand_pool = (mempool_block*)pool;
         expand_pool->mempool_ptr = pool;
         expand_pool->mem_hndl = mem_hndl;
         expand_pool->size = expand_size;
         expand_pool->next = NULL;
+#if MEMPOOL_DEBUG
         printf("[%d] No memory has such free empty chunck of %d. expanding %p with new size %d\n", CmiMyPe(), size, expand_pool->mempool_ptr, expand_size);
-          // FIXME: go to the end of link list
+#endif
+        // FIXME: go to the end of link list
         while (mempools_head->next != NULL) mempools_head = mempools_head->next;
         mempools_head->next = expand_pool;
 
@@ -140,7 +149,8 @@ void*  mempool_malloc(mempool_type *mptr, int size, int expand)
         bestfit->size = expand_size-sizeof(mempool_block);
         bestfit->mem_hndl = expand_pool->mem_hndl;
         bestfit->next_free = 0;
-        bestfit_size = expand_size;
+        //bestfit_size = expand_size;
+        bestfit_size = bestfit->size;
 #if 0
         current = freelist_head;
         while(current!= NULL && current < bestfit )
@@ -158,14 +168,14 @@ void*  mempool_malloc(mempool_type *mptr, int size, int expand)
            previous->next_free = (char*)bestfit-(char*)mptr;
     }
 
-    bestfit->size = size;
-    if(bestfit_size > size) //deduct this entry 
+    //bestfit->size = size;
+    if(bestfit_size > (size + sizeof(mempool_header))) //deduct this entry 
     {
         mempool_header *ptr = (mempool_header *)((char*)bestfit + size);
         ptr->size = bestfit_size - size;
         ptr->mem_hndl = bestfit->mem_hndl;
         ptr->next_free = bestfit->next_free;
-        if(bestfit == freelist_head_ptr)
+        if(bestfit == freelist_head_ptr || freelist_head_ptr == NULL)
            *freelist_head = (char*)ptr - (char*)mptr;
         if(bestfit_previous != NULL)
            bestfit_previous->next_free = (char*)ptr - (char*)mptr;
@@ -179,10 +189,10 @@ void*  mempool_malloc(mempool_type *mptr, int size, int expand)
     }
 #if  MEMPOOL_DEBUG
     printf("[%d] ++MALLOC served: %d, ptr:%p\n", CmiMyPe(), size, bestfit);
-printf("[%d] freelist_head in malloc  offset:%d free_head: %ld %ld %d %d\n", myrank, (char*)bestfit-(char*)mptr, *freelist_head, ((mempool_header*)((char*)mptr+*freelist_head))->next_free, bestfit_size, size);
+printf("[%d] freelist_head in malloc  offset:%d free_head: %ld %ld %d %d\n", CmiMyPe(), (char*)bestfit-(char*)mptr, *freelist_head, ((mempool_header*)((char*)mptr+*freelist_head))->next_free, bestfit_size, size);
 #endif
     CmiAssert(*freelist_head >= 0);
-    return (char*)bestfit;
+    return (void*)bestfit;
 }
 
 //sorted free_list and merge it if it become continous 
@@ -208,7 +218,7 @@ void mempool_free(mempool_type *mptr, void *ptr_free)
     free_lastbytes_pos = (char*)ptr_free +free_size;
 
 #if  MEMPOOL_DEBUG
-    printf("[%d] INSIDE FREE ptr=%p, size=%d freehead=%p mutex: %p\n", CmiMyPe(), ptr_free, free_size, freelist_head, mptr->mutex);
+    printf("[%d] INSIDE FREE ptr=%p, size=%d freehead=%p \n", CmiMyPe(), ptr_free, free_size, freelist_head);
 #endif
     
     while(current!= NULL && current < to_free )
index c396d80630b6f6e26ccb901a18a353af104784ec..614083e152dedbfe3c0254bfadefc4c20a6d0826 100644 (file)
@@ -18,7 +18,7 @@ typedef struct mempool_block_t
 {
     void                *mempool_ptr;
     gni_mem_handle_t    mem_hndl;
-    int                 size;
+    CmiInt8             size;
     struct              mempool_block_t *next;
 } mempool_block;
 
@@ -30,7 +30,7 @@ typedef struct mempool_header
   size_t            next_free;
 } mempool_header;
 
-typedef void * (* mempool_newblockfn)(int size, gni_mem_handle_t *mem_hndl);
+typedef void * (* mempool_newblockfn)(size_t *size, gni_mem_handle_t *mem_hndl);
 typedef void (* mempool_freeblock)(void *ptr, gni_mem_handle_t mem_hndl);
 
 // only at beginning of first block of mempool
@@ -43,7 +43,7 @@ typedef struct mempool_type
 } mempool_type;
 
 mempool_type *mempool_init(size_t pool_size, mempool_newblockfn newfn, mempool_freeblock freefn);
-void  mempool_destory(mempool_type *mptr);
+void  mempool_destroy(mempool_type *mptr);
 void*  mempool_malloc(mempool_type *mptr, int size, int expand);
 void mempool_free(mempool_type *mptr, void *ptr_free);
 
index c33df3592e34340f4b1a12a3884c70a4da65e5e6..2fc734f1ccc8657569a180fa4c8d66cb9f0d480a 100644 (file)
@@ -55,6 +55,7 @@
 /* Tag variable y as being from unit x: */
 #define CMK_TAG(x,y) x##y##_
 
+#define USE_MEMPOOL_ISOMALLOC 1
 
 #include "pup_c.h"
 
index 7281aff872feaf1c58afc9dc6a7e728e08146cc2..494dd0fa501b48a60e1c69b8cb869cc6c25b940d 100644 (file)
@@ -250,7 +250,8 @@ void CtgGlobalStruct::pup(PUP::er &p) {
     p | seg_size;
         /* global data segment need to be isomalloc pupped */
     if (CmiMemoryIs(CMI_MEMORY_IS_ISOMALLOC))
-      CmiIsomallocPup(&p, &data_seg);
+      //CmiIsomallocPup(&p, &data_seg);
+      pub_bytes(&p, &data_seg,sizeof(char*));
     else {
       if (p.isUnpacking()) allocate(seg_size);
       p((char *)data_seg, seg_size);
index c431fcb308bee4dc0f5c6bc6d6f954066abc6ae5..e60c5cfb02311723e7cc4f5b01d97fd5bf01fbb8 100644 (file)
@@ -46,10 +46,6 @@ added by Ryan Mokos in July 2008.
 
 #define CMK_THREADS_DEBUG 0
 
-/* 0: use the old non-mempool implementation
-1: use the new mempool implementation  */
-#define USE_MEMPOOL_ISOMALLOC 1
-
 /* 0: use the old isomalloc implementation (array)
 1: use the new isomalloc implementation (b-tree)  */
 #define USE_BTREE_ISOMALLOC 1
@@ -142,10 +138,15 @@ static CmiInt8 pe2slot(int pe) {
   return pe*numslots;
 }
 /* Return the number of slots in a block with n user data bytes */
+#if USE_MEMPOOL_ISOMALLOC
+static int length2slots(int nBytes) {
+  return (sizeof(CmiIsomallocBlock)+sizeof(mempool_type)+ sizeof(mempool_header)+nBytes+slotsize-1)/slotsize;
+}
+#else
 static int length2slots(int nBytes) {
   return (sizeof(CmiIsomallocBlock)+nBytes+slotsize-1)/slotsize;
 }
-
+#endif
 /* ======================================================================
  * New isomalloc (b-tree-based implementation)
  * ====================================================================== */
@@ -1647,6 +1648,40 @@ CpvStaticDeclare(slotset *, myss); /*My managed slots*/
 
 #if USE_MEMPOOL_ISOMALLOC
 CtvStaticDeclare(mempool_type *, threadpool); /*Thread managed pools*/
+
+//alloc function to be used by mempool
+void * isomallocfn (size_t *size, gni_mem_handle_t *mem_hndl)
+{
+  CmiInt8 s,n,i;
+  void *newaddr;
+  n=length2slots(*size);
+  /*Always satisfy mallocs with local slots:*/
+  s=get_slots(CpvAccess(myss),n);
+  if (s==-1) {
+    CmiError("Not enough address space left on processor %d to isomalloc %d bytes!\n",
+              CmiMyPe(),*size);
+    CmiAbort("Out of virtual address space for isomalloc");
+  }
+  grab_slots(CpvAccess(myss),s,n);
+  for (i=0; i<5; i++) {
+    newaddr=map_slots(s,n);
+    if (newaddr!=NULL) break;
+#if CMK_HAS_USLEEP
+    if (errno == ENOMEM) { usleep(rand()%1000); continue; }
+    else break;
+#endif
+  }
+  if (!newaddr) map_failed(s,n);
+  *mem_hndl = s;
+  *size = n*slotsize;
+  return newaddr;
+}
+
+//free function to be used by mempool
+void isofreefn(void *ptr, gni_mem_handle_t mem_hndl)
+{
+  call_munmap(ptr, ((mempool_block *)ptr)->size);
+}
 #endif
 
 /*This struct describes a range of virtual addresses*/
@@ -2256,6 +2291,22 @@ static void all_slotOP(const slotOP *op,CmiInt8 s,CmiInt8 n)
 }
 
 /************** External interface ***************/
+#if USE_MEMPOOL_ISOMALLOC
+void *CmiIsomalloc(int size)
+{
+  CmiInt8 s,n,i;
+  CmiIsomallocBlock *blk;
+  if (isomallocStart==NULL) return disabled_map(size);
+  if(CtvAccess(threadpool) == NULL) {
+    CtvAccess(threadpool) = mempool_init(size+sizeof(CmiIsomallocBlock), 
+                                                isomallocfn, isofreefn);
+  }
+  blk = (CmiIsomallocBlock*)mempool_malloc(CtvAccess(threadpool),size+sizeof(CmiIsomallocBlock),1);
+  blk->slot=-1;
+  blk->length=size;
+  return block2pointer(blk);
+}
+#else
 void *CmiIsomalloc(int size)
 {
   CmiInt8 s,n,i;
@@ -2283,6 +2334,7 @@ void *CmiIsomalloc(int size)
   blk->length=size;
   return block2pointer(blk);
 }
+#endif
 
 #define MALLOC_ALIGNMENT           (2*sizeof(size_t))
 #define MINSIZE                    (sizeof(CmiIsomallocBlock))
@@ -2377,16 +2429,20 @@ void CmiIsomallocFree(void *blockPtr)
   }
   else if (blockPtr!=NULL)
   {
+#if USE_MEMPOOL_ISOMALLOC
+    mempool_free(CtvAccess(threadpool), blockPtr);
+#else
     CmiIsomallocBlock *blk=pointer2block(blockPtr);
     CmiInt8 s=blk->slot; 
     CmiInt8 n=length2slots(blk->length);
     unmap_slots(s,n);
     /*Mark used slots as free*/
     all_slotOP(&freeOP,s,n);
+#endif
   }
 }
 
-CmiInt8   CmiIsomallocLength(void *block)
+CmiInt8  CmiIsomallocLength(void *block)
 {
   return pointer2block(block)->length;
 }
@@ -2447,7 +2503,6 @@ void CmiIsomallocInit(char **argv)
 static char *Slot_toUser(CmiIsomallocBlockList *s) {return (char *)(s+1);}
 static CmiIsomallocBlockList *Slot_fmUser(void *s) {return ((CmiIsomallocBlockList *)s)-1;}
 
-
 /*Build a new blockList.*/
 CmiIsomallocBlockList *CmiIsomallocBlockListNew(void)
 {
@@ -2458,7 +2513,6 @@ CmiIsomallocBlockList *CmiIsomallocBlockListNew(void)
   return ret;
 }
 
-
 /* BIGSIM_OOC DEBUGGING */
 static void print_myslots();
 
@@ -2466,6 +2520,37 @@ static void print_myslots();
   list traversals.  Because everything's isomalloc'd, we don't even
   have to restore the pointers-- they'll be restored automatically!
   */
+#if USE_MEMPOOL_ISOMALLOC
+void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp)
+{
+  mempool_block *current, *mempools_head;
+  void *newblock;
+  int slot;
+  CmiInt8 size;
+
+  if(!pup_isUnpacking(p)) {
+    printf("[%d] address is %p %p\n",CmiMyPe(),CtvAccess(threadpool),&(CtvAccess(threadpool)->mempools_head));
+    current = &(CtvAccess(threadpool)->mempools_head);
+    while(current != NULL) {
+      pup_int8(p,&current->size);
+      pup_int(p,&current->mem_hndl);
+      pup_bytes(p,current->mempool_ptr,current->size);
+      current = current->next;
+    }
+    mempool_destroy(CtvAccess(threadpool));
+  }
+
+  if(pup_isUnpacking(p)) {
+    pup_int8(p,&size);
+    pup_int(p,&slot);
+    newblock = map_slots(slot,size/slotsize);
+    pup_bytes(p,newblock,size);
+  }
+  pup_bytes(p,lp,sizeof(int*));
+  if (pup_isDeleting(p))
+    *lp=NULL;
+}
+#else
 void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp)
 {
   /* BIGSIM_OOC DEBUGGING */
@@ -2505,6 +2590,7 @@ void CmiIsomallocBlockListPup(pup_er p,CmiIsomallocBlockList **lp)
   /* BIGSIM_OOC DEBUGGING */
   /* if(pup_isUnpacking(p)) print_myslots(); */
 }
+#endif
 
 /*Delete all the blocks in this list.*/
 void CmiIsomallocBlockListDelete(CmiIsomallocBlockList *l)
@@ -2560,8 +2646,6 @@ void CmiIsomallocBlockListFree(void *block)
   CmiIsomallocFree(n);
 }
 
-
-
 /* BIGSIM_OOC DEBUGGING */
 static void print_myslots(){
   CmiPrintf("[%d] my slot set=%p\n", CmiMyPe(), CpvAccess(myss));
index 062f7411dddafc0f6f30e79f7adcc5176c231515..c6143245353a119c26844652ee642e031876d4c3 100644 (file)
@@ -596,7 +596,8 @@ void CthPupBase(pup_er p,CthThreadBase *t,int useMigratable)
 #elif CMK_THREADS_USE_STACKCOPY
                /* do nothing */
 #else /* isomalloc */
-               CmiIsomallocPup(p,&t->stack);
+//             CmiIsomallocPup(p,&t->stack);
+               pup_bytes(p,&t->stack,sizeof(char*));
 #endif
        } 
        else {
@@ -617,7 +618,8 @@ void CthPupBase(pup_er p,CthThreadBase *t,int useMigratable)
         pup_bytes(p, &t->tlsseg, sizeof(tlsseg_t));
         aux = ((void*)(t->tlsseg.memseg)) - t->tlsseg.size;
         /* fixme: tls global variables handling needs isomalloc */
-        CmiIsomallocPup(p, &aux);
+        //CmiIsomallocPup(p, &aux);
+                   pup_bytes(p,&aux,sizeof(char*));
         /* printf("[%d] %s %p\n", CmiMyPe(), pup_typeString(p), t->tlsseg.memseg); */
 #endif