From d6244e238976e45ccb8c64ab4a0fe443fe44c952 Mon Sep 17 00:00:00 2001 From: Brian Foster Date: Thu, 3 May 2012 10:09:27 -0400 Subject: 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 Reviewed-on: http://review.gluster.com/3268 Tested-by: Gluster Build System Reviewed-by: Raghavendra G Reviewed-by: Amar Tumballi Reviewed-by: Jeff Darcy --- xlators/performance/md-cache/src/md-cache.c | 80 ++++++++++++++++++++++++++--- 1 file changed, 74 insertions(+), 6 deletions(-) (limited to 'xlators/performance/md-cache') diff --git a/xlators/performance/md-cache/src/md-cache.c b/xlators/performance/md-cache/src/md-cache.c index 9ef599ad8ba..5fcb583db27 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); } -- cgit