prefix all mpool functions with nobug_
authorChristian Thaeter <ct@pipapo.org>
Tue, 11 May 2010 22:12:54 +0000 (00:12 +0200)
committerChristian Thaeter <ct@pipapo.org>
Tue, 11 May 2010 22:12:54 +0000 (00:12 +0200)
also bump library version

Makefile.am
src/mpool.c
src/mpool.h
src/nobug_resources.c

index ad6c579..b96c893 100644 (file)
@@ -24,7 +24,7 @@ ACLOCAL_AMFLAGS = -I m4
 
 AM_CFLAGS = -D_GNU_SOURCE -std=gnu99 -Wall -Wextra -Werror
 
-libnobug_version = 1:0:0
+libnobug_version = 2:0:0
 
 CLEANFILES =
 EXTRA_DIST =
index 110f066..8d7d6ba 100644 (file)
 #include "mpool.h"
 
 #if UINTPTR_MAX > 4294967295U   /* 64 bit */
-#define MPOOL_DIV_SHIFT 6
-#define MPOOL_C(c) c ## ULL
+#define NOBUG_MPOOL_DIV_SHIFT 6
+#define NOBUG_MPOOL_C(c) c ## ULL
 #else                           /* 32 bit */
-#define MPOOL_DIV_SHIFT 5
-#define MPOOL_C(c) c ## UL
+#define NOBUG_MPOOL_DIV_SHIFT 5
+#define NOBUG_MPOOL_C(c) c ## UL
 #endif
 
 /*
   Cluster and node structures are private
 */
 
-typedef struct mpoolcluster_struct mpoolcluster;
-typedef mpoolcluster* MPoolcluster;
-typedef const mpoolcluster* const_MPoolcluster;
+typedef struct nobug_mpoolcluster_struct nobug_mpoolcluster;
+typedef nobug_mpoolcluster* NobugMPoolcluster;
+typedef const nobug_mpoolcluster* const_NobugMPoolcluster;
 
-struct mpoolcluster_struct
+struct nobug_mpoolcluster_struct
 {
   llist node;           /* all clusters */
   char data[];          /* bitmap and elements */
 };
 
 
-typedef struct mpoolnode_struct mpoolnode;
-typedef mpoolnode* MPoolnode;
-typedef const mpoolnode* const_MPoolnode;
+typedef struct nobug_mpoolnode_struct nobug_mpoolnode;
+typedef nobug_mpoolnode* NobugMPoolnode;
+typedef const nobug_mpoolnode* const_NobugMPoolnode;
 
-struct mpoolnode_struct
+struct nobug_mpoolnode_struct
 {
   llist node;
 };
 
 
-MPool
-mpool_cluster_alloc_ (MPool self);
+NobugMPool
+nobug_mpool_cluster_alloc_ (NobugMPool self);
 
 
-#define MPOOL_BITMAP_SIZE(elements_per_cluster)                 \
+#define NOBUG_MPOOL_BITMAP_SIZE(elements_per_cluster)                 \
   (((elements_per_cluster) + sizeof(uintptr_t)*CHAR_BIT - 1)    \
   / (sizeof(uintptr_t) * CHAR_BIT) * sizeof (uintptr_t))
 
-MPool
-mpool_init (MPool self, size_t elem_size, unsigned elements_per_cluster, mpool_destroy_fn dtor)
+NobugMPool
+nobug_mpool_init (NobugMPool self, size_t elem_size, unsigned elements_per_cluster, nobug_mpool_destroy_fn dtor)
 {
   if (self)
     {
@@ -86,8 +86,8 @@ mpool_init (MPool self, size_t elem_size, unsigned elements_per_cluster, mpool_d
 
       self->elements_per_cluster = elements_per_cluster;
 
-      self->cluster_size = sizeof (mpoolcluster) +              /* header */
-        MPOOL_BITMAP_SIZE (self->elements_per_cluster) +        /* bitmap */
+      self->cluster_size = sizeof (nobug_mpoolcluster) +        /* header */
+        NOBUG_MPOOL_BITMAP_SIZE (self->elements_per_cluster) +  /* bitmap */
         self->elem_size * self->elements_per_cluster;           /* elements */
 
       self->elements_free = 0;
@@ -100,28 +100,28 @@ mpool_init (MPool self, size_t elem_size, unsigned elements_per_cluster, mpool_d
 
 
 static inline void*
-cluster_element_get (MPoolcluster cluster, MPool self, unsigned n)
+cluster_element_get (NobugMPoolcluster cluster, NobugMPool self, unsigned n)
 {
   return (void*)cluster +                                       /* start address */
     sizeof (*cluster) +                                         /* header */
-    MPOOL_BITMAP_SIZE (self->elements_per_cluster) +            /* bitmap */
+    NOBUG_MPOOL_BITMAP_SIZE (self->elements_per_cluster) +      /* bitmap */
     self->elem_size * n;                                        /* offset*/
 }
 
 
 static inline bool
-bitmap_bit_get_nth (MPoolcluster cluster, unsigned index)
+bitmap_bit_get_nth (NobugMPoolcluster cluster, unsigned index)
 {
-  uintptr_t quot = index>>MPOOL_DIV_SHIFT;
-  uintptr_t rem = index & ~((~MPOOL_C(0))<<MPOOL_DIV_SHIFT);
+  uintptr_t quot = index>>NOBUG_MPOOL_DIV_SHIFT;
+  uintptr_t rem = index & ~((~NOBUG_MPOOL_C(0))<<NOBUG_MPOOL_DIV_SHIFT);
   uintptr_t* bitmap = (uintptr_t*)&cluster->data;
 
   return bitmap[quot] & ((uintptr_t)1<<rem);
 }
 
 
-MPool
-mpool_destroy (MPool self)
+NobugMPool
+nobug_mpool_destroy (NobugMPool self)
 {
   if (self)
     {
@@ -130,9 +130,9 @@ mpool_destroy (MPool self)
           if (self->destroy)
             for (unsigned i = 0; i < self->elements_per_cluster; ++i)
               {
-                if (bitmap_bit_get_nth ((MPoolcluster)cluster, i))
+                if (bitmap_bit_get_nth ((NobugMPoolcluster)cluster, i))
                   {
-                    void* obj = cluster_element_get ((MPoolcluster)cluster, self, i);
+                    void* obj = cluster_element_get ((NobugMPoolcluster)cluster, self, i);
                     self->destroy (obj);
                   }
               }
@@ -151,21 +151,21 @@ mpool_destroy (MPool self)
 
 
 
-MPool
-mpool_cluster_alloc_ (MPool self)
+NobugMPool
+nobug_mpool_cluster_alloc_ (NobugMPool self)
 {
-  MPoolcluster cluster = malloc (self->cluster_size);
+  NobugMPoolcluster cluster = malloc (self->cluster_size);
 
   if (!cluster)
     return NULL;
 
   /* clear the bitmap */
-  memset (&cluster->data, 0, MPOOL_BITMAP_SIZE (self->elements_per_cluster));
+  memset (&cluster->data, 0, NOBUG_MPOOL_BITMAP_SIZE (self->elements_per_cluster));
 
   /* initialize freelist */
   for (unsigned i = 0; i < self->elements_per_cluster; ++i)
     {
-      MPoolnode node = cluster_element_get (cluster, self, i);
+      NobugMPoolnode node = cluster_element_get (cluster, self, i);
       llist_insert_tail (&self->freelist, llist_init (&node->node));
     }
 
@@ -190,10 +190,10 @@ cmp_cluster_contains_element (const_LList cluster, const_LList element, void* cl
 }
 
 
-static inline MPoolcluster
-element_cluster_get (MPool self, void* element)
+static inline NobugMPoolcluster
+element_cluster_get (NobugMPool self, void* element)
 {
-  return (MPoolcluster) llist_ufind (&self->clusters, (const_LList) element, cmp_cluster_contains_element, (void*)self->cluster_size);
+  return (NobugMPoolcluster) llist_ufind (&self->clusters, (const_LList) element, cmp_cluster_contains_element, (void*)self->cluster_size);
 }
 
 
@@ -201,7 +201,7 @@ static inline unsigned
 uintptr_nearestbit (uintptr_t v, unsigned n)
 {
   unsigned r = 0;
-  uintptr_t mask = MPOOL_C(1)<<n;
+  uintptr_t mask = NOBUG_MPOOL_C(1)<<n;
 
   while (1)
     {
@@ -212,7 +212,7 @@ uintptr_nearestbit (uintptr_t v, unsigned n)
           else
             return n+r;
         }
-      if (mask == ~MPOOL_C(0))
+      if (mask == ~NOBUG_MPOOL_C(0))
         return ~0U;
       ++r;
       mask |= ((mask<<1)|(mask>>1));
@@ -221,16 +221,16 @@ uintptr_nearestbit (uintptr_t v, unsigned n)
 
 
 static inline void*
-alloc_near (MPoolcluster cluster, MPool self, void* locality)
+alloc_near (NobugMPoolcluster cluster, NobugMPool self, void* locality)
 {
   void* begin_of_elements =
     (void*)cluster +
     sizeof (*cluster) +                                                 /* header */
-    MPOOL_BITMAP_SIZE (((MPool)self)->elements_per_cluster);            /* bitmap */
+    NOBUG_MPOOL_BITMAP_SIZE (((NobugMPool)self)->elements_per_cluster); /* bitmap */
 
   uintptr_t index = (locality - begin_of_elements) / self->elem_size;
-  uintptr_t quot = index>>MPOOL_DIV_SHIFT;
-  uintptr_t rem = index & ~((~MPOOL_C(0))<<MPOOL_DIV_SHIFT);
+  uintptr_t quot = index>>NOBUG_MPOOL_DIV_SHIFT;
+  uintptr_t rem = index & ~((~NOBUG_MPOOL_C(0))<<NOBUG_MPOOL_DIV_SHIFT);
 
   uintptr_t* bitmap = (uintptr_t*)&cluster->data;
   unsigned r = ~0U;
@@ -257,16 +257,16 @@ alloc_near (MPoolcluster cluster, MPool self, void* locality)
 
 
 static inline void
-bitmap_set_element (MPoolcluster cluster, MPool self, void* element)
+bitmap_set_element (NobugMPoolcluster cluster, NobugMPool self, void* element)
 {
   void* begin_of_elements =
     (void*)cluster +
     sizeof (*cluster) +                                                 /* header */
-    MPOOL_BITMAP_SIZE (((MPool)self)->elements_per_cluster);            /* bitmap */
+    NOBUG_MPOOL_BITMAP_SIZE (((NobugMPool)self)->elements_per_cluster); /* bitmap */
 
   uintptr_t index = (element - begin_of_elements) / self->elem_size;
-  uintptr_t quot = index>>MPOOL_DIV_SHIFT;
-  uintptr_t rem = index & ~((~MPOOL_C(0))<<MPOOL_DIV_SHIFT);
+  uintptr_t quot = index>>NOBUG_MPOOL_DIV_SHIFT;
+  uintptr_t rem = index & ~((~NOBUG_MPOOL_C(0))<<NOBUG_MPOOL_DIV_SHIFT);
 
   uintptr_t* bitmap = (uintptr_t*)&cluster->data;
   bitmap[quot] |= ((uintptr_t)1<<rem);
@@ -274,16 +274,16 @@ bitmap_set_element (MPoolcluster cluster, MPool self, void* element)
 
 
 static inline void
-bitmap_clear_element (MPoolcluster cluster, MPool self, void* element)
+bitmap_clear_element (NobugMPoolcluster cluster, NobugMPool self, void* element)
 {
   void* begin_of_elements =
     (void*)cluster +
     sizeof (*cluster) +                                                 /* header */
-    MPOOL_BITMAP_SIZE (((MPool)self)->elements_per_cluster);            /* bitmap */
+    NOBUG_MPOOL_BITMAP_SIZE (((NobugMPool)self)->elements_per_cluster); /* bitmap */
 
   uintptr_t index = (element - begin_of_elements) / self->elem_size;
-  uintptr_t quot = index>>MPOOL_DIV_SHIFT;
-  uintptr_t rem = index & ~((~MPOOL_C(0))<<MPOOL_DIV_SHIFT);
+  uintptr_t quot = index>>NOBUG_MPOOL_DIV_SHIFT;
+  uintptr_t rem = index & ~((~NOBUG_MPOOL_C(0))<<NOBUG_MPOOL_DIV_SHIFT);
 
   uintptr_t* bitmap = (uintptr_t*)&cluster->data;
   bitmap[quot] &= ~((uintptr_t)1<<rem);
@@ -291,11 +291,11 @@ bitmap_clear_element (MPoolcluster cluster, MPool self, void* element)
 
 
 void*
-mpool_alloc (MPool self)
+nobug_mpool_alloc (NobugMPool self)
 {
   if (!self->elements_free)
     {
-      if (mpool_cluster_alloc_ (self))
+      if (nobug_mpool_cluster_alloc_ (self))
         self->locality = NULL; /* supress alloc_near() */
       else
         return NULL;
@@ -323,11 +323,11 @@ mpool_alloc (MPool self)
 
 
 void*
-mpool_alloc_near (MPool self, void* near)
+nobug_mpool_alloc_near (NobugMPool self, void* near)
 {
   if (!self->elements_free)
     {
-      if (mpool_cluster_alloc_ (self))
+      if (nobug_mpool_cluster_alloc_ (self))
         near = NULL; /* supress alloc_near() */
       else
         return NULL;
@@ -353,17 +353,17 @@ mpool_alloc_near (MPool self, void* near)
 }
 
 
-static inline MPoolnode
-find_near (MPoolcluster cluster, MPool self, void* element)
+static inline NobugMPoolnode
+find_near (NobugMPoolcluster cluster, NobugMPool self, void* element)
 {
   void* begin_of_elements =
     (void*)cluster +
     sizeof (*cluster) +                                                 /* header */
-    MPOOL_BITMAP_SIZE (((MPool)self)->elements_per_cluster);            /* bitmap */
+    NOBUG_MPOOL_BITMAP_SIZE (((NobugMPool)self)->elements_per_cluster); /* bitmap */
 
   uintptr_t index = (element - begin_of_elements) / self->elem_size;
-  uintptr_t quot = index>>MPOOL_DIV_SHIFT;
-  uintptr_t rem = index & ~((~MPOOL_C(0))<<MPOOL_DIV_SHIFT);
+  uintptr_t quot = index>>NOBUG_MPOOL_DIV_SHIFT;
+  uintptr_t rem = index & ~((~NOBUG_MPOOL_C(0))<<NOBUG_MPOOL_DIV_SHIFT);
 
   uintptr_t* bitmap = (uintptr_t*)&cluster->data;
   unsigned r = ~0U;
@@ -394,25 +394,25 @@ find_near (MPoolcluster cluster, MPool self, void* element)
 
 
 void
-mpool_free (MPool self, void* element)
+nobug_mpool_free (NobugMPool self, void* element)
 {
   if (self && element)
     {
-      MPoolcluster cluster = element_cluster_get (self,element);
-      MPoolnode near = find_near (cluster, self, element);
+      NobugMPoolcluster cluster = element_cluster_get (self,element);
+      NobugMPoolnode near = find_near (cluster, self, element);
 
       bitmap_clear_element (cluster, self, element);
-      llist_init (&((MPoolnode)element)->node);
+      llist_init (&((NobugMPoolnode)element)->node);
 
       if (near)
         {
-          if (near < (MPoolnode)element)
-            llist_insert_next (&near->node, &((MPoolnode)element)->node);
+          if (near < (NobugMPoolnode)element)
+            llist_insert_next (&near->node, &((NobugMPoolnode)element)->node);
           else
-            llist_insert_prev (&near->node, &((MPoolnode)element)->node);
+            llist_insert_prev (&near->node, &((NobugMPoolnode)element)->node);
         }
       else
-        llist_insert_tail (&self->freelist, &((MPoolnode)element)->node);
+        llist_insert_tail (&self->freelist, &((NobugMPoolnode)element)->node);
 
       ++self->elements_free;
     }
@@ -420,12 +420,12 @@ mpool_free (MPool self, void* element)
 
 
 
-MPool
-mpool_reserve (MPool self, unsigned nelements)
+NobugMPool
+nobug_mpool_reserve (NobugMPool self, unsigned nelements)
 {
   if (self)
     while (self->elements_free < nelements)
-      if (!mpool_cluster_alloc_ (self))
+      if (!nobug_mpool_cluster_alloc_ (self))
         return NULL;
 
   return self;
index e8f38e4..ffe9a72 100644 (file)
@@ -51,7 +51,7 @@
 //mpool         element to be destroyed
 //mpool
 */
-typedef void (*mpool_destroy_fn)(void* self);
+typedef void (*nobug_mpool_destroy_fn)(void* self);
 
 
 /*
@@ -64,11 +64,11 @@ typedef void (*mpool_destroy_fn)(void* self);
 //mpool
 //mpool This structure should be considered opaque.
 */
-typedef struct mpool_struct mpool;
-typedef mpool* MPool;
-typedef const mpool* const_MPool;
+typedef struct nobug_mpool_struct nobug_mpool;
+typedef nobug_mpool* NobugMPool;
+typedef const nobug_mpool* const_NobugMPool;
 
-struct mpool_struct
+struct nobug_mpool_struct
 {
   llist freelist;
   llist clusters;
@@ -77,7 +77,7 @@ struct mpool_struct
   uintptr_t cluster_size;
   unsigned elements_free;               /* a counter of free elements is the price we pay to support a reserve() operation */
   void* locality;
-  mpool_destroy_fn destroy;
+  nobug_mpool_destroy_fn destroy;
 };
 
 
@@ -103,8 +103,8 @@ struct mpool_struct
 //mpool         self
 //mpool
 */
-MPool
-mpool_init (MPool self, size_t elem_size, unsigned elements_per_cluster, mpool_destroy_fn dtor);
+NobugMPool
+nobug_mpool_init (NobugMPool self, size_t elem_size, unsigned elements_per_cluster, nobug_mpool_destroy_fn dtor);
 
 
 /*
@@ -126,8 +126,8 @@ mpool_init (MPool self, size_t elem_size, unsigned elements_per_cluster, mpool_d
 //mpool
 //mpool
 */
-MPool
-mpool_destroy (MPool self);
+NobugMPool
+nobug_mpool_destroy (NobugMPool self);
 
 
 /*
@@ -145,7 +145,7 @@ mpool_destroy (MPool self);
 //mpool
 */
 static inline unsigned
-mpool_available (MPool self)
+nobug_mpool_available (NobugMPool self)
 {
   return self->elements_free;
 }
@@ -167,8 +167,8 @@ mpool_available (MPool self)
 //mpool         self on success or NULL on error
 //mpool
 */
-MPool
-mpool_reserve (MPool self, unsigned nelements);
+NobugMPool
+nobug_mpool_reserve (NobugMPool self, unsigned nelements);
 
 
 /*
@@ -188,7 +188,7 @@ mpool_reserve (MPool self, unsigned nelements);
 //mpool
 */
 void*
-mpool_alloc (MPool self);
+nobug_mpool_alloc (NobugMPool self);
 
 
 /*
@@ -210,7 +210,7 @@ mpool_alloc (MPool self);
 //mpool
 */
 void*
-mpool_alloc_near (MPool self, void* near);
+nobug_mpool_alloc_near (NobugMPool self, void* near);
 
 
 /*
@@ -228,17 +228,9 @@ mpool_alloc_near (MPool self, void* near);
 //mpool
 */
 void
-mpool_free (MPool self, void* element);
+nobug_mpool_free (NobugMPool self, void* element);
 
 
-
-void
-nobug_mpool_dump (const_MPool self,
-                  const int depth,
-                  const char* file,
-                  const int line,
-                  const char* func);
-
 /*
 //      Local Variables:
 //      mode: C
index 58c02f6..9e4dd27 100644 (file)
@@ -78,10 +78,10 @@ const char* nobug_resource_states[] =
 const char* nobug_resource_error = NULL;
 
 static llist nobug_resource_registry;
-static mpool nobug_resource_record_pool;
-static mpool nobug_resource_user_pool;
+static nobug_mpool nobug_resource_record_pool;
+static nobug_mpool nobug_resource_user_pool;
 #if NOBUG_USE_PTHREAD
-static mpool nobug_resource_node_pool;
+static nobug_mpool nobug_resource_node_pool;
 #endif
 
 static void nobug_resource_record_dtor (void*);
@@ -103,18 +103,18 @@ nobug_resource_init (void)
 
   llist_init (&nobug_resource_registry);
 
-  mpool_init (&nobug_resource_record_pool,
+  nobug_mpool_init (&nobug_resource_record_pool,
               sizeof(struct nobug_resource_record),
               NOBUG_RESOURCE_MPOOL_CHUNKSIZE/sizeof(struct nobug_resource_record),
               nobug_resource_record_dtor);
 
-  mpool_init (&nobug_resource_user_pool,
+  nobug_mpool_init (&nobug_resource_user_pool,
               sizeof(struct nobug_resource_user),
               NOBUG_RESOURCE_MPOOL_CHUNKSIZE/sizeof(struct nobug_resource_user),
               nobug_resource_user_dtor);
 
 #if NOBUG_USE_PTHREAD
-  mpool_init (&nobug_resource_node_pool,
+  nobug_mpool_init (&nobug_resource_node_pool,
               sizeof(struct nobug_resource_node),
               NOBUG_RESOURCE_MPOOL_CHUNKSIZE/sizeof(struct nobug_resource_node),
               nobug_resource_node_dtor);
@@ -126,24 +126,24 @@ void
 nobug_resource_destroy (void)
 {
 #if NOBUG_USE_PTHREAD
-  mpool_destroy (&nobug_resource_node_pool);
+  nobug_mpool_destroy (&nobug_resource_node_pool);
 #endif
-  mpool_destroy (&nobug_resource_user_pool);
-  mpool_destroy (&nobug_resource_record_pool);
+  nobug_mpool_destroy (&nobug_resource_user_pool);
+  nobug_mpool_destroy (&nobug_resource_record_pool);
 }
 
 
 unsigned
 nobug_resource_record_available (void)
 {
-  return mpool_available (&nobug_resource_record_pool);
+  return nobug_mpool_available (&nobug_resource_record_pool);
 }
 
 
 unsigned
 nobug_resource_user_available (void)
 {
-  return mpool_available (&nobug_resource_user_pool);
+  return nobug_mpool_available (&nobug_resource_user_pool);
 }
 
 
@@ -151,7 +151,7 @@ nobug_resource_user_available (void)
 unsigned
 nobug_resource_node_available (void)
 {
-  return mpool_available (&nobug_resource_node_pool);
+  return nobug_mpool_available (&nobug_resource_node_pool);
 }
 
 
@@ -163,7 +163,7 @@ nobug_resource_node_free (struct nobug_resource_node* self)
 
   llist_unlink_fast_ (&self->cldnode);
   llist_unlink_fast_ (&self->node);
-  mpool_free (&nobug_resource_node_pool, self);
+  nobug_mpool_free (&nobug_resource_node_pool, self);
 }
 
 
@@ -222,7 +222,7 @@ nobug_resource_announce (const char* type, const char* name, const void* object_
   pthread_mutex_lock (&nobug_resource_mutex);
 #endif
 
-  struct nobug_resource_record* node = mpool_alloc (&nobug_resource_record_pool);
+  struct nobug_resource_record* node = nobug_mpool_alloc (&nobug_resource_record_pool);
   if (!node)
     {
       nobug_resource_error = "internal allocation error";
@@ -280,7 +280,7 @@ nobug_resource_forget (struct nobug_resource_record* self)
 
   nobug_resource_record_dtor (self);
 
-  mpool_free (&nobug_resource_record_pool, self);
+  nobug_mpool_free (&nobug_resource_record_pool, self);
 
 #if NOBUG_USE_PTHREAD
   pthread_mutex_unlock (&nobug_resource_mutex);
@@ -305,7 +305,7 @@ struct nobug_resource_node*
 nobug_resource_node_new (struct nobug_resource_record* resource,
                          struct nobug_resource_node* parent)
 {
-  struct nobug_resource_node* self = mpool_alloc (&nobug_resource_node_pool);
+  struct nobug_resource_node* self = nobug_mpool_alloc (&nobug_resource_node_pool);
   if (self)
     {
       llist_insert_head (&resource->nodes, llist_init (&self->node));
@@ -550,7 +550,7 @@ nobug_resource_enter (struct nobug_resource_record* resource,
   if (nobug_resource_error)
     return NULL;
 
-  struct nobug_resource_user* new_user = mpool_alloc (&nobug_resource_user_pool);
+  struct nobug_resource_user* new_user = nobug_mpool_alloc (&nobug_resource_user_pool);
   if (!new_user)
     {
       nobug_resource_error = "internal allocation error";
@@ -723,7 +723,7 @@ nobug_resource_leave (struct nobug_resource_user* user)
 #endif
 
       llist_unlink_fast_ (&user->hdr.node);
-      mpool_free (&nobug_resource_user_pool, user);
+      nobug_mpool_free (&nobug_resource_user_pool, user);
     }