diff options
| -rw-r--r-- | tests/basic/distribute/throttle-rebal.t | 14 | ||||
| -rw-r--r-- | xlators/cluster/dht/src/dht-common.h | 3 | ||||
| -rw-r--r-- | xlators/cluster/dht/src/dht-rebalance.c | 25 | ||||
| -rw-r--r-- | xlators/cluster/dht/src/dht-shared.c | 108 | ||||
| -rw-r--r-- | xlators/mgmt/glusterd/src/glusterd-volume-set.c | 32 |
5 files changed, 152 insertions, 30 deletions
diff --git a/tests/basic/distribute/throttle-rebal.t b/tests/basic/distribute/throttle-rebal.t index 89495aee71b..f4823cf4f21 100644 --- a/tests/basic/distribute/throttle-rebal.t +++ b/tests/basic/distribute/throttle-rebal.t @@ -16,6 +16,11 @@ function set_throttle { $CLI volume set $V0 cluster.rebal-throttle $level 2>&1 |grep -oE 'success|failed' } +#Determine number of cores +cores=$(cat /proc/cpuinfo | grep processor | wc -l) +if [ "$cores" == "" ]; then + echo "Could not get number of cores available" +fi THROTTLE_LEVEL="lazy" EXPECT "success" set_throttle $THROTTLE_LEVEL @@ -36,6 +41,15 @@ EXPECT "failed" set_throttle $THROTTLE_LEVEL #check if throttle-level is still aggressive EXPECT "aggressive" echo `$CLI volume info | grep rebal-throttle | awk '{print $2}'` +EXPECT "success" set_throttle $cores + +#Setting thorttle number to be more than the number of cores should fail +THORTTLE_LEVEL=$((cores+1)) +TEST echo $THORTTLE_LEVEL +EXPECT "failed" set_throttle $THROTTLE_LEVEL +EXPECT "$cores" echo `$CLI volume info | grep rebal-throttle | awk '{print $2}'` + + TEST $CLI volume stop $V0; TEST $CLI volume delete $V0; diff --git a/xlators/cluster/dht/src/dht-common.h b/xlators/cluster/dht/src/dht-common.h index a756a1e579f..c8cec133960 100644 --- a/xlators/cluster/dht/src/dht-common.h +++ b/xlators/cluster/dht/src/dht-common.h @@ -36,6 +36,7 @@ #define DHT_ENTRY_SYNC_DOMAIN "dht.entry.sync" #define TIERING_MIGRATION_KEY "tiering.migration" #define DHT_LAYOUT_HASH_INVALID 1 +#define MAX_REBAL_THREADS sysconf(_SC_NPROCESSORS_ONLN) #define DHT_DIR_STAT_BLOCKS 8 #define DHT_DIR_STAT_SIZE 4096 @@ -614,7 +615,7 @@ struct dht_conf { /* Support size-weighted rebalancing (heterogeneous bricks). */ gf_boolean_t do_weighting; gf_boolean_t randomize_by_gfid; - char *dthrottle; + int dthrottle; dht_methods_t methods; diff --git a/xlators/cluster/dht/src/dht-rebalance.c b/xlators/cluster/dht/src/dht-rebalance.c index 66cd623ea08..1b140dbb8b5 100644 --- a/xlators/cluster/dht/src/dht-rebalance.c +++ b/xlators/cluster/dht/src/dht-rebalance.c @@ -2721,7 +2721,7 @@ gf_defrag_task (void *opaque) defrag->current_thread_count--; gf_log ("DHT", GF_LOG_INFO, "Thread sleeping. " - "defrag->current_thread_count: %d", + "current thread count: %d", defrag->current_thread_count); pthread_cond_wait ( @@ -2729,11 +2729,11 @@ gf_defrag_task (void *opaque) &defrag->dfq_mutex); defrag->current_thread_count++; - gf_log ("DHT", GF_LOG_INFO, "Thread wokeup. " - "defrag->current_thread_count: %d", + "current thread count: %d", defrag->current_thread_count); + } if (defrag->q_entry_count) { @@ -2786,6 +2786,14 @@ gf_defrag_task (void *opaque) finished */ if (!defrag->crawl_done) { + + defrag->current_thread_count--; + gf_log ("DHT", GF_LOG_INFO, "Thread " + " sleeping while waiting for " + "migration entries. current " + "thread count :%d", + defrag->current_thread_count); + pthread_cond_wait ( &defrag->parallel_migration_cond, &defrag->dfq_mutex); @@ -2793,10 +2801,19 @@ gf_defrag_task (void *opaque) if (defrag->crawl_done && !defrag->q_entry_count) { + defrag->current_thread_count++; + gf_msg_debug ("DHT", 0, "Exiting thread"); + pthread_cond_broadcast ( &defrag->parallel_migration_cond); goto unlock; } else { + defrag->current_thread_count++; + gf_msg_debug ("DHT", 0, "Thread woke up" + " as found migrating entries. " + "current thread count:%d", + defrag->current_thread_count); + pthread_mutex_unlock (&defrag->dfq_mutex); continue; @@ -4205,7 +4222,7 @@ gf_defrag_start_crawl (void *data) INIT_LIST_HEAD (&(defrag->queue[0].list)); - thread_spawn_count = MAX ((sysconf(_SC_NPROCESSORS_ONLN) - 4), 4); + thread_spawn_count = MAX (MAX_REBAL_THREADS, 4); gf_msg_debug (this->name, 0, "thread_spawn_count: %d", thread_spawn_count); diff --git a/xlators/cluster/dht/src/dht-shared.c b/xlators/cluster/dht/src/dht-shared.c index f13762e34fb..9c3eb16869c 100644 --- a/xlators/cluster/dht/src/dht-shared.c +++ b/xlators/cluster/dht/src/dht-shared.c @@ -400,7 +400,7 @@ dht_reconfigure (xlator_t *this, dict_t *options) char *temp_str = NULL; gf_boolean_t search_unhashed; int ret = -1; - int throttle_count = 0; + int rebal_thread_count = 0; GF_VALIDATE_OR_GOTO ("dht", this, out); GF_VALIDATE_OR_GOTO ("dht", options, out); @@ -456,22 +456,54 @@ dht_reconfigure (xlator_t *this, dict_t *options) conf->randomize_by_gfid, options, bool, out); - GF_OPTION_RECONF ("rebal-throttle", conf->dthrottle, options, - str, out); - GF_OPTION_RECONF ("lock-migration", conf->lock_migration_enabled, options, bool, out); if (conf->defrag) { + pthread_mutex_lock (&conf->defrag->dfq_mutex); + { + if (dict_get_str (options, "rebal-throttle", &temp_str) == 0) { + if (!strcasecmp (temp_str, "lazy")) { + conf->defrag->recon_thread_count = 1; + } else if (!strcasecmp (temp_str, "normal")) { + conf->defrag->recon_thread_count = 3; + } else if (!strcasecmp (temp_str, "aggressive")) { + conf->defrag->recon_thread_count = MAX ((MAX_REBAL_THREADS - 4), 4); + } else if ((gf_string2int (temp_str, &rebal_thread_count) == 0)) { + if ((rebal_thread_count > 0) && (rebal_thread_count <= MAX_REBAL_THREADS)) { + gf_msg_debug (this->name, 0, "rebal throttle count reconfigured to %d", rebal_thread_count); + conf->defrag->recon_thread_count = rebal_thread_count; + } else { + gf_msg(this->name, GF_LOG_ERROR, 0, + DHT_MSG_INVALID_OPTION, + "Invalid option: Reconfigure: " + "rebal-throttle should be " + "within range of 0 and maximum number of" + " cores available"); + ret = -1; + pthread_mutex_unlock (&conf->defrag->dfq_mutex); + goto out; + } + } else { + gf_msg(this->name, GF_LOG_ERROR, 0, + DHT_MSG_INVALID_OPTION, + "Invalid option: Reconfigure: " + "rebal-throttle should be {lazy|normal|aggressive}" + " or a number upto number of cores available," + " not (%s), defaulting to (%d)", + temp_str, conf->dthrottle); + ret = -1; + pthread_mutex_unlock (&conf->defrag->dfq_mutex); + goto out; + } + } + } + pthread_mutex_unlock (&conf->defrag->dfq_mutex); + } + + if (conf->defrag) { conf->defrag->lock_migration_enabled = conf->lock_migration_enabled; - - GF_DECIDE_DEFRAG_THROTTLE_COUNT (throttle_count, conf); - gf_msg ("DHT", GF_LOG_INFO, 0, - DHT_MSG_REBAL_THROTTLE_INFO, - "conf->dthrottle: %s, " - "conf->defrag->recon_thread_count: %d", - conf->dthrottle, conf->defrag->recon_thread_count); } if (conf->defrag) { @@ -608,8 +640,8 @@ dht_init (xlator_t *this) gf_defrag_info_t *defrag = NULL; int cmd = 0; char *node_uuid = NULL; - int throttle_count = 0; uint32_t commit_hash = 0; + int rebal_thread_count = 0; GF_VALIDATE_OR_GOTO ("dht", this, err); @@ -809,15 +841,49 @@ dht_init (xlator_t *this) conf->randomize_by_gfid, bool, err); if (defrag) { - GF_OPTION_INIT ("rebal-throttle", - conf->dthrottle, str, err); - - GF_DECIDE_DEFRAG_THROTTLE_COUNT(throttle_count, conf); - - gf_msg_debug ("DHT", 0, "conf->dthrottle: %s, " - "conf->defrag->recon_thread_count: %d", - conf->dthrottle, - conf->defrag->recon_thread_count); + GF_OPTION_INIT ("rebal-throttle", temp_str, str, err); + if (temp_str) { + + pthread_mutex_lock (&conf->defrag->dfq_mutex); + { + if (!strcasecmp (temp_str, "lazy")) { + conf->defrag->recon_thread_count = 1; + } else if (!strcasecmp (temp_str, "normal")) { + conf->defrag->recon_thread_count = 2; + } else if (!strcasecmp (temp_str, "aggressive")) { + conf->defrag->recon_thread_count = MAX (MAX_REBAL_THREADS - 4, 4); + } else if ((gf_string2int (temp_str, &rebal_thread_count) == 0)) { + if ((rebal_thread_count > 0) && (rebal_thread_count <= MAX_REBAL_THREADS)) { + gf_msg (this->name, GF_LOG_INFO, 0, 0, + "rebal thread count configured to %d", + rebal_thread_count); + conf->defrag->recon_thread_count = rebal_thread_count; + } else { + gf_msg(this->name, GF_LOG_ERROR, 0, + DHT_MSG_INVALID_OPTION, + "Invalid option: Reconfigure: " + "rebal-throttle should be " + "within range of 0 and maximum number of" + " cores available"); + ret = -1; + pthread_mutex_unlock (&conf->defrag->dfq_mutex); + goto err; + } + } else { + gf_msg(this->name, GF_LOG_ERROR, 0, + DHT_MSG_INVALID_OPTION, + "Invalid option: Reconfigure: " + "rebal-throttle should be {lazy|normal|aggressive}" + " or a number upto number of cores available," + " not (%s), defaulting to (%d)", + temp_str, conf->dthrottle); + ret = -1; + pthread_mutex_unlock (&conf->defrag->dfq_mutex); + goto err; + } + } + pthread_mutex_unlock (&conf->defrag->dfq_mutex); + } } GF_OPTION_INIT ("xattr-name", conf->xattr_name, str, err); diff --git a/xlators/mgmt/glusterd/src/glusterd-volume-set.c b/xlators/mgmt/glusterd/src/glusterd-volume-set.c index 08557d1bd86..728da74b7a6 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volume-set.c +++ b/xlators/mgmt/glusterd/src/glusterd-volume-set.c @@ -546,21 +546,45 @@ static int validate_defrag_throttle_option (glusterd_volinfo_t *volinfo, dict_t *dict, char *key, char *value, char **op_errstr) { - char errstr[2048] = ""; - int ret = 0; - xlator_t *this = NULL; + char errstr[2048] = ""; + int ret = 0; + xlator_t *this = NULL; + int thread_count = 0; + long int cores_available = 0; this = THIS; GF_ASSERT (this); + cores_available = sysconf(_SC_NPROCESSORS_ONLN); + + /* Throttle option should be one of lazy|normal|aggressive or a number + * configured by user max up to the number of cores in the machine */ + if (!strcasecmp (value, "lazy") || !strcasecmp (value, "normal") || !strcasecmp (value, "aggressive")) { ret = 0; + } else if ((gf_string2int (value, &thread_count) == 0)) { + if ((thread_count > 0) && (thread_count <= cores_available)) { + ret = 0; + } else { + ret = -1; + snprintf (errstr, sizeof (errstr), "%s should be within" + " range of 0 and maximum number of cores " + "available (cores available - %ld)", key, + cores_available); + + gf_msg (this->name, GF_LOG_ERROR, EINVAL, + GD_MSG_INVALID_ENTRY, "%s", errstr); + + *op_errstr = gf_strdup (errstr); + } } else { ret = -1; snprintf (errstr, sizeof (errstr), "%s should be " - "{lazy|normal|aggressive}", key); + "{lazy|normal|aggressive} or a number upto number of" + " cores available (cores availble - %ld)", key, + cores_available); gf_msg (this->name, GF_LOG_ERROR, EINVAL, GD_MSG_INVALID_ENTRY, "%s", errstr); *op_errstr = gf_strdup (errstr); |