[SSI] openssi/kernel/cluster/ssi/util rmtfb.c,1.27,1.28

Update of /cvsroot/ssic-linux/openssi/kernel/cluster/ssi/util
In directory sfp-cvsdas-3.v30.ch3.sourceforge.com:/tmp/cvs-serv3645/cluster/ssi/util

Modified Files:
      Tag: OPENSSI-FC
	rmtfb.c 
Log Message:
- Double the number of buckets in hash tables rmtfb_svrtbl and rmtfb_clitbl.
  Use hlist_head struct. Memory footprint unchanged.

 cluster/ssi/util/rmtfb.c         |   93 ++++++++++++++++---------------
 include/cluster/ssi/util/rmtfb.h |    4 -
 2 files changed, 50 insertions(+), 47 deletions(-)


Index: rmtfb.c
===================================================================
RCS file: /cvsroot/ssic-linux/openssi/kernel/cluster/ssi/util/rmtfb.c,v
retrieving revision 1.27
retrieving revision 1.28
diff -u -d -r1.27 -r1.28
--- rmtfb.c	5 Mar 2010 05:48:18 -0000	1.27
+++ rmtfb.c	5 Mar 2010 06:05:59 -0000	1.28
@@ -57,10 +57,10 @@
 #define RMTFB_MAGIC 0xDEAD2A9E
 #define RMTFB_VALID(_rfb) ((_rfb)->rfb_magic == RMTFB_MAGIC)
 
-#define rmtfb_tbllen (PAGE_SIZE / sizeof(struct list_head))
+#define rmtfb_tbllen (PAGE_SIZE / sizeof(struct hlist_head))
 static unsigned int rmtfb_tblbits;
 
-static struct list_head *rmtfb_svrtbl, *rmtfb_clitbl;
+static struct hlist_head *rmtfb_svrtbl, *rmtfb_clitbl;
 #ifdef RMTFB_HASH_LOCKLESS
 static __cacheline_aligned_in_smp DEFINE_SPINLOCK(rmtfb_svrtbl_lock);
 static __cacheline_aligned_in_smp DEFINE_SPINLOCK(rmtfb_clitbl_lock);
@@ -166,8 +166,8 @@
 {
 	int ctr;
 
-	rmtfb_svrtbl = (struct list_head *)__get_free_page(GFP_KERNEL);
-	rmtfb_clitbl = (struct list_head *)__get_free_page(GFP_KERNEL);
+	rmtfb_svrtbl = (typeof(rmtfb_svrtbl)) __get_free_page(GFP_KERNEL);
+	rmtfb_clitbl = (typeof(rmtfb_clitbl)) __get_free_page(GFP_KERNEL);
 	if (!rmtfb_svrtbl || !rmtfb_clitbl)
 		panic("rmtfb_init: Out of memory\n");
 
@@ -180,8 +180,8 @@
 #endif
 
 	for (ctr = 0; ctr < rmtfb_tbllen; ++ctr) {
-		INIT_LIST_HEAD(&rmtfb_svrtbl[ctr]);
-		INIT_LIST_HEAD(&rmtfb_clitbl[ctr]);
+		INIT_HLIST_HEAD(&rmtfb_svrtbl[ctr]);
+		INIT_HLIST_HEAD(&rmtfb_clitbl[ctr]);
 	}
 
 #ifndef RMTFB_HASH_LOCKLESS
@@ -203,7 +203,7 @@
 
 #ifdef SSI_NOTUSED
 void
-rmtfb_getids(struct list_head *ids, unsigned long min)
+rmtfb_getids(struct hlist_head *ids, unsigned long min)
 {
 	/* SSI_XXX: need a real implementation when we handle
 	 * wrapping in the unique number server
@@ -345,7 +345,8 @@
 rmtfb_tryagain_handle(struct rmtfb_svrhandle **svrhandle, const int error)
 {
 	struct inode *inode = NULL;
-	struct list_head *head;
+	struct hlist_head *head;
+	struct hlist_node *pos;
 	struct rmtfb_cmn *cmn;
 	int ctr, fixed_ino = 0;
 
@@ -359,7 +360,7 @@
 	SSI_ASSERT(*svrhandle);
 	LOCK_SHR_RW_LOCK(&rmtfb_svrtbl_lock);
 	for (ctr = 0, head = rmtfb_svrtbl; ctr < rmtfb_tbllen; ++ctr, ++head) {
-		list_for_each_entry(cmn, head, rfb_hash) {
+		hlist_for_each_entry(cmn, pos, head, rfb_hash) {
 			if (cmn->rfb_id == (*svrhandle)->id) {
 				inode = ftoi(cmn->rfb_file);
 				/* NB: rfb_id must be unique */
@@ -553,7 +554,7 @@
 #else /* RMTFB_HASH_LOCKLESS */
 struct rmtfb_clrnode_arg {
 	clusternode_t node;
-	struct list_head *list;
+	struct hlist_head *list;
 };
 
 static void
@@ -565,12 +566,15 @@
 #ifdef RMTFB_REFCNT_FIX
 	if (test_bit(ap->node - 1, rfb->rfb_clients)) {
 		rmtfb_get(rfb);
-		list_move(&rfb->common.rfb_hash, ap->list);
+		hlist_del(&rfb->common.rfb_hash);
+		hlist_add_head(&rfb->common.rfb_hash, ap->list);
 	}
 #else
 	rmtfb_clear_bit(ap->node, rfb);
-	if (!atomic_read(&rfb->rfb_refcnt) && rmtfb_nocli(rfb))
-		list_move(&rfb->common.rfb_hash, ap->list);
+	if (!atomic_read(&rfb->rfb_refcnt) && rmtfb_nocli(rfb)) {
+		hlist_del(&rfb->common.rfb_hash);
+		hlist_add_head(&rfb->common.rfb_hash, ap->list);
+	}
 #endif
 }
 #endif /* !RMTFB_HASH_LOCKLESS */
@@ -581,22 +585,23 @@
 /* also used by the print routines */
 static inline void
 rmtfb_nodedown_cmn(
-		struct list_head *table,
+		struct hlist_head *table,
 		rmtfb_nodedown_do *do_f,
 		u_long arg)
 
 {
-	struct list_head *head;
-	struct rmtfb_cmn *cmn;
+	struct hlist_head *head;
+	struct hlist_node *pos;
 #ifndef RMTFB_HASH_LOCKLESS
-	struct rmtfb_cmn *next;
+	struct hlist_node *next;
 #endif
+	struct rmtfb_cmn *cmn;
 	int ctr;
 
 	for (ctr = 0, head = table; ctr < rmtfb_tbllen; ++ctr, ++head) {
 #ifdef RMTFB_HASH_LOCKLESS
 		rcu_read_lock();
-		list_for_each_entry_rcu(cmn, head, rfb_hash) {
+		hlist_for_each_entry_rcu(cmn, pos, head, rfb_hash) {
 			if (!atomic_test_and_add(1, &cmn->rfb_ref_cnt))
 				continue;
 			/* do_f() to decrement rfb_ref_cnt */
@@ -604,7 +609,7 @@
 		}
 		rcu_read_unlock();
 #else
-		list_for_each_entry_safe(cmn, next, head, rfb_hash) {
+		hlist_for_each_entry_safe(cmn, pos, next, head, rfb_hash) {
 			do_f(cmn, arg);
 		}
 #endif /* !RMTFB_HASH_LOCKLESS */
@@ -621,11 +626,11 @@
 {
 #ifndef RMTFB_HASH_LOCKLESS
 #ifdef RMTFB_REFCNT_FIX
-	struct rmtfb_svr *rfb, *tmp;
-#else
-	struct list_head *cur;
+	struct rmtfb_svr *rfb;
+	struct hlist_node *tmp;
 #endif
-	LIST_HEAD(freelist);
+	struct hlist_node *cur;
+	HLIST_HEAD(freelist);
 	struct rmtfb_clrnode_arg rca;
 #endif /* !RMTFB_HASH_LOCKLESS */
 
@@ -648,14 +653,14 @@
 	UNLOCK_EXCL_RW_LOCK(&rmtfb_svrtbl_lock);
 
 #ifdef RMTFB_REFCNT_FIX
-	list_for_each_entry_safe(rfb, tmp, &freelist, common.rfb_hash) {
+	hlist_for_each_entry_safe(rfb, cur, tmp, &freelist, common.rfb_hash) {
 		rmtfb_clear_bit(node, rfb);
 		rmtfb_putsvr(rfb);
 	}
 #else
-	list_for_each(cur, &freelist) {
+	hlist_for_each(cur, &freelist) {
 		struct rmtfb_svr *rfb = (struct rmtfb_svr *)
-			list_entry(cur, struct rmtfb_cmn, rfb_hash);
+			hlist_entry(cur, struct rmtfb_cmn, rfb_hash);
 		rmtfb_freesvr(rfb);
 	}
 #endif /* !RMTFB_REFCNT_FIX */
@@ -687,16 +692,17 @@
 /* common lookup -- assumes the appropriate table is at least read-locked */
 static struct rmtfb_cmn *
 rmtfb_getcmn(
-		struct list_head *head,
+		struct hlist_head *head,
 		rmtfb_test *test,
 		void *data)
 {
 	struct rmtfb_cmn *cmn;
+	struct hlist_node *pos;
 #ifdef RMTFB_HASH_LOCKLESS
 	char found = 0;
 
 	rcu_read_lock();
-	list_for_each_entry_rcu(cmn, head, rfb_hash) {
+	hlist_for_each_entry_rcu(cmn, pos, head, rfb_hash) {
 		if (!test(cmn, data))
 			continue;
 		if (!atomic_test_and_add(1, &cmn->rfb_ref_cnt))
@@ -707,7 +713,7 @@
 	rcu_read_unlock();
 	return found ? cmn : NULL;
 #else
-	list_for_each_entry(cmn, head, rfb_hash) {
+	hlist_for_each_entry(cmn, pos, head, rfb_hash) {
 		if (test(cmn, data))
 			return cmn;
 	}
@@ -871,7 +877,7 @@
 		SSI_ASSERT(atomic_read(&rfb->rfb_refcnt));
 		LOCK_EXCL_RW_LOCK(&rmtfb_svrtbl_lock);
 		if (atomic_dec_and_test(&rfb->rfb_refcnt) && rmtfb_nocli(rfb)) {
-			list_del(&rfb->common.rfb_hash);
+			hlist_del(&rfb->common.rfb_hash);
 			UNLOCK_EXCL_RW_LOCK(&rmtfb_svrtbl_lock);
 			rmtfb_freesvr(rfb);
 		}
@@ -884,7 +890,7 @@
 #ifdef RMTFB_HASH_LOCKLESS
 	if (!atomic_dec_and_lock(&rfb->rfb_refcnt, &rmtfb_svrtbl_lock))
 		return;
-	list_del_rcu(&rfb->common.rfb_hash);
+	hlist_del_rcu(&rfb->common.rfb_hash);
 	spin_unlock(&rmtfb_svrtbl_lock);
 #else
 	LOCK_EXCL_RW_LOCK(&rmtfb_svrtbl_lock);
@@ -892,7 +898,7 @@
 		UNLOCK_EXCL_RW_LOCK(&rmtfb_svrtbl_lock);
 		return;
 	}
-	list_del(&rfb->common.rfb_hash);
+	hlist_del(&rfb->common.rfb_hash);
 	UNLOCK_EXCL_RW_LOCK(&rmtfb_svrtbl_lock);
 #endif /* !RMTFB_HASH_LOCKLESS */
 	rmtfb_freesvr(rfb);
@@ -1095,7 +1101,7 @@
 #ifdef RMTFB_HASH_LOCKLESS
 	if (!atomic_dec_and_lock(&rfb->rfb_refcnt, &rmtfb_clitbl_lock))
 		return;
-	list_del_rcu(&rfb->common.rfb_hash);
+	hlist_del_rcu(&rfb->common.rfb_hash);
 	spin_unlock(&rmtfb_clitbl_lock);
 #else
 	LOCK_EXCL_RW_LOCK(&rmtfb_clitbl_lock);
@@ -1103,7 +1109,7 @@
 		UNLOCK_EXCL_RW_LOCK(&rmtfb_clitbl_lock);
 		return;
 	}
-	list_del(&rfb->common.rfb_hash);
+	hlist_del(&rfb->common.rfb_hash);
 	UNLOCK_EXCL_RW_LOCK(&rmtfb_clitbl_lock);
 #endif /* !RMTFB_HASH_LOCKLESS */
 	rmtfb_freecli(rfb);
@@ -1123,7 +1129,7 @@
 
 	if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
 	    SLAB_CTOR_CONSTRUCTOR) {
-		INIT_LIST_HEAD(&cmn->rfb_hash);
+		INIT_HLIST_NODE(&cmn->rfb_hash);
 		INIT_RCU_HEAD(&cmn->rfb_rcu);
 	}
 }
@@ -1145,10 +1151,7 @@
 static inline void
 rmtfb_new_prep(struct rmtfb_cmn *cmn, struct file *file, unsigned long id)
 {
-#if 0
-	INIT_LIST_HEAD(&cmn->rfb_hash);
-	get_file(file); /* done in caller */
-#endif
+	/* Skipped get_file(); done in caller */
 	cmn->rfb_file = file;
 	cmn->rfb_id = id ? : unum_getnum(unum_rmtfbid);
 	atomic_set(&cmn->rfb_ref_cnt, 1);
@@ -1196,7 +1199,7 @@
 	if (!cmn)
 		return NULL;
 
-	INIT_LIST_HEAD(&cmn->rfb_hash);
+	INIT_HLIST_NODE(&cmn->rfb_hash);
 	cmn->rfb_file = file; /* Client to grab reference to file struct */
 	cmn->rfb_id = id ? id : unum_getnum(unum_rmtfbid);
 	return cmn;
@@ -1236,7 +1239,7 @@
 	}
 
 	spin_lock(&rmtfb_svrtbl_lock);
-	list_add_rcu(&rfb->common.rfb_hash, &rmtfb_svrtbl[rfbhash(ino)]);
+	hlist_add_head_rcu(&rfb->common.rfb_hash, &rmtfb_svrtbl[rfbhash(ino)]);
 	spin_unlock(&rmtfb_svrtbl_lock);
 	up(&rmtfb_newsvr_lock);
 out:
@@ -1288,7 +1291,7 @@
 #ifndef RMTFB_REFCNT_FIX
 	get_file(file);
 #endif
-	list_add(&rfb->common.rfb_hash, &rmtfb_svrtbl[rfbhash(ino)]);
+	hlist_add_head(&rfb->common.rfb_hash, &rmtfb_svrtbl[rfbhash(ino)]);
 	UNLOCK_EXCL_RW_LOCK(&rmtfb_svrtbl_lock);
 out:
 #ifdef RFBDEBUG
@@ -1435,7 +1438,7 @@
 	 */
 
 	spin_lock(&rmtfb_clitbl_lock);
-	list_add_rcu(&rfb->common.rfb_hash, &rmtfb_clitbl[rfbhash(id)]);
+	hlist_add_head_rcu(&rfb->common.rfb_hash, &rmtfb_clitbl[rfbhash(id)]);
 	spin_unlock(&rmtfb_clitbl_lock);
 	up(&rmtfb_newcli_lock);
 out:
@@ -1539,7 +1542,7 @@
 	 */
 	rmtfb_get(rfb); /* for file->private_data */
 #endif
-	list_add(&rfb->common.rfb_hash, &rmtfb_clitbl[rfbhash(id)]);
+	hlist_add_head(&rfb->common.rfb_hash, &rmtfb_clitbl[rfbhash(id)]);
 	SSI_ASSERT(ftocli(file) == rfb);
 	/* Skipped get_file(file) due to circular reference.
 	 *	file->private_data->common.rfb_file == file
@@ -1631,7 +1634,7 @@
 	file->private_data = NULL;
 #else
 	LOCK_EXCL_RW_LOCK(&rmtfb_clitbl_lock);
-	list_del(&rfb->common.rfb_hash);
+	hlist_del(&rfb->common.rfb_hash);
 	UNLOCK_EXCL_RW_LOCK(&rmtfb_clitbl_lock);
 	rfb->rfb_magic = 0;
 	kfree(rfb);


------------------------------------------------------------------------------
Download Intel&#174; Parallel Studio Eval
Try the new software tools for yourself. Speed compiling, find bugs
proactively, and fine-tune applications for parallel performance.
See why Intel Parallel Studio got high marks during beta.
http://p.sf.net/sfu/intel-sw-dev