add patch series

1 files changed, 84 insertions, 0 deletions

diff --git a/debian/patches/0002-libihash-add-hurd_ihash_get_load.patch b/debian/patches/0002-libihash-add-hurd_ihash_get_load.patch
new file mode 100644
index 00000000..d6b17098
--- /dev/null
+++ b/debian/patches/0002-libihash-add-hurd_ihash_get_load.patch
@@ -0,0 +1,84 @@
+From 27dcb999977533fadd4c8c370c472bf9e31fd4c7 Mon Sep 17 00:00:00 2001
+From: Justus Winter <4winter@informatik.uni-hamburg.de>
+Date: Thu, 15 May 2014 13:53:16 +0200
+Subject: [PATCH 02/16] libihash: add hurd_ihash_get_load
+
+* libihash/ihash.c (hurd_ihash_add): Move the code computing the load
+factor of the hash table...
+* libihash/ihash.h (hurd_ihash_get_load): ... here, together with the
+comment describing the method and the rationale for chosing binary
+percent.
+---
+ libihash/ihash.c | 20 ++------------------
+ libihash/ihash.h | 24 ++++++++++++++++++++++++
+ 2 files changed, 26 insertions(+), 18 deletions(-)
+
+diff --git a/libihash/ihash.c b/libihash/ihash.c
+index f20ba61..4d9cc18 100644
+--- a/libihash/ihash.c
++++ b/libihash/ihash.c
+@@ -273,24 +273,8 @@ hurd_ihash_add (hurd_ihash_t ht, hurd_ihash_key_t key, hurd_ihash_value_t item)
+ 
+   if (ht->size)
+     {
+-      /* Only fill the hash table up to its maximum load factor given
+-         as "binary percent", where 128b% corresponds to 100%.  As the
+-         size is always a power of two, and 128 is also, the quotient
+-         of both is also a power of two.  Therefore, we can use bit
+-         shifts to scale the number of items.
+-
+-         load = nr_items * 128 / size
+-              = nr_items * 2^{log2 (128) - log2 (size)}
+-              = nr_items >> (log2 (size) - log2 (128))
+-                                -- if size >= 128
+-              = nr_items << (log2 (128) - log2 (size))
+-                                -- otherwise
+-      */
+-      int d = __builtin_ctzl (ht->size) - 7;
+-      unsigned int load = d >= 0
+-        ? ht->nr_items >> d
+-        : ht->nr_items << -d;
+-      if (load <= ht->max_load)
++      /* Only fill the hash table up to its maximum load factor.  */
++      if (hurd_ihash_get_load (ht) <= ht->max_load)
+ 	if (add_one (ht, key, item))
+ 	  return 0;
+     }
+diff --git a/libihash/ihash.h b/libihash/ihash.h
+index 809166f..345630d 100644
+--- a/libihash/ihash.h
++++ b/libihash/ihash.h
+@@ -160,6 +160,30 @@ void hurd_ihash_set_cleanup (hurd_ihash_t ht, hurd_ihash_cleanup_t cleanup,
+ void hurd_ihash_set_max_load (hurd_ihash_t ht, unsigned int max_load);
+ 
+ 
++/* Get the current load factor of HT in binary percent, where 128b%
++   corresponds to 100%.  The reason we do this is that it is so
++   efficient to compute:
++
++   As the size is always a power of two, and 128 is also, the quotient
++   of both is also a power of two.  Therefore, we can use bit shifts
++   to scale the number of items.
++
++   load = nr_items * 128 / size
++        = nr_items * 2^{log2 (128) - log2 (size)}
++        = nr_items >> (log2 (size) - log2 (128))
++                                -- if size >= 128
++        = nr_items << (log2 (128) - log2 (size))
++                                -- otherwise
++
++   If you want to convert this to percent, just divide by 1.28.  */
++static inline unsigned int
++hurd_ihash_get_load (hurd_ihash_t ht)
++{
++  int d = __builtin_ctzl (ht->size) - 7;
++  return d >= 0 ? ht->nr_items >> d : ht->nr_items << -d;
++}
++
++
+ /* Add ITEM to the hash table HT under the key KEY.  If there already
+    is an item under this key, call the cleanup function (if any) for
+    it before overriding the value.  If a memory allocation error
+-- 
+2.0.0.rc0
+