Changeset 364

Timestamp:

Mar 30, 2006 3:56:01 PM (19 years ago)

Author:

bennylp

Message:

Added ability to have custom pool backend (needed for pool debugging facility)

Location:

pjproject/trunk/pjlib

Files:

• include/pj/config.h (modified) (3 diffs)
• include/pj/pool.h (modified) (3 diffs)
• include/pj/pool_alt.h (added)
• src/pj/config.c (modified) (2 diffs)
• src/pj/pool.c (modified) (2 diffs)
• src/pj/pool_caching.c (modified) (9 diffs)
• src/pj/pool_dbg.c (added)
• src/pj/pool_policy_malloc.c (modified) (2 diffs)

pjproject/trunk/pjlib/include/pj/config.h

@@ -209 +209 @@
 #endif
 
-/**
- * Pool debugging.
+
+/**
+ * If pool debugging is used, then each memory allocation from the pool
+ * will call malloc(), and pool will release all memory chunks when it
+ * is destroyed. This works better when memory verification programs
+ * such as Rational Purify is used.
  *
  * Default: 0
@@ -217 +221 @@
 #  define PJ_POOL_DEBUG             0
 #endif
+
+
+/**
+ * Do we have alternate pool implementation?
+ *
+ * Default: 0
+ */
+#ifndef PJ_HAS_POOL_ALT_API
+#   define PJ_HAS_POOL_ALT_API      PJ_POOL_DEBUG
+#endif
+
 
 /**
@@ -261 +276 @@
 #   endif
 #endif
+
+
+/**
+ * If PJ_IOQUEUE_HAS_SAFE_UNREG macro is defined, then ioqueue will do more
+ * things to ensure thread safety of handle unregistration operation by
+ * employing reference counter to each handle.
+ *
+ * In addition, the ioqueue will preallocate memory for the handles, 
+ * according to the maximum number of handles that is specified during 
+ * ioqueue creation.
+ *
+ * All applications would normally want this enabled, but you may disable
+ * this if:
+ *  - there is no dynamic unregistration to all ioqueues.
+ *  - there is no threading, or there is no preemptive multitasking.
+ *
+ * Default: 1
+ */
+#ifndef PJ_IOQUEUE_HAS_SAFE_UNREG
+#   define PJ_IOQUEUE_HAS_SAFE_UNREG    1
+#endif
+
+
+/**
+ * When safe unregistration (PJ_IOQUEUE_HAS_SAFE_UNREG) is configured in
+ * ioqueue, the PJ_IOQUEUE_KEY_FREE_DELAY macro specifies how long the
+ * ioqueue key is kept in closing state before it can be reused.
+ *
+ * The value is in miliseconds.
+ *
+ * Default: 500 msec.
+ */
+#ifndef PJ_IOQUEUE_KEY_FREE_DELAY
+#   define PJ_IOQUEUE_KEY_FREE_DELAY    500
+#endif
+
 
 /**

pjproject/trunk/pjlib/include/pj/pool.h

@@ -17 +17 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
  */
+
+#include <pj/list.h>
+
+/* See if we use pool's alternate API.
+ * The alternate API is used e.g. to implement pool debugging.
+ */
+#if PJ_HAS_POOL_ALT_API
+#  include <pj/pool_alt.h>
+#endif
+
+
 #ifndef __PJ_POOL_H__
 #define __PJ_POOL_H__
@@ -24 +35 @@
  * @brief Memory Pool.
  */
-
-#include <pj/list.h>
 
 PJ_BEGIN_DECL
@@ -475 +484 @@
 
 /**
+ * Dump pool factory state.
+ * @param pf        The pool factory.
+ * @param detail    Detail state required.
+ */
+PJ_INLINE(void) pj_pool_factory_dump( pj_pool_factory *pf,
+                                      pj_bool_t detail )
+{
+    (*pf->dump_status)(pf, detail);
+}
+
+/**
  *  @}  // PJ_POOL_FACTORY
  */

pjproject/trunk/pjlib/src/pj/config.c

@@ -22 +22 @@
 
 static const char *id = "config.c";
-const char *PJ_VERSION = "0.5.4.1";
+const char *PJ_VERSION = "0.5.4.5";
 
 PJ_DEF(void) pj_dump_config(void)
@@ -44 +44 @@
     PJ_LOG(3, (id, " PJ_LOG_USE_STACK_BUFFER   : %d", PJ_LOG_USE_STACK_BUFFER));
     PJ_LOG(3, (id, " PJ_POOL_DEBUG             : %d", PJ_POOL_DEBUG));
+    PJ_LOG(3, (id, " PJ_HAS_POOL_ALT_API       : %d", PJ_HAS_POOL_ALT_API));
     PJ_LOG(3, (id, " PJ_HAS_TCP                : %d", PJ_HAS_TCP));
     PJ_LOG(3, (id, " PJ_MAX_HOSTNAME           : %d", PJ_MAX_HOSTNAME));
     PJ_LOG(3, (id, " ioqueue type              : %s", pj_ioqueue_name()));
     PJ_LOG(3, (id, " PJ_IOQUEUE_MAX_HANDLES    : %d", PJ_IOQUEUE_MAX_HANDLES));
+    PJ_LOG(3, (id, " PJ_IOQUEUE_HAS_SAFE_UNREG : %d", PJ_IOQUEUE_HAS_SAFE_UNREG));
     PJ_LOG(3, (id, " PJ_HAS_THREADS            : %d", PJ_HAS_THREADS));
     PJ_LOG(3, (id, " PJ_LOG_USE_STACK_BUFFER   : %d", PJ_LOG_USE_STACK_BUFFER));

pjproject/trunk/pjlib/src/pj/pool.c

@@ -23 +23 @@
 #include <pj/os.h>
 
+#if !PJ_HAS_POOL_ALT_API
+
+
 /* Include inline definitions when inlining is disabled. */
 #if !PJ_FUNCTIONS_ARE_INLINED
@@ -262 +265 @@
 
 
+#endif  /* PJ_HAS_POOL_ALT_API */
+

pjproject/trunk/pjlib/src/pj/pool_caching.c

@@ -23 +23 @@
 #include <pj/os.h>
 
+#if !PJ_HAS_POOL_ALT_API
+
 static pj_pool_t* cpool_create_pool(pj_pool_factory *pf, 
                                     const char *name,
@@ -164 +166 @@
 {
     pj_caching_pool *cp = (pj_caching_pool*)pf;
+    unsigned pool_capacity;
     int i;
 
@@ -175 +178 @@
     /* Decrement used count. */
     --cp->used_count;
+
+    pool_capacity = pj_pool_get_capacity(pool);
 
     /* Destroy the pool if the size is greater than our size or if the total
@@ -180 +185 @@
      * maximum capacity.
    . */
-    if (pool->capacity > pool_sizes[PJ_CACHING_POOL_ARRAY_SIZE-1] ||
-        cp->capacity + pool->capacity > cp->max_capacity)
+    if (pool_capacity > pool_sizes[PJ_CACHING_POOL_ARRAY_SIZE-1] ||
+        cp->capacity + pool_capacity > cp->max_capacity)
     {
         pj_pool_destroy_int(pool);
@@ -190 +195 @@
     /* Reset pool. */
     PJ_LOG(6, (pool->obj_name, "recycle(): cap=%d, used=%d(%d%%)", 
-               pool->capacity, pj_pool_get_used_size(pool), 
-               pj_pool_get_used_size(pool)*100/pool->capacity));
+               pool_capacity, pj_pool_get_used_size(pool), 
+               pj_pool_get_used_size(pool)*100/pool_capacity));
     pj_pool_reset(pool);
 
@@ -197 +202 @@
      * Otherwise put the pool in our recycle list.
      */
-    for (i=0; i < PJ_CACHING_POOL_ARRAY_SIZE && pool_sizes[i] != pool->capacity; ++i)
+    for (i=0; i < PJ_CACHING_POOL_ARRAY_SIZE && pool_sizes[i] != pool_capacity; ++i)
         ;
 
@@ -209 +214 @@
 
     pj_list_insert_after(&cp->free_list[i], pool);
-    cp->capacity += pool->capacity;
+    cp->capacity += pool_capacity;
 
     pj_mutex_unlock(cp->mutex);
@@ -229 +234 @@
         PJ_LOG(3,("cachpool", "  Dumping all active pools:"));
         while (pool != (void*)&cp->used_list) {
-            PJ_LOG(3,("cachpool", "   %12s: %8d of %8d (%d%%) used", pool->obj_name, 
-                                  pj_pool_get_used_size(pool), pool->capacity,
-                                  pj_pool_get_used_size(pool)*100/pool->capacity));
+            unsigned pool_capacity = pj_pool_get_capacity(pool);
+            PJ_LOG(3,("cachpool", "   %12s: %8d of %8d (%d%%) used", 
+                                  pj_pool_getobjname(pool), 
+                                  pj_pool_get_used_size(pool), 
+                                  pool_capacity,
+                                  pj_pool_get_used_size(pool)*100/pool_capacity));
             total_used += pj_pool_get_used_size(pool);
-            total_capacity += pool->capacity;
+            total_capacity += pool_capacity;
             pool = pool->next;
         }
@@ -247 +255 @@
 #endif
 }
+
+#endif  /* PJ_HAS_POOL_ALT_API */
+

pjproject/trunk/pjlib/src/pj/pool_policy_malloc.c

@@ -21 +21 @@
 #include <pj/os.h>
 #include <pj/compat/malloc.h>
+
+#if !PJ_HAS_POOL_ALT_API
 
 /*
@@ -61 +63 @@
     0
 };
+
+#endif  /* PJ_HAS_POOL_ALT_API */