r12337@catbus: nickm | 2007-04-10 17:55:26 -0400

 Add support for using memory pools to allocate queued cell; pass --disable-cell-pool to configure to disable this.

svn:r9939

diff --git a/configure.in b/configure.in
index f0aebe0ea3c0f7391c29bb3a6b308704a32bed90..63d76eafc580c13b2e6dd5314b045724dfcb29f7 100644 (file)
--- a/configure.in
+++ b/configure.in
@@ -19,6 +19,14 @@ AC_ARG_ENABLE(debug,
     CFLAGS="$CFLAGS -g"
 fi])
 
+AC_ARG_ENABLE(cell-pool,
+     AS_HELP_STRING(--disable-cell-pool, disable pool allocator for cells))
+
+if test x$enable_cell_pool != xno; then
+  AC_DEFINE(ENABLE_CELL_POOL, 1,
+            [Defined if we try to use the pool allocator for queued cells])
+fi
+
 AC_ARG_ENABLE(transparent,
      AS_HELP_STRING(--disable-transparent, disable transparent proxy support),
      [case "${enableval}" in

diff --git a/src/common/mempool.c b/src/common/mempool.c
index 853c2b371aba4b27e546a773d3b914dfd3386489..39bcbfc705eedcaf780f1424e530229ffe89041c 100644 (file)
--- a/src/common/mempool.c
+++ b/src/common/mempool.c
@@ -7,6 +7,10 @@
 #define MEMPOOL_PRIVATE
 #include "mempool.h"
 
+/* OVERVIEW:
+ *   DOCDOC
+ */
+
 /* DRAWBACKS:
  *   - Not even slightly threadsafe.
  *   - Likes to have lots of items per chunks.
@@ -17,6 +21,7 @@
  *     if you need doubles.
  *   - Could probably be optimized a bit; the representation contains
  *     a bit more info than it really needs to have.
+ *   - probably, chunks should always be a power of 2.
  */
 
 /* NOTES:

diff --git a/src/or/main.c b/src/or/main.c
index 77d8db1e3a771cba9911824005291dfd805bec06..9a063fb09fe72480e036a12878d9bc0a7780ff79 100644 (file)
--- a/src/or/main.c
+++ b/src/or/main.c
@@ -1229,6 +1229,9 @@ do_main_loop(void)
     }
   }
 
+  /* DOCDOC */
+  init_cell_pool();
+
   /* Set up our buckets */
   connection_bucket_init();
   stats_prev_global_read_bucket = global_read_bucket;
@@ -1665,6 +1668,7 @@ tor_free_all(int postfork)
     config_free_all();
     router_free_all();
   }
+  free_cell_pool();
   tor_tls_free_all();
   /* stuff in main.c */
   smartlist_free(closeable_connection_lst);

diff --git a/src/or/or.h b/src/or/or.h
index cca9c96e077313cad0b666277166115087760c2d..048e6793c5f883315103e928b39552c3f2a13386 100644 (file)
--- a/src/or/or.h
+++ b/src/or/or.h
@@ -2667,6 +2667,9 @@ extern uint64_t stats_n_data_bytes_packaged;
 extern uint64_t stats_n_data_cells_received;
 extern uint64_t stats_n_data_bytes_received;
 
+void init_cell_pool(void);
+void free_cell_pool(void);
+
 void cell_queue_clear(cell_queue_t *queue);
 void cell_queue_append(cell_queue_t *queue, packed_cell_t *cell);
 void cell_queue_append_packed_copy(cell_queue_t *queue, const cell_t *cell);

diff --git a/src/or/relay.c b/src/or/relay.c
index 4cc0635314aa4dc8c98598da3fadc209f695bc1c..4fd6648116a104ba2cf23fca58b57bfc909102dc 100644 (file)
--- a/src/or/relay.c
+++ b/src/or/relay.c
@@ -13,6 +13,7 @@ const char relay_c_id[] =
  **/
 
 #include "or.h"
+#include "../common/mempool.h"
 
 static int relay_crypt(circuit_t *circ, cell_t *cell, int cell_direction,
                 crypt_path_t **layer_hint, char *recognized);
@@ -1477,18 +1478,67 @@ circuit_consider_sending_sendme(circuit_t *circ, crypt_path_t *layer_hint)
 #define assert_active_circuits_ok_paranoid(conn)
 #endif
 
+#ifdef ENABLE_CELL_POOL
+static mp_pool_t *cell_pool;
+/* DOCDOC */
+void
+init_cell_pool(void)
+{
+  tor_assert(!cell_pool);
+  cell_pool = mp_pool_new(sizeof(packed_cell_t), 64);
+}
+
+/* DOCDOC */
+void
+free_cell_pool(void)
+{
+  tor_assert(cell_pool);
+  mp_pool_destroy(cell_pool);
+  cell_pool = NULL;
+}
+
 /** Release storage held by <b>cell</b> */
+static INLINE void
+packed_cell_free(packed_cell_t *cell)
+{
+  mp_pool_release(cell);
+}
+
+/* DOCDOC */
+static INLINE packed_cell_t*
+packed_cell_alloc(void)
+{
+  return mp_pool_get(cell_pool);
+}
+#else
+void
+init_cell_pool(void)
+{
+}
+
+void
+free_cell_pool(void)
+{
+}
+
 static INLINE void
 packed_cell_free(packed_cell_t *cell)
 {
   tor_free(cell);
 }
 
+static INLINE packed_cell_t *
+packed_cell_alloc(void)
+{
+  return tor_malloc(sizeof(packed_cell_t));
+}
+#endif
+
 /** Allocate a new copy of packed <b>cell</b>. */
 static INLINE packed_cell_t *
 packed_cell_copy(const cell_t *cell)
 {
-  packed_cell_t *c = tor_malloc(sizeof(packed_cell_t));
+  packed_cell_t *c = packed_cell_alloc();
   cell_pack(c, cell);
   c->next = NULL;
   return c;