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

Diff for /libaitsess/src/Attic/mem.c between versions 1.1.2.2 and 1.1.2.6

version 1.1.2.2, 2012/02/27 21:00:43 version 1.1.2.6, 2012/02/28 09:28:00
Line 49  SUCH DAMAGE. Line 49  SUCH DAMAGE.
 /*  /*
  * mpool_init() - Init memory pool   * mpool_init() - Init memory pool
  *   *
    * @maxmem = If !=0 set maximum memory quota
  * return: =NULL error or !=NULL new allocated pool   * return: =NULL error or !=NULL new allocated pool
  */   */
 mpool_t *  mpool_t *
mpool_init(void)mpool_init(u_long maxmem)
 {  {
         mpool_t *mp;          mpool_t *mp;
           register int i;
   
         mp = malloc(sizeof(mpool_t));          mp = malloc(sizeof(mpool_t));
         if (!mp) {          if (!mp) {
Line 64  mpool_init(void) Line 66  mpool_init(void)
                 memset(mp, 0, sizeof(mpool_t));                  memset(mp, 0, sizeof(mpool_t));
   
         pthread_mutex_init(&mp->pool_mtx, NULL);          pthread_mutex_init(&mp->pool_mtx, NULL);
   
           mp->pool_quota.max = maxmem;
   
           mpool_lock(mp);
           for (i = 0; i < MEM_BUCKETS; i++) {
                   TAILQ_INIT(&mp->pool_active[i]);
                   TAILQ_INIT(&mp->pool_inactive[i]);
           }
           mpool_unlock(mp);
   
         return mp;          return mp;
 }  }
   
Line 131  pullInactive(mpool_t * __restrict mp, int idx) Line 143  pullInactive(mpool_t * __restrict mp, int idx)
         /* must be locked pool before use this function */           /* must be locked pool before use this function */ 
         if ((m = TAILQ_FIRST(&mp->pool_inactive[idx]))) {          if ((m = TAILQ_FIRST(&mp->pool_inactive[idx]))) {
                 TAILQ_REMOVE(&mp->pool_inactive[idx], m, alloc_node);                  TAILQ_REMOVE(&mp->pool_inactive[idx], m, alloc_node);
                   /* statistics */
                   mp->pool_calls.cache--;
                   mp->pool_bytes.cache -= mem_size(m);
   
                 /* clear name */                  /* clear name */
                 *m->alloc_name = 0;                  *m->alloc_name = 0;
Line 216  mpool_malloc(mpool_t * __restrict mp, u_int size, cons Line 231  mpool_malloc(mpool_t * __restrict mp, u_int size, cons
 }  }
   
 /*  /*
    * mpool_purge() - Purge memory block cache and release resources
    *
    * @mp = Memory pool
    * @atmost = Free at most in buckets
    * return: -1 error or 0 ok
    */
   int
   mpool_purge(mpool_t * __restrict mp, u_int atmost)
   {
           register int i, cx;
           struct tagAlloc *m, *tmp;
   
           if (!mp) {
                   sess_SetErr(EINVAL, "Pool not specified");
                   return -1;
           }
   
           mpool_lock(mp);
   
           for (i = cx = 0; i < MEM_BUCKETS; cx = 0, i++) {
                   TAILQ_FOREACH_SAFE(m, &mp->pool_inactive[i], alloc_node, tmp) {
                           /* barrier for purge */
                           if (cx < atmost) {
                                   cx++;
                                   continue;
                           }
   
                           TAILQ_REMOVE(&mp->pool_inactive[i], m, alloc_node);
                           /* statistics */
                           mp->pool_calls.cache--;
                           mp->pool_bytes.cache -= mem_size(m);
   
                           mp->pool_calls.free++;
                           mp->pool_bytes.free += mem_size(m);
                           /* quota */
                           mp->pool_quota.curr -= mem_size(m);
   
                           if (m->alloc_mem)
                                   free(m->alloc_mem);
                           free(m);
                   }
           }
   
           mpool_unlock(mp);
           return 0;
   }
   
   /*
  * mpool_free() Free allocated memory with mpool_alloc()   * mpool_free() Free allocated memory with mpool_alloc()
  *   *
  * @mp = Memory pool   * @mp = Memory pool
Line 238  mpool_free(mpool_t * __restrict mp, void * __restrict  Line 301  mpool_free(mpool_t * __restrict mp, void * __restrict 
                 sess_SetErr(EFAULT, "Corrupted memory address");                  sess_SetErr(EFAULT, "Corrupted memory address");
                 return -2;                  return -2;
         } else          } else
                idx = BucketIndex(((u_int*)data)[-2]);                idx = BucketIndex(((u_int*)data)[-2] * sizeof(u_int));
   
         mpool_lock(mp);          mpool_lock(mp);
         TAILQ_FOREACH(m, &mp->pool_active[idx], alloc_node)          TAILQ_FOREACH(m, &mp->pool_active[idx], alloc_node)
                 if (mem_data(m, void*) == data) {                  if (mem_data(m, void*) == data) {
                         TAILQ_REMOVE(&mp->pool_active[idx], m, alloc_node);                          TAILQ_REMOVE(&mp->pool_active[idx], m, alloc_node);
                           /* statistics */
                           mp->pool_calls.alloc--;
                           mp->pool_bytes.alloc -= mem_size(m);
   
                         if (!purge) {                          if (!purge) {
                                 TAILQ_INSERT_HEAD(&mp->pool_inactive[idx], m, alloc_node);                                  TAILQ_INSERT_HEAD(&mp->pool_inactive[idx], m, alloc_node);
Line 251  mpool_free(mpool_t * __restrict mp, void * __restrict  Line 317  mpool_free(mpool_t * __restrict mp, void * __restrict 
                                 mp->pool_calls.cache++;                                  mp->pool_calls.cache++;
                                 mp->pool_bytes.cache += mem_size(m);                                  mp->pool_bytes.cache += mem_size(m);
                         } else {                          } else {
                                 if (m->alloc_mem)  
                                         free(m->alloc_mem);  
                                 free(m);  
                                 /* statistics */                                  /* statistics */
                                 mp->pool_calls.free++;                                  mp->pool_calls.free++;
                                 mp->pool_bytes.free += mem_size(m);                                  mp->pool_bytes.free += mem_size(m);
                                   /* quota */
                                   mp->pool_quota.curr -= mem_size(m);
   
                                   if (m->alloc_mem)
                                           free(m->alloc_mem);
                                   free(m);
                         }                          }
                         break;                          break;
                 }                  }
Line 290  mpool_free2(mpool_t * __restrict mp, u_int size, const Line 359  mpool_free2(mpool_t * __restrict mp, u_int size, const
         TAILQ_FOREACH(m, &mp->pool_active[idx], alloc_node)          TAILQ_FOREACH(m, &mp->pool_active[idx], alloc_node)
                 if (!strcmp(m->alloc_name, memname)) {                  if (!strcmp(m->alloc_name, memname)) {
                         TAILQ_REMOVE(&mp->pool_active[idx], m, alloc_node);                          TAILQ_REMOVE(&mp->pool_active[idx], m, alloc_node);
                           /* statistics */
                           mp->pool_calls.alloc--;
                           mp->pool_bytes.alloc -= mem_size(m);
   
                         if (!purge) {                          if (!purge) {
                                 TAILQ_INSERT_HEAD(&mp->pool_inactive[idx], m, alloc_node);                                  TAILQ_INSERT_HEAD(&mp->pool_inactive[idx], m, alloc_node);
Line 297  mpool_free2(mpool_t * __restrict mp, u_int size, const Line 369  mpool_free2(mpool_t * __restrict mp, u_int size, const
                                 mp->pool_calls.cache++;                                  mp->pool_calls.cache++;
                                 mp->pool_bytes.cache += mem_size(m);                                  mp->pool_bytes.cache += mem_size(m);
                         } else {                          } else {
                                 if (m->alloc_mem)  
                                         free(m->alloc_mem);  
                                 free(m);  
                                 /* statistics */                                  /* statistics */
                                 mp->pool_calls.free++;                                  mp->pool_calls.free++;
                                 mp->pool_bytes.free += mem_size(m);                                  mp->pool_bytes.free += mem_size(m);
                                   /* quota */
                                   mp->pool_quota.curr -= mem_size(m);
   
                                   if (m->alloc_mem)
                                           free(m->alloc_mem);
                                   free(m);
                         }                          }
                         break;                          break;
                 }                  }
Line 334  mpool_getmembynam(mpool_t * __restrict mp, u_int size, Line 409  mpool_getmembynam(mpool_t * __restrict mp, u_int size,
                         break;                          break;
   
         return mem_data(m, void*);          return mem_data(m, void*);
   }
   
   /*
    * mpool_getsizebyaddr() - Get size of allocated memory block by address
    *
    * @addr = allocated memory from mpool_malloc()
    * return: usable size of allocated memory block
    */
   inline u_int
   mpool_getsizebyaddr(void * __restrict data)
   {
           if (mpool_chkaddr(data))
                   return 0;
   
           return (((u_int*) data)[-2] * sizeof(u_int));
   }
   
   /*
    * mpool_chkaddr() - Check validity of given address
    *
    * @data = allocated memory from mpool_malloc()
    * return: -1 bad address, 1 corrupted address or 0 ok
    */
   inline int
   mpool_chkaddr(void * __restrict data)
   {
           /* check address range */
           if (MEM_BADADDR(data))
                   return -1;
           /* check sentinel */
           if (MEM_CORRUPT(data))
                   return 1;
           /* data address is ok! */
           return 0;
   }
   
   /*
    * mpool_setquota() - Change maximum memory quota
    *
    * @mp = Memory pool
    * @maxmem = New max quota size
    * return: old maximum memory quota size
    */
   inline u_long
   mpool_setquota(mpool_t * __restrict mp, u_long maxmem)
   {
           u_long ret;
   
           if (!mp)
                   return 0;
   
           ret = mp->pool_quota.max;
           mp->pool_quota.max = maxmem;
   
           /* if new max quota is less then current allocated memory, 
            *      try to purge memory cache blocks
            */
           if (mp->pool_quota.max < mp->pool_quota.curr)
                   mpool_purge(mp, 0);
   
           return ret;
   }
   
   /* ----------------------------------------------------------- */
   
   /*
    * mpool_statistics() - Dump statistics from memory pool buckets
    *
    * @mp = Memory pool
    * @cb = Export statistics to callback
    * return: none
    */
   void
   mpool_statistics(mpool_t * __restrict mp, mpool_stat_cb cb)
   {
           struct tagAlloc *m;
           register int i, act, inact;
   
           if (!mp || !cb)
                   return;
   
           for (i = act = inact = 0; i < MEM_BUCKETS; act = inact = 0, i++) {
                   TAILQ_FOREACH(m, &mp->pool_active[i], alloc_node)
                           act++;
                   TAILQ_FOREACH(m, &mp->pool_inactive[i], alloc_node)
                           inact++;
   
                   cb(1 << (i + MEM_MIN_BUCKET), act, inact);
           }
 }  }
Removed from v.1.1.2.2  
changed lines
  Added in v.1.1.2.6

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