[BACK]Return to mem.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libelwix / src

Diff for /libelwix/src/mem.c between versions 1.4.18.1 and 1.6.2.2

version 1.4.18.1, 2015/06/25 00:36:48 version 1.6.2.2, 2016/05/14 13:12:43
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004 - 2015Copyright 2004 - 2016
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 218  mpool_malloc(mpool_t * __restrict mp, u_int size, cons Line 218  mpool_malloc(mpool_t * __restrict mp, u_int size, cons
                         return NULL;                          return NULL;
                 } else {        /* quota */                  } else {        /* quota */
                         mp->pool_quota.curr += size;                          mp->pool_quota.curr += size;
                           mp->pool_quota.real += 1 << (idx + MEM_MIN_BUCKET);
                         memset(m->alloc_mem, 0, align + 12);                          memset(m->alloc_mem, 0, align + 12);
                 }                  }
         }          }
Line 246  mpool_malloc(mpool_t * __restrict mp, u_int size, cons Line 247  mpool_malloc(mpool_t * __restrict mp, u_int size, cons
 void *  void *
 mpool_realloc(mpool_t * __restrict mp, void * __restrict data, u_int newsize, const char *memname)  mpool_realloc(mpool_t * __restrict mp, void * __restrict data, u_int newsize, const char *memname)
 {  {
         struct tagAlloc *m, *tmp;  
         int idx, oidx;          int idx, oidx;
         void *p;          void *p;
        u_int align, osize;        u_int osize;
   
         /* if !data execute mpool_malloc() */          /* if !data execute mpool_malloc() */
         if (!data)          if (!data)
Line 263  mpool_realloc(mpool_t * __restrict mp, void * __restri Line 263  mpool_realloc(mpool_t * __restrict mp, void * __restri
         if (MEM_BADADDR(data) || MEM_CORRUPT(data)) {          if (MEM_BADADDR(data) || MEM_CORRUPT(data)) {
                 elwix_SetErr(EFAULT, "Corrupted memory address");                  elwix_SetErr(EFAULT, "Corrupted memory address");
                 return NULL;                  return NULL;
         } else {  
                 osize = ((u_int*)data)[-2] * sizeof(u_int);  
                 oidx = BucketIndex(osize);  
         }          }
         /* prepare new size */          /* prepare new size */
         if (newsize > MEM_ALLOC_MAX) {          if (newsize > MEM_ALLOC_MAX) {
                 elwix_SetErr(ENOMEM, "Memory size is too large");                  elwix_SetErr(ENOMEM, "Memory size is too large");
                 return NULL;                  return NULL;
         } else {  
                 newsize = (newsize + 3) & ~3;   /* must align to 4 because needed room for sentinels */  
                 idx = BucketIndex(newsize);  
         }          }
   
         mpool_lock(mp);          mpool_lock(mp);
   
           osize = ((u_int*)data)[-2] * sizeof(u_int);
           oidx = BucketIndex(osize);
           newsize = (newsize + 3) & ~3;   /* must align to 4 because needed room for sentinels */
           idx = BucketIndex(newsize);
   
         /* quota */          /* quota */
         if (mp->pool_quota.max &&           if (mp->pool_quota.max && 
                         (mp->pool_quota.curr + ((u_long) newsize - osize)) > mp->pool_quota.max) {                          (mp->pool_quota.curr + ((u_long) newsize - osize)) > mp->pool_quota.max) {
Line 286  mpool_realloc(mpool_t * __restrict mp, void * __restri Line 285  mpool_realloc(mpool_t * __restrict mp, void * __restri
                 return NULL;                  return NULL;
         }          }
   
        /* find old memory block */        if (oidx != idx) {
        TAILQ_FOREACH_SAFE(m, &mp->pool_active[oidx], alloc_node, tmp) { 
                if (mem_data(m, void*) == data && mem_size(m) == osize) { 
                        /* case in different buckets */ 
                        if (oidx != idx) { 
                                TAILQ_REMOVE(&mp->pool_active[oidx], m, alloc_node); 
                                /* statistics */ 
                                mp->pool_calls.alloc--; 
                        } 
                        mp->pool_bytes.alloc -= osize; 
                        break; 
                } 
        } 
        /* memory block not found! */ 
        if (!m) { 
                 mpool_unlock(mp);                  mpool_unlock(mp);
                elwix_SetErr(EFAULT, "Memory block not found");                p = mpool_malloc(mp, newsize, memname);
                return NULL;                if (!p)
        }                        return NULL;
   
        /* try to reallocate memory block to new bucket */                memcpy(p, data, MIN(osize, newsize));
        if (oidx != idx) {                mpool_free(mp, data, 0);
                align = 1 << (idx + MEM_MIN_BUCKET);        } else {
                p = realloc(m->alloc_mem, align + 12);                p = data;
                if (!p) { 
                        LOGERR; 
   
                        /* restore to old bucket pulled memory block for reallocation */                ((u_int*) p)[-2] = newsize / sizeof(u_int);
                        TAILQ_INSERT_HEAD(&mp->pool_active[oidx], m, alloc_node);                ((u_int*) p)[newsize / sizeof(u_int)] = MEM_MAGIC_STOP;
                        /* statistics */ 
                        mp->pool_calls.alloc++; 
                        mp->pool_bytes.alloc += osize; 
   
                        mpool_unlock(mp);                mp->pool_bytes.alloc += (u_long) newsize - osize;
                        return NULL;                mp->pool_quota.curr += (u_long) newsize - osize;
                } else 
                        m->alloc_mem = (u_int*) p; 
        } 
        /* quota */ 
        mp->pool_quota.curr += (u_long) newsize - osize; 
   
        m->alloc_mem[0] = newsize / sizeof(u_int);                mpool_unlock(mp);
        m->alloc_mem[1] = MEM_MAGIC_START; 
        m->alloc_mem[2 + newsize / sizeof(u_int)] = MEM_MAGIC_STOP; 
 
        if (oidx != idx) { 
                TAILQ_INSERT_HEAD(&mp->pool_active[idx], m, alloc_node); 
                /* statistics */ 
                mp->pool_calls.alloc++; 
         }          }
         mp->pool_bytes.alloc += newsize;  
   
        if (memname)        return p;
                strlcpy(m->alloc_name, memname, sizeof m->alloc_name); 
 
        mpool_unlock(mp); 
        return mem_data(m, void*); 
 }  }
   
 /*  /*
Line 382  mpool_purge(mpool_t * __restrict mp, u_int atmost) Line 345  mpool_purge(mpool_t * __restrict mp, u_int atmost)
                         mp->pool_bytes.free += mem_size(m);                          mp->pool_bytes.free += mem_size(m);
                         /* quota */                          /* quota */
                         mp->pool_quota.curr -= mem_size(m);                          mp->pool_quota.curr -= mem_size(m);
                           mp->pool_quota.real -= 1 << (i + MEM_MIN_BUCKET);
   
                         if (m->alloc_mem)                          if (m->alloc_mem)
                                 free(m->alloc_mem);                                  free(m->alloc_mem);
Line 440  mpool_free(mpool_t * __restrict mp, void * __restrict  Line 404  mpool_free(mpool_t * __restrict mp, void * __restrict 
                                 mp->pool_bytes.free += mem_size(m);                                  mp->pool_bytes.free += mem_size(m);
                                 /* quota */                                  /* quota */
                                 mp->pool_quota.curr -= mem_size(m);                                  mp->pool_quota.curr -= mem_size(m);
                                   mp->pool_quota.real -= 1 << (idx + MEM_MIN_BUCKET);
   
                                 if (m->alloc_mem)                                  if (m->alloc_mem)
                                         free(m->alloc_mem);                                          free(m->alloc_mem);
Line 492  mpool_free2(mpool_t * __restrict mp, u_int size, const Line 457  mpool_free2(mpool_t * __restrict mp, u_int size, const
                                 mp->pool_bytes.free += mem_size(m);                                  mp->pool_bytes.free += mem_size(m);
                                 /* quota */                                  /* quota */
                                 mp->pool_quota.curr -= mem_size(m);                                  mp->pool_quota.curr -= mem_size(m);
                                   mp->pool_quota.real -= 1 << (idx + MEM_MIN_BUCKET);
   
                                 if (m->alloc_mem)                                  if (m->alloc_mem)
                                         free(m->alloc_mem);                                          free(m->alloc_mem);
Line 627  mpool_setquota(mpool_t * __restrict mp, u_long maxmem) Line 593  mpool_setquota(mpool_t * __restrict mp, u_long maxmem)
  * mpool_getquota() - Get memory quota   * mpool_getquota() - Get memory quota
  *   *
  * @mp = Memory pool   * @mp = Memory pool
 * @currmem = Return current memory * @currmem = Return current memory usage
  * @realmem = Return current real memory usage
  * @maxmem = Return max quota size   * @maxmem = Return max quota size
  * return: none   * return: none
  */   */
 void  void
mpool_getquota(mpool_t * __restrict mp, u_long *currmem, u_long *maxmem)mpool_getquota(mpool_t * __restrict mp, u_long *currmem, u_long *realmem, u_long *maxmem)
 {  {
         if (!mp)          if (!mp)
                 return;                  return;
   
         if (maxmem)          if (maxmem)
                 *maxmem = mp->pool_quota.max;                  *maxmem = mp->pool_quota.max;
           if (realmem)
                   *realmem = mp->pool_quota.real;
         if (currmem)          if (currmem)
                 *currmem = mp->pool_quota.curr;                  *currmem = mp->pool_quota.curr;
 }  }
Line 746  mpool_xstatistics(mpool_stat_cb cb) Line 715  mpool_xstatistics(mpool_stat_cb cb)
 {  {
         mpool_statistics(elwix_mpool, cb);          mpool_statistics(elwix_mpool, cb);
 }  }
   
   static void
   xdump_show(u_int size, u_int act, u_int inact)
   {
           if (!act && !inact)
                   return; /* skip empty bucket */
   
           if (size < 1024)
                   printf("\t\t* BUCKET %uB size, %u active, %u inactive\n", 
                                   size, act, inact);
           else if (size < 1048576)
                   printf("\t\t* BUCKET %uKB size, %u active, %u inactive\n", 
                                   size / 1024, act, inact);
           else
                   printf("\t\t* BUCKET %uMB size, %u active, %u inactive\n", 
                                   size / 1048576, act, inact);
   }
   
   /*
    * mpool_dump() - Dump elwix memory pool statistics
    *
    * @mp = memory pool, if =NULL dump elwix default memory pool
    * @fmt = prefix info format string
    * @... = argument(s)
    * return: none
    */
   void
   mpool_dump(mpool_t * __restrict mp, const char *fmt, ...)
   {
           va_list lst;
           mpool_t *p = mp ? mp : elwix_mpool;
   
           if (fmt) {
                   va_start(lst, fmt);
                   vprintf(fmt, lst);
                   va_end(lst);
           } else
                   printf("\n%s(%d)\n", __func__, __LINE__);
   
           printf("------------------------------------------------------------\n");
           printf( " ELWIX memory pool ::\n"
                   "\t- quotas Current/Real/Max = %lu/%lu/%lu\n"
                   "\t- calls Alloc/Free/Cache = %lu/%lu/%lu\n"
                   "\t- bytes Alloc/Free/Cache = %lu/%lu/%lu\n"
                   "\t- buckets :\n", 
                   p->pool_quota.curr, p->pool_quota.real, p->pool_quota.max, 
                   p->pool_calls.alloc, p->pool_calls.free, p->pool_calls.cache, 
                   p->pool_bytes.alloc, p->pool_bytes.free, p->pool_bytes.cache);
   
           mpool_statistics(p, xdump_show);
           printf("------------------------------------------------------------\n");
   }
   
Removed from v.1.4.18.1  
changed lines
  Added in v.1.6.2.2

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>