[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.7 and 1.11

version 1.7, 2016/05/18 12:47:42 version 1.11, 2024/10/28 09:58:51
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 - 2016Copyright 2004 - 2024
         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 91  mpool_init(u_long maxmem) Line 91  mpool_init(u_long maxmem)
 void  void
 mpool_destroy(mpool_t ** __restrict mp)  mpool_destroy(mpool_t ** __restrict mp)
 {  {
        struct tagAlloc *m;        struct tagAlloc *m, *n;
         register int i;          register int i;
   
        if (!mp && !*mp)        if (!mp || !*mp)
                 return;                  return;
   
         mpool_lock(*mp);          mpool_lock(*mp);
   
         for (i = 0; i < MEM_BUCKETS; i++) {          for (i = 0; i < MEM_BUCKETS; i++) {
                while ((m = TAILQ_FIRST(&(*mp)->pool_active[i]))) {                for (m = TAILQ_FIRST(&(*mp)->pool_active[i]); m; m = n) {
                        TAILQ_REMOVE(&(*mp)->pool_active[i], m, alloc_node);                        n = TAILQ_NEXT(m, alloc_node);
                         if (m->alloc_mem)                          if (m->alloc_mem)
                                 free(m->alloc_mem);                                  free(m->alloc_mem);
                         free(m);                          free(m);
                 }                  }
                while ((m = TAILQ_FIRST(&(*mp)->pool_inactive[i]))) {                for (m = TAILQ_FIRST(&(*mp)->pool_inactive[i]); m; m = n) {
                        TAILQ_REMOVE(&(*mp)->pool_inactive[i], m, alloc_node);                        n = TAILQ_NEXT(m, alloc_node);
                         if (m->alloc_mem)                          if (m->alloc_mem)
                                 free(m->alloc_mem);                                  free(m->alloc_mem);
                         free(m);                          free(m);
Line 219  mpool_malloc(mpool_t * __restrict mp, u_int size, cons Line 219  mpool_malloc(mpool_t * __restrict mp, u_int size, cons
                 } else {        /* quota */                  } else {        /* quota */
                         mp->pool_quota.curr += size;                          mp->pool_quota.curr += size;
                         mp->pool_quota.real += 1 << (idx + MEM_MIN_BUCKET);                          mp->pool_quota.real += 1 << (idx + MEM_MIN_BUCKET);
   #ifdef MPOOL_MEM_ZERO
                         memset(m->alloc_mem, 0, align + 12);                          memset(m->alloc_mem, 0, align + 12);
   #endif
                 }                  }
         }          }
   
Line 236  mpool_malloc(mpool_t * __restrict mp, u_int size, cons Line 238  mpool_malloc(mpool_t * __restrict mp, u_int size, cons
 }  }
   
 /*  /*
    * mpool_calloc() - Multiple memory block allocation
    *
    * @mp = Memory pool
    * @nmemb = Number of memory blocks
    * @size = Size
    * @memname = Optional memory block name
    * return: NULL error or !=NULL ok allocated memory
    */
   void *
   mpool_calloc(mpool_t * __restrict mp, u_int nmemb, u_int size, const char *memname)
   {
           void *m;
           u_int total = nmemb * size;
   
           m = mpool_malloc(mp, total, memname);
   #ifndef MPOOL_MEM_ZERO
           if (m)
                   memset(m, 0, total);
   #endif
           return m;
   }
   
   /*
  * mpool_realloc() Reallocate memory block with new size   * mpool_realloc() Reallocate memory block with new size
  *   *
  * @mp = Memory pool   * @mp = Memory pool
Line 619  mpool_getquota(mpool_t * __restrict mp, u_long *currme Line 644  mpool_getquota(mpool_t * __restrict mp, u_long *currme
  *   *
  * @mp = Memory pool   * @mp = Memory pool
  * @cb = Export statistics to callback   * @cb = Export statistics to callback
 * return: none * return: -1 error or >0 bytes in data buffer
  */   */
voidint
mpool_statistics(mpool_t * __restrict mp, mpool_stat_cb cb)mpool_statistics(mpool_t * __restrict mp, mpool_stat_cb cb, void *data, u_int datlen)
 {  {
         struct tagAlloc *m;          struct tagAlloc *m;
         register int i, act, inact;          register int i, act, inact;
           int len = 0;
   
         if (!mp || !cb)          if (!mp || !cb)
                return;                return -1;
   
         for (i = act = inact = 0; i < MEM_BUCKETS; act = inact = 0, i++) {          for (i = act = inact = 0; i < MEM_BUCKETS; act = inact = 0, i++) {
                 TAILQ_FOREACH(m, &mp->pool_active[i], alloc_node)                  TAILQ_FOREACH(m, &mp->pool_active[i], alloc_node)
Line 636  mpool_statistics(mpool_t * __restrict mp, mpool_stat_c Line 662  mpool_statistics(mpool_t * __restrict mp, mpool_stat_c
                 TAILQ_FOREACH(m, &mp->pool_inactive[i], alloc_node)                  TAILQ_FOREACH(m, &mp->pool_inactive[i], alloc_node)
                         inact++;                          inact++;
   
                cb(1 << (i + MEM_MIN_BUCKET), act, inact);                len += cb(1 << (i + MEM_MIN_BUCKET), act, inact, data, datlen);
         }          }
   
           return len;
 }  }
   
 /* ----------------------------------------------------------- */  /* ----------------------------------------------------------- */
Line 664  mpool_xmalloc(size_t size) Line 692  mpool_xmalloc(size_t size)
 void *  void *
 mpool_xcalloc(size_t num, size_t size)  mpool_xcalloc(size_t num, size_t size)
 {  {
        return mpool_malloc(elwix_mpool, num * size, elwix_Prog);        return mpool_calloc(elwix_mpool, num, size, elwix_Prog);
 }  }
   
 /*  /*
Line 705  mpool_xstrdup(const char *str) Line 733  mpool_xstrdup(const char *str)
 }  }
   
 /*  /*
 * mpool_xstatistics() - elwix memory pool statistics wrapper * mpool_xstatistics() - elwix default memory pool statistics wrapper
  *   *
  * @cb = Export statistics to callback   * @cb = Export statistics to callback
 * return: none * @data = data buffer
  * @datlen = data buffer length
  * return: >0 data in string buffer
  */   */
voidint
mpool_xstatistics(mpool_stat_cb cb)mpool_xstatistics(mpool_stat_cb cb, void *data, u_int datlen)
 {  {
        mpool_statistics(elwix_mpool, cb);        return mpool_statistics(elwix_mpool, cb, data, datlen);
 }  }
   
static voidstatic int
xdump_show(u_int size, u_int act, u_int inact)xdump_show(u_int size, u_int act, u_int inact, void *data, u_int datlen)
 {  {
         if (!act && !inact)          if (!act && !inact)
                return;       /* skip empty bucket */                return 0;       /* skip empty bucket */
   
         if (size < 1024)          if (size < 1024)
                 printf("\t\t* BUCKET %uB size, %u active, %u inactive\n",                   printf("\t\t* BUCKET %uB size, %u active, %u inactive\n", 
Line 731  xdump_show(u_int size, u_int act, u_int inact) Line 761  xdump_show(u_int size, u_int act, u_int inact)
         else          else
                 printf("\t\t* BUCKET %uMB size, %u active, %u inactive\n",                   printf("\t\t* BUCKET %uMB size, %u active, %u inactive\n", 
                                 size / 1048576, act, inact);                                  size / 1048576, act, inact);
   
           return 0;
 }  }
   
   static int
   xdump_show2(u_int size, u_int act, u_int inact, void *data, u_int datlen)
   {
           char szStr[STRSIZ], *str = data;
           int len = 0;
   
           if (!data || !datlen)
                   return 0;       /* skip missing data buffer */
           if (!act && !inact)
                   return 0;       /* skip empty bucket */
   
           if (size < 1024)
                   len = snprintf(szStr, sizeof szStr, "\t\t* BUCKET %uB size, %u active, %u inactive\n", 
                                   size, act, inact);
           else if (size < 1048576)
                   len = snprintf(szStr, sizeof szStr, "\t\t* BUCKET %uKB size, %u active, %u inactive\n", 
                                   size / 1024, act, inact);
           else
                   len = snprintf(szStr, sizeof szStr, "\t\t* BUCKET %uMB size, %u active, %u inactive\n", 
                                   size / 1048576, act, inact);
   
           strlcat(str, szStr, datlen);
           return len;
   }
   
 /*  /*
  * mpool_dump() - Dump elwix memory pool statistics   * mpool_dump() - Dump elwix memory pool statistics
  *   *
Line 755  mpool_dump(mpool_t * __restrict mp, const char *fmt, . Line 812  mpool_dump(mpool_t * __restrict mp, const char *fmt, .
                 printf("\n%s(%d)\n", __func__, __LINE__);                  printf("\n%s(%d)\n", __func__, __LINE__);
   
         printf("------------------------------------------------------------\n");          printf("------------------------------------------------------------\n");
        printf( " ELWIX memory pool ::\n"        printf( " ELWIX memory pool %p ::\n"
                 "\t- quotas Current/Real/Max = %lu/%lu/%lu\n"                  "\t- quotas Current/Real/Max = %lu/%lu/%lu\n"
                 "\t- calls Alloc/Free/Cache = %lu/%lu/%lu\n"                  "\t- calls Alloc/Free/Cache = %lu/%lu/%lu\n"
                 "\t- bytes Alloc/Free/Cache = %lu/%lu/%lu\n"                  "\t- bytes Alloc/Free/Cache = %lu/%lu/%lu\n"
                "\t- buckets :\n",                 "\t- buckets :\n", mp, 
                 p->pool_quota.curr, p->pool_quota.real, p->pool_quota.max,                   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_calls.alloc, p->pool_calls.free, p->pool_calls.cache, 
                 p->pool_bytes.alloc, p->pool_bytes.free, p->pool_bytes.cache);                  p->pool_bytes.alloc, p->pool_bytes.free, p->pool_bytes.cache);
   
        mpool_statistics(p, xdump_show);        mpool_statistics(p, xdump_show, NULL, 0);
         printf("------------------------------------------------------------\n");          printf("------------------------------------------------------------\n");
 }  }
   
   /*
    * mpool_dump2() - Dump elwix memory pool statistics to string
    *
    * @mp = memory pool, if =NULL dump elwix default memory pool
    * @str = string buffer
    * @strlen = string buffer length
    * return: >0 data in string buffer
    */
   int
   mpool_dump2(mpool_t * __restrict mp, char *str, int strlen)
   {
           int len;
           mpool_t *p = mp ? mp : elwix_mpool;
   
           len = snprintf(str, strlen, 
                           "------------------------------------------------------------\n");
           len += snprintf(str + len, strlen - len, " ELWIX memory pool %p ::\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", mp, 
                   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);
           len += mpool_statistics(p, xdump_show2, str + len, strlen - len);
           len += snprintf(str + len, strlen - len, 
                           "------------------------------------------------------------\n");
   
           return len;
   }
Removed from v.1.7  
changed lines
  Added in v.1.11

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