[lttng-dev] [PATCH 1/6] change default mm type

[Mathieu Desnoyers]

Merged as:

commit c1888f3a47cf8f7c213269888ce42d191de7e34a
Author: Mathieu Desnoyers <mathieu.desnoyers at efficios.com>
Date:   Sun Dec 4 10:40:01 2011 -0500

    rculfhash: default mm type
    
    In the original patch from Lai Jiangshan <laijs at cn.fujitsu.com>:
    
    When I test backend with the following commands.
    (my box is x86_64 with 4 cores/logic cpus)
    **(test with Load factor = 100% only)**
    
    ./tests/test_urcu_hash 4 0 10 -B mmap -h $((1<<19)) -p $((1<<19))
    ./tests/test_urcu_hash 4 0 10 -B mmap -h $((1<<18)) -p $((1<<18))
    ./tests/test_urcu_hash 4 0 10 -B mmap -h $((1<<17)) -p $((1<<17))
    ./tests/test_urcu_hash 4 0 10 -B mmap -h $((1<<16)) -p $((1<<16))
                        4readers/no writer
    
    It shows that mmap backend is about 6% better over order backend.
    (It also shows that chunk backend is (worse than)/(the same as) order
    backend for small/large min_nr_alloc_buckets. (use -m when test)).
    
    Note:
    "6%" and the google-perftools told us the bucket_at() is not the
    critical bottleneck.
    
    new strategy:
    * infinite buckets size                  --> order mm
    * otherwise if 64bits,
       with number of buckets <= (1 << 32)   --> mmap mm
    * otherwise                              --> order mm
    
    Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers at efficios.com>

diff --git a/rculfhash.c b/rculfhash.c
index 6c648f1..5ef2c78 100644
--- a/rculfhash.c
+++ b/rculfhash.c
@@ -1271,6 +1271,36 @@ struct cds_lfht *_cds_lfht_new(unsigned long init_size,
 	if (!init_size || (init_size & (init_size - 1)))
 		return NULL;
 
+	/*
+	 * Memory management plugin default.
+	 */
+	if (!mm) {
+		if (!max_nr_buckets) {
+			/*
+			 * If the maximum number of buckets is not
+			 * specified, we cannot use the mmap allocator,
+			 * so fallback on order allocator.
+			 */
+			mm = &cds_lfht_mm_order;
+		} else if (CAA_BITS_PER_LONG > 32
+				&& max_nr_buckets <= (1ULL << 32)) {
+			/*
+			 * For 64-bit architectures, with max number of
+			 * buckets small enough not to use the entire
+			 * 64-bit memory mapping space (and allowing a
+			 * fair number of hash table instances), use the
+			 * mmap allocator, which is faster than the
+			 * order allocator.
+			 */
+			mm = &cds_lfht_mm_mmap;
+		} else {
+			/*
+			 * The fallback is to use the order allocator.
+			 */
+			mm = &cds_lfht_mm_order;
+		}
+	}
+
 	/* max_nr_buckets == 0 for order based mm means infinite */
 	if (mm == &cds_lfht_mm_order && !max_nr_buckets)
 		max_nr_buckets = 1UL << (MAX_TABLE_ORDER - 1);
diff --git a/urcu/rculfhash.h b/urcu/rculfhash.h
index 6ed7c8c..de31526 100644
--- a/urcu/rculfhash.h
+++ b/urcu/rculfhash.h
@@ -154,7 +154,7 @@ struct cds_lfht *cds_lfht_new(unsigned long init_size,
 			pthread_attr_t *attr)
 {
 	return _cds_lfht_new(init_size, min_nr_alloc_buckets, max_nr_buckets,
-			flags, &cds_lfht_mm_order, &rcu_flavor, attr);
+			flags, NULL, &rcu_flavor, attr);
 }
 
 /*

-- 
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com