quick-read, md-cache: selectively cache xattr data to conserve memory

The md-cache translator can cache items for a long period of time and
thus is sensitive to memory usage associated with the items it
references. This implements two changes to help conserve memory:

- quick-read - Migrate the file content data to a local dict and
	delete from the xdata dict that passes through the stack.
- md-cache - Create a local dict to selectively store the xattr
	data md-cache is interested in. This includes a slight
	optimization to not allocate an empty dict in the case
	where we have not received any xattr's of interest.

I've tested both changes independently and together by running a
readdirp test against several compiled source trees (~340k files).
The base test results in a 7.7GB RSS on the client. The quick-read
modification cuts RSS down to 4.1GB, which is still large due
to md-cache unintelligently caching a large number of empty
dictionaries. The combined modification cuts RSS down to 462MB
on the same workload.

NOTE: Theoretically the md-cache change should supercede the
quick-read change, but practically I save an extra 150MB or so with
both. I already had the change and consider it an improvement that
quick-read clean up after itself.

BUG: 812876
Change-Id: Id59734d12dd6476b0e32480939e633448adb6884
Signed-off-by: Brian Foster <bfoster@redhat.com>
Reviewed-on: http://review.gluster.com/3268
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Raghavendra G <raghavendra@gluster.com>
Reviewed-by: Amar Tumballi <amarts@redhat.com>
Reviewed-by: Jeff Darcy <jdarcy@redhat.com>

1 files changed, 74 insertions, 6 deletions

diff --git a/xlators/performance/md-cache/src/md-cache.c b/xlators/performance/md-cache/src/md-cache.c
index 9ef599ad8..5fcb583db 100644
--- a/xlators/performance/md-cache/src/md-cache.c
+++ b/xlators/performance/md-cache/src/md-cache.c
@@ -441,12 +441,70 @@ out:
         return ret;
 }
 
+struct updatedict {
+	dict_t *dict;
+	int ret;
+};
+
+static void
+updatefn(dict_t *dict, char *key, data_t *value, void *data)
+{
+	struct updatedict *u = data;
+	const char *mdc_key;
+	int i = 0;
+
+	for (mdc_key = mdc_keys[i].name; (mdc_key = mdc_keys[i].name); i++) {
+		if (!mdc_keys[i].check)
+			continue;
+		if (strcmp(mdc_key, key))
+			continue;
+
+		if (!u->dict) {
+			u->dict = dict_new();
+			if (!u->dict) {
+				u->ret = -1;
+				return;
+			}
+		}
+
+		if (dict_set(u->dict, key, value) < 0) {
+			u->ret = -1;
+			return;
+		}
+
+		break;
+	}
+}
+
+static int
+mdc_dict_update(dict_t **tgt, dict_t *src)
+{
+	struct updatedict u = {
+		.dict = *tgt,
+		.ret = 0,
+	};
+
+	dict_foreach(src, updatefn, &u);
+
+	if (*tgt)
+		return u.ret;
+
+	if ((u.ret < 0) && u.dict) {
+		dict_unref(u.dict);
+		return u.ret;
+	}
+
+	*tgt = u.dict;
+
+	return u.ret;
+}
 
 int
 mdc_inode_xatt_set (xlator_t *this, inode_t *inode, dict_t *dict)
 {
         int              ret = -1;
         struct md_cache *mdc = NULL;
+	dict_t		*newdict = NULL;
 
         mdc = mdc_inode_prep (this, inode);
         if (!mdc)
@@ -457,10 +515,19 @@ mdc_inode_xatt_set (xlator_t *this, inode_t *inode, dict_t *dict)
 
         LOCK (&mdc->lock);
         {
-                if (mdc->xattr)
+                if (mdc->xattr) {
                         dict_unref (mdc->xattr);
+			mdc->xattr = NULL;
+		}
+
+		ret = mdc_dict_update(&newdict, dict);
+		if (ret < 0) {
+			UNLOCK(&mdc->lock);
+			goto out;
+		}
 
-                mdc->xattr = dict_ref (dict);
+		if (newdict)
+			mdc->xattr = newdict;
 
                 time (&mdc->xa_time);
         }
@@ -486,10 +553,11 @@ mdc_inode_xatt_update (xlator_t *this, inode_t *inode, dict_t *dict)
 
         LOCK (&mdc->lock);
         {
-                if (!mdc->xattr)
-                        mdc->xattr = dict_ref (dict);
-                else
-                        dict_copy (dict, mdc->xattr);
+		ret = mdc_dict_update(&mdc->xattr, dict);
+		if (ret < 0) {
+			UNLOCK(&mdc->lock);
+			goto out;
+		}
 
                 time (&mdc->xa_time);
         }