[sheepdog] [PATCH v3] sockfd cache: grow fds count dynamically

Liu Yuan namei.unix at gmail.com
Tue Jul 24 03:46:34 CEST 2012


From: Liu Yuan <tailai.ly at taobao.com>

v3:
 - update comment
 - fd_in_use -> in_use
------------------------------------------------------ >8

This will scale sheep daemon to serve more VMs on one node and do
it adoptively and automatically.

- fd count default to 16 instead of previous 8

Signed-off-by: Liu Yuan <tailai.ly at taobao.com>
---
 sheep/sheep.c        |    1 +
 sheep/sheep_priv.h   |    1 +
 sheep/sockfd_cache.c |  128 ++++++++++++++++++++++++++++++++++++++------------
 3 files changed, 99 insertions(+), 31 deletions(-)

diff --git a/sheep/sheep.c b/sheep/sheep.c
index df28a94..380a129 100644
--- a/sheep/sheep.c
+++ b/sheep/sheep.c
@@ -344,6 +344,7 @@ int main(int argc, char **argv)
 	sys->recovery_wqueue = init_work_queue("recovery", true);
 	sys->deletion_wqueue = init_work_queue("deletion", true);
 	sys->block_wqueue = init_work_queue("block", true);
+	sys->sockfd_wqueue = init_work_queue("sockfd", true);
 	if (!sys->gateway_wqueue || !sys->io_wqueue ||!sys->recovery_wqueue ||
 	    !sys->deletion_wqueue || !sys->block_wqueue)
 		exit(1);
diff --git a/sheep/sheep_priv.h b/sheep/sheep_priv.h
index e455d27..530fe14 100644
--- a/sheep/sheep_priv.h
+++ b/sheep/sheep_priv.h
@@ -122,6 +122,7 @@ struct cluster_info {
 	struct work_queue *deletion_wqueue;
 	struct work_queue *recovery_wqueue;
 	struct work_queue *block_wqueue;
+	struct work_queue *sockfd_wqueue;
 };
 
 struct siocb {
diff --git a/sheep/sockfd_cache.c b/sheep/sockfd_cache.c
index aa90299..13c414b 100644
--- a/sheep/sockfd_cache.c
+++ b/sheep/sockfd_cache.c
@@ -48,23 +48,34 @@ static struct sockfd_cache sockfd_cache = {
 	.lock = PTHREAD_RWLOCK_INITIALIZER,
 };
 
+/*
+ * Suppose request size from Guest is 512k, then 4M / 512k = 8, so at
+ * most 8 requests can be issued to the same sheep object. Based on this
+ * assumption, '16' would be effecient for servers that only host 2~4
+ * Guests.
+ *
+ * This fd count will be dynamically grown when the idx reaches watermark which
+ * is calculated as FDS_COUNT * 0.75
+ */
+#define DEFAULT_FDS_COUNT	16
+#define DEFAULT_FDS_WATERMARK	12
+
+/* How many FDs we cache for one node */
+static int fds_count = DEFAULT_FDS_COUNT;
+
+struct sockfd_cache_fd {
+	int fd;
+	uint8_t in_use;
+};
+
 struct sockfd_cache_entry {
 	struct rb_node rb;
 	struct node_id nid;
-#define SOCKFD_CACHE_MAX_FD	8 /* How many FDs we cache for one node */
-	/*
-	 * FIXME: Make this macro configurable.
-	 *
-	 * Suppose request size from Guest is 512k, then 4M / 512k = 8, so at
-	 * most 8 requests can be issued to the same sheep object. Based on this
-	 * assumption, '8' would be effecient for servers that only host 4~8
-	 * Guests, but for powerful servers that can host dozens of Guests, we
-	 * might consider bigger value.
-	 */
-	int fd[SOCKFD_CACHE_MAX_FD];
-	uint8_t fd_in_use[SOCKFD_CACHE_MAX_FD];
+	struct sockfd_cache_fd *fds;
 };
 
+#define fds_bytes (sizeof(struct sockfd_cache_fd) * fds_count)
+
 static struct sockfd_cache_entry *
 sockfd_cache_insert(struct sockfd_cache_entry *new)
 {
@@ -118,8 +129,8 @@ static inline int get_free_slot(struct sockfd_cache_entry *entry)
 {
 	int idx = -1, i;
 
-	for (i = 0; i < SOCKFD_CACHE_MAX_FD; i++) {
-		if (uatomic_cmpxchg(&entry->fd_in_use[i], 0, 1))
+	for (i = 0; i < fds_count; i++) {
+		if (uatomic_cmpxchg(&entry->fds[i].in_use, 0, 1))
 			continue;
 		idx = i;
 		break;
@@ -155,8 +166,8 @@ out:
 static inline bool slots_all_free(struct sockfd_cache_entry *entry)
 {
 	int i;
-	for (i = 0; i < SOCKFD_CACHE_MAX_FD; i++)
-		if (uatomic_read(&entry->fd_in_use[i]))
+	for (i = 0; i < fds_count; i++)
+		if (uatomic_read(&entry->fds[i].in_use))
 			return false;
 	return true;
 }
@@ -164,9 +175,9 @@ static inline bool slots_all_free(struct sockfd_cache_entry *entry)
 static inline void destroy_all_slots(struct sockfd_cache_entry *entry)
 {
 	int i;
-	for (i = 0; i < SOCKFD_CACHE_MAX_FD; i++)
-		if (entry->fd[i] != -1)
-			close(entry->fd[i]);
+	for (i = 0; i < fds_count; i++)
+		if (entry->fds[i].fd != -1)
+			close(entry->fds[i].fd);
 }
 
 /*
@@ -220,11 +231,12 @@ void sockfd_cache_del(struct node_id *nid)
 
 static void sockfd_cache_add_nolock(struct node_id *nid)
 {
-	struct sockfd_cache_entry *new = xzalloc(sizeof(*new));
+	struct sockfd_cache_entry *new = xmalloc(sizeof(*new));
 	int i;
 
-	for (i = 0; i < SOCKFD_CACHE_MAX_FD; i++)
-		new->fd[i] = -1;
+	new->fds = xzalloc(fds_bytes);
+	for (i = 0; i < fds_count; i++)
+		new->fds[i].fd = -1;
 
 	memcpy(&new->nid, nid, sizeof(struct node_id));
 	if (sockfd_cache_insert(new)) {
@@ -251,15 +263,17 @@ void sockfd_cache_add_group(struct sd_node *nodes, int nr)
 /* Add one node to the cache means we can do caching tricks on this node */
 void sockfd_cache_add(struct node_id *nid)
 {
-	struct sockfd_cache_entry *new = xzalloc(sizeof(*new));
+	struct sockfd_cache_entry *new;
 	char name[INET6_ADDRSTRLEN];
 	int n, i;
 
-	for (i = 0; i < SOCKFD_CACHE_MAX_FD; i++)
-		new->fd[i] = -1;
+	pthread_rwlock_rdlock(&sockfd_cache.lock);
+	new = xmalloc(sizeof(*new));
+	new->fds = xzalloc(fds_bytes);
+	for (i = 0; i < fds_count; i++)
+		new->fds[i].fd = -1;
 
 	memcpy(&new->nid, nid, sizeof(struct node_id));
-	pthread_rwlock_rdlock(&sockfd_cache.lock);
 	if (sockfd_cache_insert(new)) {
 		free(new);
 		pthread_rwlock_unlock(&sockfd_cache.lock);
@@ -271,6 +285,56 @@ void sockfd_cache_add(struct node_id *nid)
 	dprintf("%s:%d, count %d\n", name, nid->port, n);
 }
 
+static void do_grow_fds(struct work *work)
+{
+	struct sockfd_cache_entry *entry;
+	struct rb_node *p;
+	int old_fds_count, new_fds_count, new_size, i;
+
+	dprintf("%d\n", fds_count);
+	pthread_rwlock_wrlock(&sockfd_cache.lock);
+	old_fds_count = fds_count;
+	new_fds_count = fds_count * 2;
+	new_size = fds_bytes * 2;
+	for (p = rb_first(&sockfd_cache.root); p; p = rb_next(p)) {
+		entry = rb_entry(p, struct sockfd_cache_entry, rb);
+		entry->fds = xrealloc(entry->fds, new_size);
+		for (i = old_fds_count; i < new_fds_count; i++) {
+			entry->fds[i].fd = -1;
+			entry->fds[i].in_use = 0;
+		}
+	}
+	pthread_rwlock_unlock(&sockfd_cache.lock);
+}
+
+static bool fds_in_grow;
+static int fds_high_watermark = DEFAULT_FDS_WATERMARK;
+
+static void grow_fds_done(struct work *work)
+{
+	fds_in_grow = false;
+	fds_count *= 2;
+	fds_high_watermark = fds_count * 3 / 4;
+	dprintf("fd count has been grown into %d\n", fds_count);
+	free(work);
+}
+
+static void inline check_idx(int idx)
+{
+	struct work *w;
+
+	if (idx <= fds_high_watermark)
+		return;
+	if (fds_in_grow)
+		return;
+
+	w = xmalloc(sizeof(*w));
+	w->fn = do_grow_fds;
+	w->done = grow_fds_done;
+	fds_in_grow = true;
+	queue_work(sys->sockfd_wqueue, w);
+}
+
 static struct sockfd *sockfd_cache_get(struct node_id *nid, char *name)
 {
 	struct sockfd_cache_entry *entry;
@@ -281,7 +345,9 @@ static struct sockfd *sockfd_cache_get(struct node_id *nid, char *name)
 	if (!entry)
 		return NULL;
 
-	if (entry->fd[idx] != -1) {
+	check_idx(idx);
+
+	if (entry->fds[idx].fd != -1) {
 		dprintf("%s:%d, idx %d\n", name, nid->port, idx);
 		goto out;
 	}
@@ -290,14 +356,14 @@ static struct sockfd *sockfd_cache_get(struct node_id *nid, char *name)
 	dprintf("create connection %s:%d idx %d\n", name, nid->port, idx);
 	fd = connect_to(name, nid->port);
 	if (fd < 0) {
-		uatomic_dec(&entry->fd_in_use[idx]);
+		uatomic_dec(&entry->fds[idx].in_use);
 		return NULL;
 	}
-	entry->fd[idx] = fd;
+	entry->fds[idx].fd = fd;
 
 out:
 	sfd = xmalloc(sizeof(*sfd));
-	sfd->fd = entry->fd[idx];
+	sfd->fd = entry->fds[idx].fd;
 	sfd->idx = idx;
 	return sfd;
 }
@@ -316,7 +382,7 @@ static void sockfd_cache_put(struct node_id *nid, int idx)
 	pthread_rwlock_unlock(&sockfd_cache.lock);
 
 	assert(entry);
-	refcnt = uatomic_cmpxchg(&entry->fd_in_use[idx], 1, 0);
+	refcnt = uatomic_cmpxchg(&entry->fds[idx].in_use, 1, 0);
 	assert(refcnt == 1);
 }
 
-- 
1.7.10.2




More information about the sheepdog mailing list