b=17479

r=adilger,behlendorf1

- avoid div/mod in lustre_hash code

diff --git a/lustre/include/class_hash.h b/lustre/include/class_hash.h
index 78a946e..e2b2b11 100644 (file)
--- a/lustre/include/class_hash.h
+++ b/lustre/include/class_hash.h
@@ -50,9 +50,10 @@ typedef struct lustre_hash_bucket {
 #define LUSTRE_MAX_HASH_NAME 16
 
 typedef struct lustre_hash {
-        int                         lh_cur_size;    /* current hash size */
-        int                         lh_min_size;    /* min hash size */
-        int                         lh_max_size;    /* max hash size */
+        int                         lh_cur_bits;    /* current hash bits */
+        int                         lh_cur_mask;    /* current hash mask */
+        int                         lh_min_bits;    /* min hash bits */
+        int                         lh_max_bits;    /* max hash bits */
         int                         lh_min_theta;   /* resize min threshold */
         int                         lh_max_theta;   /* resize max threshold */
         int                         lh_flags;       /* hash flags */
@@ -180,7 +181,7 @@ __lustre_hash_bucket_validate(lustre_hash_t *lh, lustre_hash_bucket_t *lhb,
         unsigned i;
 
         if (unlikely(lh->lh_flags & LH_DEBUG)) {
-                i = lh_hash(lh, lh_key(lh, hnode), lh->lh_cur_size - 1);
+                i = lh_hash(lh, lh_key(lh, hnode), lh->lh_cur_mask);
                 LASSERT(&lh->lh_buckets[i] == lhb);
         }
 }
@@ -225,8 +226,8 @@ __lustre_hash_bucket_del(lustre_hash_t *lh,
 }
 
 /* Hash init/cleanup functions */
-lustre_hash_t *lustre_hash_init(char *name, unsigned int cur_size, 
-                                unsigned int max_size,
+lustre_hash_t *lustre_hash_init(char *name, unsigned int cur_bits, 
+                                unsigned int max_bits,
                                 lustre_hash_ops_t *ops, int flags);
 void lustre_hash_exit(lustre_hash_t *lh);
 
@@ -251,21 +252,36 @@ void lustre_hash_for_each_empty(lustre_hash_t *lh, lh_for_each_cb, void *data);
 void lustre_hash_for_each_key(lustre_hash_t *lh, void *key,
                               lh_for_each_cb, void *data);
 
-/* Rehash - Theta is calculated to be the average chained
- * hash depth assuming a perfectly uniform hash funcion. */
-int lustre_hash_rehash(lustre_hash_t *lh, int size);
+/* 
+ * Rehash - Theta is calculated to be the average chained
+ * hash depth assuming a perfectly uniform hash funcion. 
+ */
+int lustre_hash_rehash(lustre_hash_t *lh, int bits);
 void lustre_hash_rehash_key(lustre_hash_t *lh, void *old_key,
                             void *new_key, struct hlist_node *hnode);
 
 
-static inline int
-__lustre_hash_theta(lustre_hash_t *lh)
+#define LH_THETA_BITS  10
+
+/* Return integer component of theta */
+static inline int __lustre_hash_theta_int(int theta)
 {
-        return ((atomic_read(&lh->lh_count) * 1000) / lh->lh_cur_size);
+        return (theta >> LH_THETA_BITS);
 }
 
-static inline void
-__lustre_hash_set_theta(lustre_hash_t *lh, int min, int max)
+/* Return a fractional value between 0 and 999 */
+static inline int __lustre_hash_theta_frac(int theta)
+{
+        return ((theta * 1000) >> LH_THETA_BITS) - 
+               (__lustre_hash_theta_int(theta) * 1000);
+}
+
+static inline int __lustre_hash_theta(lustre_hash_t *lh)
+{
+        return (atomic_read(&lh->lh_count) << LH_THETA_BITS) >> lh->lh_cur_bits;
+}
+
+static inline void __lustre_hash_set_theta(lustre_hash_t *lh, int min, int max)
 {
         LASSERT(min < max);
         lh->lh_min_theta = min;
@@ -317,7 +333,7 @@ lh_u64_hash(__u64 key, unsigned mask)
 
 #define lh_for_each_bucket(lh, lhb, pos)         \
         for (pos = 0;                            \
-             pos < lh->lh_cur_size &&            \
+             pos <= lh->lh_cur_mask &&           \
              ({ lhb = &lh->lh_buckets[i]; 1; }); \
              pos++)
 

diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c
index 8bf6dc9..f930952 100644 (file)
--- a/lustre/ldlm/ldlm_lockd.c
+++ b/lustre/ldlm/ldlm_lockd.c
@@ -1978,7 +1978,7 @@ int ldlm_init_export(struct obd_export *exp)
 
         exp->exp_lock_hash =
                 lustre_hash_init(obd_uuid2str(&exp->exp_client_uuid),
-                                 128, 65536, &ldlm_export_lock_ops, LH_REHASH);
+                                 7, 16, &ldlm_export_lock_ops, LH_REHASH);
 
         if (!exp->exp_lock_hash)
                 RETURN(-ENOMEM);

diff --git a/lustre/obdclass/class_hash.c b/lustre/obdclass/class_hash.c
index 5e8fab2..c03bb94 100644 (file)
--- a/lustre/obdclass/class_hash.c
+++ b/lustre/obdclass/class_hash.c
@@ -58,14 +58,14 @@
 /**
  * Initialize new lustre hash, where:
  * @name     - Descriptive hash name
- * @cur_size - Initial hash table size
- * @max_size - Maximum allowed hash table resize
+ * @cur_bits - Initial hash table size, in bits
+ * @max_bits - Maximum allowed hash table resize, in bits
  * @ops      - Registered hash table operations
  * @flags    - LH_REHASH enable synamic hash resizing
  *           - LH_SORT enable chained hash sort
  */
 lustre_hash_t *
-lustre_hash_init(char *name, unsigned int cur_size, unsigned int max_size,
+lustre_hash_init(char *name, unsigned int cur_bits, unsigned int max_bits,
                  lustre_hash_ops_t *ops, int flags)
 {
         lustre_hash_t *lh;
@@ -75,14 +75,9 @@ lustre_hash_init(char *name, unsigned int cur_size, unsigned int max_size,
         LASSERT(name != NULL);
         LASSERT(ops != NULL);
 
-        /* 
-         * Ensure hash is a power of two to allow the use of a bitmask
-         * in the hash function instead of a more expensive modulus. 
-         */
-        LASSERTF(cur_size && (cur_size & (cur_size - 1)) == 0,
-                 "Size (%u) is not power of 2\n", cur_size);
-        LASSERTF(max_size && (max_size & (max_size - 1)) == 0,
-                 "Size (%u) is not power of 2\n", max_size);
+        LASSERT(cur_bits > 0);
+        LASSERT(max_bits >= cur_bits);
+        LASSERT(max_bits < 31);
   
         OBD_ALLOC_PTR(lh);
         if (!lh)
@@ -92,22 +87,27 @@ lustre_hash_init(char *name, unsigned int cur_size, unsigned int max_size,
         atomic_set(&lh->lh_rehash_count, 0);
         atomic_set(&lh->lh_count, 0);
         rwlock_init(&lh->lh_rwlock);
-        lh->lh_cur_size = cur_size;
-        lh->lh_min_size = cur_size;
-        lh->lh_max_size = max_size;
+        lh->lh_cur_bits = cur_bits;
+        lh->lh_cur_mask = (1 << cur_bits) - 1;
+        lh->lh_min_bits = cur_bits;
+        lh->lh_max_bits = max_bits;
+        /* XXX: need to fixup lustre_hash_rehash_bits() before this can be
+         *      anything other than 0.5 and 2.0 */
+        lh->lh_min_theta = 1 << (LH_THETA_BITS - 1);
+        lh->lh_max_theta = 1 << (LH_THETA_BITS + 1);
         lh->lh_ops = ops;
         lh->lh_flags = flags;
 
         /* theta * 1000 */
         __lustre_hash_set_theta(lh, 500, 2000);
 
-        OBD_VMALLOC(lh->lh_buckets, sizeof(*lh->lh_buckets) * lh->lh_cur_size);
+        OBD_VMALLOC(lh->lh_buckets, sizeof(*lh->lh_buckets) << lh->lh_cur_bits);
         if (!lh->lh_buckets) {
                 OBD_FREE_PTR(lh);
                 RETURN(NULL);
         }
   
-        for (i = 0; i < lh->lh_cur_size; i++) {
+        for (i = 0; i <= lh->lh_cur_mask; i++) {
                 INIT_HLIST_HEAD(&lh->lh_buckets[i].lhb_head);
                 rwlock_init(&lh->lh_buckets[i].lhb_rwlock);
                 atomic_set(&lh->lh_buckets[i].lhb_count, 0);
@@ -146,7 +146,7 @@ lustre_hash_exit(lustre_hash_t *lh)
                 write_unlock(&lhb->lhb_rwlock);
         }
   
-        OBD_VFREE(lh->lh_buckets, sizeof(*lh->lh_buckets) * lh->lh_cur_size);
+        OBD_VFREE(lh->lh_buckets, sizeof(*lh->lh_buckets) << lh->lh_cur_bits);
         LASSERT(atomic_read(&lh->lh_count) == 0);
         write_unlock(&lh->lh_rwlock);
   
@@ -155,26 +155,22 @@ lustre_hash_exit(lustre_hash_t *lh)
 }
 EXPORT_SYMBOL(lustre_hash_exit);
 
-static inline unsigned int lustre_hash_rehash_size(lustre_hash_t *lh)
+static inline unsigned int lustre_hash_rehash_bits(lustre_hash_t *lh)
 {
-        int size;
-
         if (!(lh->lh_flags & LH_REHASH))
                 return 0;
 
-        if ((lh->lh_cur_size < lh->lh_max_size) &&
+        /* XXX: need to handle case with max_theta != 2.0 
+         *      and the case with min_theta != 0.5 */
+        if ((lh->lh_cur_bits < lh->lh_max_bits) &&
             (__lustre_hash_theta(lh) > lh->lh_max_theta))
-                size = min(lh->lh_cur_size * 2, lh->lh_max_size);
-        else if ((lh->lh_cur_size > lh->lh_min_size) &&
-            (__lustre_hash_theta(lh) < lh->lh_min_theta))
-                size = max(lh->lh_cur_size / 2, lh->lh_min_size);
-        else
-                size = 0;
+                return lh->lh_cur_bits + 1;
 
-        if (lh->lh_cur_size == size)
-                size = 0;
+        if ((lh->lh_cur_bits > lh->lh_min_bits) &&
+            (__lustre_hash_theta(lh) < lh->lh_min_theta))
+                return lh->lh_cur_bits - 1;
 
-        return size;
+        return 0;
 }
   
 /**
@@ -185,26 +181,26 @@ void
 lustre_hash_add(lustre_hash_t *lh, void *key, struct hlist_node *hnode)
 {
         lustre_hash_bucket_t *lhb;
-        int                   size;
+        int                   bits;
         unsigned              i;
         ENTRY;
   
         __lustre_hash_key_validate(lh, key, hnode);
 
         read_lock(&lh->lh_rwlock);
-        i = lh_hash(lh, key, lh->lh_cur_size - 1);
+        i = lh_hash(lh, key, lh->lh_cur_mask);
         lhb = &lh->lh_buckets[i];
-        LASSERT(i < lh->lh_cur_size);
+        LASSERT(i <= lh->lh_cur_mask);
         LASSERT(hlist_unhashed(hnode));
 
         write_lock(&lhb->lhb_rwlock);
         __lustre_hash_bucket_add(lh, lhb, hnode);
         write_unlock(&lhb->lhb_rwlock);
 
-        size = lustre_hash_rehash_size(lh);
+        bits = lustre_hash_rehash_bits(lh);
         read_unlock(&lh->lh_rwlock);
-        if (size)
-                lustre_hash_rehash(lh, size);
+        if (bits)
+                lustre_hash_rehash(lh, bits);
   
         EXIT;
 }
@@ -214,7 +210,7 @@ static struct hlist_node *
 lustre_hash_findadd_unique_hnode(lustre_hash_t *lh, void *key,
                                  struct hlist_node *hnode)
 {
-        int                   size = 0;
+        int                   bits = 0;
         struct hlist_node    *ehnode;
         lustre_hash_bucket_t *lhb;
         unsigned              i;
@@ -223,9 +219,9 @@ lustre_hash_findadd_unique_hnode(lustre_hash_t *lh, void *key,
         __lustre_hash_key_validate(lh, key, hnode);
   
         read_lock(&lh->lh_rwlock);
-        i = lh_hash(lh, key, lh->lh_cur_size - 1);
+        i = lh_hash(lh, key, lh->lh_cur_mask);
         lhb = &lh->lh_buckets[i];
-        LASSERT(i < lh->lh_cur_size);
+        LASSERT(i <= lh->lh_cur_mask);
         LASSERT(hlist_unhashed(hnode));
 
         write_lock(&lhb->lhb_rwlock);
@@ -235,12 +231,12 @@ lustre_hash_findadd_unique_hnode(lustre_hash_t *lh, void *key,
         } else {
                 __lustre_hash_bucket_add(lh, lhb, hnode);
                 ehnode = hnode;
-                size = lustre_hash_rehash_size(lh);
+                bits = lustre_hash_rehash_bits(lh);
         }
         write_unlock(&lhb->lhb_rwlock);
         read_unlock(&lh->lh_rwlock);
-        if (size)
-                lustre_hash_rehash(lh, size);
+        if (bits)
+                lustre_hash_rehash(lh, bits);
   
         RETURN(ehnode);
 }
@@ -304,9 +300,9 @@ lustre_hash_del(lustre_hash_t *lh, void *key, struct hlist_node *hnode)
         __lustre_hash_key_validate(lh, key, hnode);
   
         read_lock(&lh->lh_rwlock);
-        i = lh_hash(lh, key, lh->lh_cur_size - 1);
+        i = lh_hash(lh, key, lh->lh_cur_mask);
         lhb = &lh->lh_buckets[i];
-        LASSERT(i < lh->lh_cur_size);
+        LASSERT(i <= lh->lh_cur_mask);
         LASSERT(!hlist_unhashed(hnode));
 
         write_lock(&lhb->lhb_rwlock);
@@ -334,9 +330,9 @@ lustre_hash_del_key(lustre_hash_t *lh, void *key)
         ENTRY;
   
         read_lock(&lh->lh_rwlock);
-        i = lh_hash(lh, key, lh->lh_cur_size - 1);
+        i = lh_hash(lh, key, lh->lh_cur_mask);
         lhb = &lh->lh_buckets[i];
-        LASSERT(i < lh->lh_cur_size);
+        LASSERT(i <= lh->lh_cur_mask);
 
         write_lock(&lhb->lhb_rwlock);
         hnode = __lustre_hash_bucket_lookup(lh, lhb, key);
@@ -368,9 +364,9 @@ lustre_hash_lookup(lustre_hash_t *lh, void *key)
         ENTRY;
   
         read_lock(&lh->lh_rwlock);
-        i = lh_hash(lh, key, lh->lh_cur_size - 1);
+        i = lh_hash(lh, key, lh->lh_cur_mask);
         lhb = &lh->lh_buckets[i];
-        LASSERT(i < lh->lh_cur_size);
+        LASSERT(i <= lh->lh_cur_mask);
 
         read_lock(&lhb->lhb_rwlock);
         hnode = __lustre_hash_bucket_lookup(lh, lhb, key);
@@ -514,9 +510,9 @@ lustre_hash_for_each_key(lustre_hash_t *lh, void *key,
         ENTRY;
   
         read_lock(&lh->lh_rwlock);
-        i = lh_hash(lh, key, lh->lh_cur_size - 1);
+        i = lh_hash(lh, key, lh->lh_cur_mask);
         lhb = &lh->lh_buckets[i];
-        LASSERT(i < lh->lh_cur_size);
+        LASSERT(i <= lh->lh_cur_mask);
   
         read_lock(&lhb->lhb_rwlock);
         hlist_for_each(hnode, &(lhb->lhb_head)) {
@@ -537,7 +533,7 @@ lustre_hash_for_each_key(lustre_hash_t *lh, void *key,
 EXPORT_SYMBOL(lustre_hash_for_each_key);
   
 /**
- * Rehash the lustre hash @lh to the given @size.  This can be used
+ * Rehash the lustre hash @lh to the given @bits.  This can be used
  * to grow the hash size when excessive chaining is detected, or to
  * shrink the hash when it is larger than needed.  When the LH_REHASH
  * flag is set in @lh the lustre hash may be dynamically rehashed
@@ -548,7 +544,7 @@ EXPORT_SYMBOL(lustre_hash_for_each_key);
  * theta thresholds for @lh are tunable via lustre_hash_set_theta().
  */
 int
-lustre_hash_rehash(lustre_hash_t *lh, int size)
+lustre_hash_rehash(lustre_hash_t *lh, int bits)
 {
         struct hlist_node     *hnode;
         struct hlist_node     *pos;
@@ -557,19 +553,21 @@ lustre_hash_rehash(lustre_hash_t *lh, int size)
         lustre_hash_bucket_t  *lh_lhb;
         lustre_hash_bucket_t  *rehash_lhb;
         int                    i;
-        int                    lh_size;
         int                    theta;
+        int                    lh_mask;
+        int                    lh_bits;
+        int                    mask = (1 << bits) - 1;
         void                  *key;
         ENTRY;
   
-        LASSERT(size > 0);
         LASSERT(!in_interrupt());
-  
-        OBD_VMALLOC(rehash_buckets, sizeof(*rehash_buckets) * size);
+        LASSERT(mask > 0);
+
+        OBD_VMALLOC(rehash_buckets, sizeof(*rehash_buckets) << bits);
         if (!rehash_buckets)
                 RETURN(-ENOMEM);
   
-        for (i = 0; i < size; i++) {
+        for (i = 0; i <= mask; i++) {
                 INIT_HLIST_HEAD(&rehash_buckets[i].lhb_head);
                 rwlock_init(&rehash_buckets[i].lhb_rwlock);
                 atomic_set(&rehash_buckets[i].lhb_count, 0);
@@ -583,19 +581,21 @@ lustre_hash_rehash(lustre_hash_t *lh, int size)
          */
         theta = __lustre_hash_theta(lh);
         if ((theta >= lh->lh_min_theta) && (theta <= lh->lh_max_theta)) {
-                OBD_VFREE(rehash_buckets, sizeof(*rehash_buckets) * size);
+                OBD_VFREE(rehash_buckets, sizeof(*rehash_buckets) << bits);
                 write_unlock(&lh->lh_rwlock);
                 RETURN(-EALREADY);
         }
   
-        lh_size = lh->lh_cur_size;
+        lh_bits = lh->lh_cur_bits;
         lh_buckets = lh->lh_buckets;
+        lh_mask = (1 << lh_bits) - 1;
   
-        lh->lh_cur_size = size;
+        lh->lh_cur_bits = bits;
+        lh->lh_cur_mask = (1 << bits) - 1;
         lh->lh_buckets = rehash_buckets;
         atomic_inc(&lh->lh_rehash_count);
 
-        for (i = 0; i < lh_size; i++) {
+        for (i = 0; i <= lh_mask; i++) {
                 lh_lhb = &lh_buckets[i];
 
                 write_lock(&lh_lhb->lhb_rwlock);
@@ -607,7 +607,7 @@ lustre_hash_rehash(lustre_hash_t *lh, int size)
                          * Validate hnode is in the correct bucket.
                          */
                         if (unlikely(lh->lh_flags & LH_DEBUG))
-                                LASSERT(lh_hash(lh, key, lh_size - 1) == i);
+                                LASSERT(lh_hash(lh, key, lh_mask) == i);
 
                         /* 
                          * Delete from old hash bucket.
@@ -619,7 +619,7 @@ lustre_hash_rehash(lustre_hash_t *lh, int size)
                         /* 
                          * Add to rehash bucket, ops->lh_key must be defined. 
                          */
-                        rehash_lhb = &rehash_buckets[lh_hash(lh, key, size-1)];
+                        rehash_lhb = &rehash_buckets[lh_hash(lh, key, mask)];
                         hlist_add_head(hnode, &(rehash_lhb->lhb_head));
                         atomic_inc(&rehash_lhb->lhb_count);
                 }
@@ -629,7 +629,7 @@ lustre_hash_rehash(lustre_hash_t *lh, int size)
                 write_unlock(&lh_lhb->lhb_rwlock);
         }
   
-        OBD_VFREE(lh_buckets, sizeof(*lh_buckets) * lh_size);
+        OBD_VFREE(lh_buckets, sizeof(*lh_buckets) << lh_bits);
         write_unlock(&lh->lh_rwlock);
   
         RETURN(0);
@@ -659,13 +659,13 @@ void lustre_hash_rehash_key(lustre_hash_t *lh, void *old_key, void *new_key,
   
         read_lock(&lh->lh_rwlock);
   
-        i = lh_hash(lh, old_key, lh->lh_cur_size - 1);
+        i = lh_hash(lh, old_key, lh->lh_cur_mask);
         old_lhb = &lh->lh_buckets[i];
-        LASSERT(i < lh->lh_cur_size);
+        LASSERT(i <= lh->lh_cur_mask);
 
-        j = lh_hash(lh, new_key, lh->lh_cur_size - 1);
+        j = lh_hash(lh, new_key, lh->lh_cur_mask);
         new_lhb = &lh->lh_buckets[j];
-        LASSERT(j < lh->lh_cur_size);
+        LASSERT(j <= lh->lh_cur_mask);
 
         write_lock(&old_lhb->lhb_rwlock);
         write_lock(&new_lhb->lhb_rwlock);
@@ -711,16 +711,19 @@ int lustre_hash_debug_str(lustre_hash_t *lh, char *str, int size)
         read_lock(&lh->lh_rwlock);
         theta = __lustre_hash_theta(lh);
 
-        c += snprintf(str + c, size - c, "%-36s ",lh->lh_name);
-        c += snprintf(str + c, size - c, "%5d ",  lh->lh_cur_size);
-        c += snprintf(str + c, size - c, "%5d ",  lh->lh_min_size);
-        c += snprintf(str + c, size - c, "%5d ",  lh->lh_max_size);
+        c += snprintf(str + c, size - c, "%-36s ", lh->lh_name);
+        c += snprintf(str + c, size - c, "%5d ",  1 << lh->lh_cur_bits);
+        c += snprintf(str + c, size - c, "%5d ",  1 << lh->lh_min_bits);
+        c += snprintf(str + c, size - c, "%5d ",  1 << lh->lh_max_bits);
         c += snprintf(str + c, size - c, "%d.%03d ",
-                      theta / 1000, theta % 1000);
+                      __lustre_hash_theta_int(theta),
+                      __lustre_hash_theta_frac(theta));
         c += snprintf(str + c, size - c, "%d.%03d ",
-                      lh->lh_min_theta / 1000, lh->lh_min_theta % 1000);
+                      __lustre_hash_theta_int(lh->lh_min_theta),
+                      __lustre_hash_theta_frac(lh->lh_min_theta));
         c += snprintf(str + c, size - c, "%d.%03d ",
-                      lh->lh_max_theta / 1000, lh->lh_max_theta % 1000);
+                      __lustre_hash_theta_int(lh->lh_max_theta),
+                      __lustre_hash_theta_frac(lh->lh_max_theta));
         c += snprintf(str + c, size - c, " 0x%02x ", lh->lh_flags);
         c += snprintf(str + c, size - c, "%6d ",
                       atomic_read(&lh->lh_rehash_count));
@@ -741,7 +744,7 @@ int lustre_hash_debug_str(lustre_hash_t *lh, char *str, int size)
          * Non-Uniform hash distribution:  128/125/0/0/0/0/2/1
          */
         lh_for_each_bucket(lh, lhb, i)
-                dist[MIN(__fls(atomic_read(&lhb->lhb_count)/MAX(theta,1)),7)]++;
+                dist[min(__fls(atomic_read(&lhb->lhb_count)/max(theta,1)),7)]++;
 
         for (i = 0; i < 8; i++)
                 c += snprintf(str + c, size - c, "%d%c",  dist[i],

diff --git a/lustre/obdclass/obd_config.c b/lustre/obdclass/obd_config.c
index e1cedeb..7eaeb96 100644 (file)
--- a/lustre/obdclass/obd_config.c
+++ b/lustre/obdclass/obd_config.c
@@ -304,19 +304,19 @@ int class_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
         spin_unlock(&obd->obd_dev_lock);
 
         /* create an uuid-export lustre hash */
-        obd->obd_uuid_hash = lustre_hash_init("UUID_HASH", 128, 128,
+        obd->obd_uuid_hash = lustre_hash_init("UUID_HASH", 7, 7,
                                               &uuid_hash_ops, 0);
         if (!obd->obd_uuid_hash)
                 GOTO(err_hash, err = -ENOMEM);
 
         /* create a nid-export lustre hash */
-        obd->obd_nid_hash = lustre_hash_init("NID_HASH", 128, 128,
+        obd->obd_nid_hash = lustre_hash_init("NID_HASH", 7, 7,
                                              &nid_hash_ops, 0);
         if (!obd->obd_nid_hash)
                 GOTO(err_hash, err = -ENOMEM);
 
         /* create a nid-stats lustre hash */
-        obd->obd_nid_stats_hash = lustre_hash_init("NID_STATS", 128, 128,
+        obd->obd_nid_stats_hash = lustre_hash_init("NID_STATS", 7, 7,
                                                    &nid_stat_hash_ops, 0);
         if (!obd->obd_nid_stats_hash)
                 GOTO(err_hash, err = -ENOMEM);

diff --git a/lustre/ptlrpc/connection.c b/lustre/ptlrpc/connection.c
index 9442bf7..fb86c6c 100644 (file)
--- a/lustre/ptlrpc/connection.c
+++ b/lustre/ptlrpc/connection.c
@@ -143,7 +143,7 @@ int ptlrpc_connection_init(void)
 {
         ENTRY;
 
-        conn_hash = lustre_hash_init("CONN_HASH", 32, 32768,
+        conn_hash = lustre_hash_init("CONN_HASH", 5, 15,
                                      &conn_hash_ops, LH_REHASH);
         if (!conn_hash)
                 RETURN(-ENOMEM);

diff --git a/lustre/quota/quota_context.c b/lustre/quota/quota_context.c
index 274a952..de7a94a 100644 (file)
--- a/lustre/quota/quota_context.c
+++ b/lustre/quota/quota_context.c
@@ -1147,8 +1147,8 @@ qctxt_init(struct obd_device *obd, dqacq_handler_t handler)
         qctxt->lqc_sync_blk = 0;
         spin_unlock(&qctxt->lqc_lock);
 
-        qctxt->lqc_lqs_hash = lustre_hash_init("LQS_HASH", 128, 128,
-                                              &lqs_hash_ops, 0);
+        qctxt->lqc_lqs_hash = lustre_hash_init("LQS_HASH", 7, 7,
+                                               &lqs_hash_ops, 0);
         if (!qctxt->lqc_lqs_hash)
                 CERROR("initialize hash lqs for %s error!\n", obd->obd_name);