WT-2858 Rename wtperf's CONFIG structure (#3065)

Also replace key-string generation implementation with a more efficient implementation.

8 files changed, 752 insertions, 739 deletions

diff --git a/bench/wtperf/config.c b/bench/wtperf/config.c
index e4e4886f142..5b14a4cdf68 100644
--- a/bench/wtperf/config.c
+++ b/bench/wtperf/config.c
@@ -168,7 +168,7 @@ config_unescape(char *orig)
  *	Parse the thread configuration.
  */
 static int
-config_threads(CONFIG *cfg, const char *config, size_t len)
+config_threads(WTPERF *wtperf, const char *config, size_t len)
 {
 	WORKLOAD *workp;
 	WT_CONFIG_ITEM groupk, groupv, k, v;
@@ -176,19 +176,19 @@ config_threads(CONFIG *cfg, const char *config, size_t len)
 	int ret;
 
 	group = scan = NULL;
-	if (cfg->workload != NULL) {
+	if (wtperf->workload != NULL) {
 		/*
 		 * This call overrides an earlier call.  Free and
 		 * reset everything.
 		 */
-		free(cfg->workload);
-		cfg->workload = NULL;
-		cfg->workload_cnt = 0;
-		cfg->workers_cnt = 0;
+		free(wtperf->workload);
+		wtperf->workload = NULL;
+		wtperf->workload_cnt = 0;
+		wtperf->workers_cnt = 0;
 	}
 	/* Allocate the workload array. */
-	cfg->workload = dcalloc(WORKLOAD_MAX, sizeof(WORKLOAD));
-	cfg->workload_cnt = 0;
+	wtperf->workload = dcalloc(WORKLOAD_MAX, sizeof(WORKLOAD));
+	wtperf->workload_cnt = 0;
 
 	/*
 	 * The thread configuration may be in multiple groups, that is, we have
@@ -207,14 +207,14 @@ config_threads(CONFIG *cfg, const char *config, size_t len)
 			goto err;
 
 		/* Move to the next workload slot. */
-		if (cfg->workload_cnt == WORKLOAD_MAX) {
+		if (wtperf->workload_cnt == WORKLOAD_MAX) {
 			fprintf(stderr,
 			    "too many workloads configured, only %d workloads "
 			    "supported\n",
 			    WORKLOAD_MAX);
 			return (EINVAL);
 		}
-		workp = &cfg->workload[cfg->workload_cnt++];
+		workp = &wtperf->workload[wtperf->workload_cnt++];
 
 		while ((ret = scan->next(scan, &k, &v)) == 0) {
 			if (STRING_MATCH("count", k.str, k.len)) {
@@ -247,9 +247,9 @@ config_threads(CONFIG *cfg, const char *config, size_t len)
 				if ((workp->truncate = v.val) != 1)
 					goto err;
 				/* There can only be one Truncate thread. */
-				if (F_ISSET(cfg, CFG_TRUNCATE))
+				if (F_ISSET(wtperf, CFG_TRUNCATE))
 					goto err;
-				F_SET(cfg, CFG_TRUNCATE);
+				F_SET(wtperf, CFG_TRUNCATE);
 				continue;
 			}
 			if (STRING_MATCH("truncate_pct", k.str, k.len)) {
@@ -277,13 +277,13 @@ config_threads(CONFIG *cfg, const char *config, size_t len)
 						goto err;
 					/* Special random value */
 					workp->update_delta = INT64_MAX;
-					F_SET(cfg, CFG_GROW);
+					F_SET(wtperf, CFG_GROW);
 				} else {
 					workp->update_delta = v.val;
 					if (v.val > 0)
-						F_SET(cfg, CFG_GROW);
+						F_SET(wtperf, CFG_GROW);
 					if (v.val < 0)
-						F_SET(cfg, CFG_SHRINK);
+						F_SET(wtperf, CFG_SHRINK);
 				}
 				continue;
 			}
@@ -313,7 +313,7 @@ config_threads(CONFIG *cfg, const char *config, size_t len)
 		if (workp->truncate != 0 &&
 		    (workp->insert > 0 || workp->read > 0 || workp->update > 0))
 			goto err;
-		cfg->workers_cnt += (u_int)workp->threads;
+		wtperf->workers_cnt += (u_int)workp->threads;
 	}
 
 	ret = group->close(group);
@@ -341,7 +341,7 @@ err:	if (group != NULL)
  * value.
  */
 static int
-config_opt(CONFIG *cfg, WT_CONFIG_ITEM *k, WT_CONFIG_ITEM *v)
+config_opt(WTPERF *wtperf, WT_CONFIG_ITEM *k, WT_CONFIG_ITEM *v)
 {
 	CONFIG_OPTS *opts;
 	CONFIG_OPT *desc;
@@ -350,7 +350,7 @@ config_opt(CONFIG *cfg, WT_CONFIG_ITEM *k, WT_CONFIG_ITEM *v)
 	size_t i, newlen;
 	void *valueloc;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
 	desc = NULL;
 	for (i = 0; i < WT_ELEMENTS(config_opts_desc); i++)
@@ -446,7 +446,7 @@ config_opt(CONFIG *cfg, WT_CONFIG_ITEM *k, WT_CONFIG_ITEM *v)
 		 */
 		if (v->type == WT_CONFIG_ITEM_STRUCT &&
 		    STRING_MATCH("threads", k->str, k->len))
-			return (config_threads(cfg, v->str, v->len));
+			return (config_threads(wtperf, v->str, v->len));
 
 		if (v->type != WT_CONFIG_ITEM_STRING &&
 		    v->type != WT_CONFIG_ITEM_ID) {
@@ -474,7 +474,7 @@ config_opt(CONFIG *cfg, WT_CONFIG_ITEM *k, WT_CONFIG_ITEM *v)
  * via lines ending in '\'.
  */
 int
-config_opt_file(CONFIG *cfg, const char *filename)
+config_opt_file(WTPERF *wtperf, const char *filename)
 {
 	FILE *fp;
 	size_t linelen, optionpos;
@@ -574,7 +574,7 @@ config_opt_file(CONFIG *cfg, const char *filename)
 		if (contline)
 			optionpos += linelen;
 		else {
-			if ((ret = config_opt_str(cfg, option)) != 0) {
+			if ((ret = config_opt_str(wtperf, option)) != 0) {
 				fprintf(stderr, "wtperf: %s: %d: parse error\n",
 				    filename, linenum);
 				break;
@@ -604,7 +604,7 @@ config_opt_file(CONFIG *cfg, const char *filename)
  * been joined.
  */
 int
-config_opt_str(CONFIG *cfg, const char *optstr)
+config_opt_str(WTPERF *wtperf, const char *optstr)
 {
 	CONFIG_OPTS *opts;
 	CONFIG_QUEUE_ENTRY *config_line;
@@ -613,12 +613,12 @@ config_opt_str(CONFIG *cfg, const char *optstr)
 	size_t len;
 	int ret, t_ret;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
 	len = strlen(optstr);
 	if ((ret = wiredtiger_config_parser_open(
 	    NULL, optstr, len, &scan)) != 0) {
-		lprintf(cfg, ret, 0, "Error in config_scan_begin");
+		lprintf(wtperf, ret, 0, "Error in config_scan_begin");
 		return (ret);
 	}
 
@@ -639,10 +639,10 @@ config_opt_str(CONFIG *cfg, const char *optstr)
 				ret = 0;
 			break;
 		}
-		ret = config_opt(cfg, &k, &v);
+		ret = config_opt(wtperf, &k, &v);
 	}
 	if ((t_ret = scan->close(scan)) != 0) {
-		lprintf(cfg, ret, 0, "Error in config_scan_end");
+		lprintf(wtperf, ret, 0, "Error in config_scan_end");
 		if (ret == 0)
 			ret = t_ret;
 	}
@@ -655,7 +655,7 @@ config_opt_str(CONFIG *cfg, const char *optstr)
  *	Set a name/value configuration pair.
  */
 int
-config_opt_name_value(CONFIG *cfg, const char *name, const char *value)
+config_opt_name_value(WTPERF *wtperf, const char *name, const char *value)
 {
 	size_t len;
 	int ret;
@@ -664,7 +664,7 @@ config_opt_name_value(CONFIG *cfg, const char *name, const char *value)
 	len = strlen(name) + strlen(value) + 4;
 	optstr = dmalloc(len);
 	snprintf(optstr, len, "%s=\"%s\"", name, value);
-	ret = config_opt_str(cfg, optstr);
+	ret = config_opt_str(wtperf, optstr);
 	free(optstr);
 	return (ret);
 }
@@ -674,13 +674,13 @@ config_opt_name_value(CONFIG *cfg, const char *name, const char *value)
  *	Configuration sanity checks.
  */
 int
-config_sanity(CONFIG *cfg)
+config_sanity(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
 	WORKLOAD *workp;
 	u_int i;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
 	/* Various intervals should be less than the run-time. */
 	if (opts->run_time > 0 &&
@@ -710,7 +710,7 @@ config_sanity(CONFIG *cfg)
 	}
 
 	if (opts->value_sz_max < opts->value_sz) {
-		if (F_ISSET(cfg, CFG_GROW)) {
+		if (F_ISSET(wtperf, CFG_GROW)) {
 			fprintf(stderr, "value_sz_max %" PRIu32
 			    " must be greater than or equal to value_sz %"
 			    PRIu32 "\n", opts->value_sz_max, opts->value_sz);
@@ -719,7 +719,7 @@ config_sanity(CONFIG *cfg)
 			opts->value_sz_max = opts->value_sz;
 	}
 	if (opts->value_sz_min > opts->value_sz) {
-		if (F_ISSET(cfg, CFG_SHRINK)) {
+		if (F_ISSET(wtperf, CFG_SHRINK)) {
 			fprintf(stderr, "value_sz_min %" PRIu32
 			    " must be less than or equal to value_sz %"
 			    PRIu32 "\n", opts->value_sz_min, opts->value_sz);
@@ -728,9 +728,9 @@ config_sanity(CONFIG *cfg)
 			opts->value_sz_min = opts->value_sz;
 	}
 
-	if (opts->readonly && cfg->workload != NULL)
-		for (i = 0, workp = cfg->workload;
-		    i < cfg->workload_cnt; ++i, ++workp)
+	if (opts->readonly && wtperf->workload != NULL)
+		for (i = 0, workp = wtperf->workload;
+		    i < wtperf->workload_cnt; ++i, ++workp)
 			if (workp->insert != 0 || workp->update != 0 ||
 			    workp->truncate != 0) {
 				fprintf(stderr,
@@ -809,16 +809,16 @@ config_opt_log(CONFIG_OPTS *opts, const char *path)
  *	Print out the configuration in verbose mode.
  */
 void
-config_opt_print(CONFIG *cfg)
+config_opt_print(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
 	WORKLOAD *workp;
 	u_int i;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
 	printf("Workload configuration:\n");
-	printf("\t" "Home: %s\n", cfg->home);
+	printf("\t" "Home: %s\n", wtperf->home);
 	printf("\t" "Table name: %s\n", opts->table_name);
 	printf("\t" "Connection configuration: %s\n", opts->conn_config);
 	if (opts->sess_config != NULL)
@@ -836,10 +836,10 @@ config_opt_print(CONFIG *cfg)
 
 	printf("\t" "Workload seconds, operations: %" PRIu32 ", %" PRIu32 "\n",
 	    opts->run_time, opts->run_ops);
-	if (cfg->workload != NULL) {
+	if (wtperf->workload != NULL) {
 		printf("\t" "Workload configuration(s):\n");
-		for (i = 0, workp = cfg->workload;
-		    i < cfg->workload_cnt; ++i, ++workp)
+		for (i = 0, workp = wtperf->workload;
+		    i < wtperf->workload_cnt; ++i, ++workp)
 			printf("\t\t%" PRId64 " threads (inserts=%" PRId64
 			    ", reads=%" PRId64 ", updates=%" PRId64
 			    ", truncates=% " PRId64 ")\n",
diff --git a/bench/wtperf/idle_table_cycle.c b/bench/wtperf/idle_table_cycle.c
index ad6b075be77..60855e666b6 100644
--- a/bench/wtperf/idle_table_cycle.c
+++ b/bench/wtperf/idle_table_cycle.c
@@ -29,31 +29,31 @@
 #include "wtperf.h"
 
 static int
-check_timing(CONFIG *cfg,
+check_timing(WTPERF *wtperf,
     const char *name, struct timespec start, struct timespec *stop)
 {
 	CONFIG_OPTS *opts;
 	uint64_t last_interval;
 	int ret;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
 	if ((ret = __wt_epoch(NULL, stop)) != 0) {
-		lprintf(cfg, ret, 0,
+		lprintf(wtperf, ret, 0,
 		    "Get time failed in cycle_idle_tables.");
-		cfg->error = true;
+		wtperf->error = true;
 		return (ret);
 	}
 
 	last_interval = (uint64_t)(WT_TIMEDIFF_SEC(*stop, start));
 
 	if (last_interval > opts->idle_table_cycle) {
-		lprintf(cfg, ret, 0,
+		lprintf(wtperf, ret, 0,
 		    "Cycling idle table failed because %s took %" PRIu64
 		    " seconds which is longer than configured acceptable"
 		    " maximum of %" PRIu32 ".",
 		    name, last_interval, opts->idle_table_cycle);
-		cfg->error = true;
+		wtperf->error = true;
 		return (ETIMEDOUT);
 	}
 	return (0);
@@ -67,34 +67,35 @@ static void *
 cycle_idle_tables(void *arg)
 {
 	struct timespec start, stop;
-	CONFIG *cfg;
 	CONFIG_OPTS *opts;
+	WTPERF *wtperf;
 	WT_CURSOR *cursor;
 	WT_SESSION *session;
 	int cycle_count, ret;
 	char uri[512];
 
-	cfg = (CONFIG *)arg;
-	opts = cfg->opts;
+	wtperf = (WTPERF *)arg;
+	opts = wtperf->opts;
 	cycle_count = 0;
 
-	if ((ret = cfg->conn->open_session(
-	    cfg->conn, NULL, opts->sess_config, &session)) != 0) {
-		lprintf(cfg, ret, 0,
-		    "Error opening a session on %s", cfg->home);
+	if ((ret = wtperf->conn->open_session(
+	    wtperf->conn, NULL, opts->sess_config, &session)) != 0) {
+		lprintf(wtperf, ret, 0,
+		    "Error opening a session on %s", wtperf->home);
 		return (NULL);
 	}
 
-	for (cycle_count = 0; cfg->idle_cycle_run; ++cycle_count) {
-		snprintf(uri, 512, "%s_cycle%07d", cfg->uris[0], cycle_count);
+	for (cycle_count = 0; wtperf->idle_cycle_run; ++cycle_count) {
+		snprintf(uri, sizeof(uri),
+		    "%s_cycle%07d", wtperf->uris[0], cycle_count);
 		/* Don't busy cycle in this loop. */
 		__wt_sleep(1, 0);
 
 		/* Setup a start timer. */
 		if ((ret = __wt_epoch(NULL, &start)) != 0) {
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			     "Get time failed in cycle_idle_tables.");
-			cfg->error = true;
+			wtperf->error = true;
 			return (NULL);
 		}
 
@@ -103,30 +104,30 @@ cycle_idle_tables(void *arg)
 		    session, uri, opts->table_config)) != 0) {
 			if (ret == EBUSY)
 				continue;
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			     "Table create failed in cycle_idle_tables.");
-			cfg->error = true;
+			wtperf->error = true;
 			return (NULL);
 		}
-		if (check_timing(cfg, "create", start, &stop) != 0)
+		if (check_timing(wtperf, "create", start, &stop) != 0)
 			return (NULL);
 		start = stop;
 
 		/* Open and close cursor. */
 		if ((ret = session->open_cursor(
 		    session, uri, NULL, NULL, &cursor)) != 0) {
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			     "Cursor open failed in cycle_idle_tables.");
-			cfg->error = true;
+			wtperf->error = true;
 			return (NULL);
 		}
 		if ((ret = cursor->close(cursor)) != 0) {
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			     "Cursor close failed in cycle_idle_tables.");
-			cfg->error = true;
+			wtperf->error = true;
 			return (NULL);
 		}
-		if (check_timing(cfg, "cursor", start, &stop) != 0)
+		if (check_timing(wtperf, "cursor", start, &stop) != 0)
 			return (NULL);
 		start = stop;
 
@@ -139,12 +140,12 @@ cycle_idle_tables(void *arg)
 			__wt_sleep(1, 0);
 
 		if (ret != 0 && ret != EBUSY) {
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			     "Table drop failed in cycle_idle_tables.");
-			cfg->error = true;
+			wtperf->error = true;
 			return (NULL);
 		}
-		if (check_timing(cfg, "drop", start, &stop) != 0)
+		if (check_timing(wtperf, "drop", start, &stop) != 0)
 			return (NULL);
 	}
 
@@ -159,22 +160,23 @@ cycle_idle_tables(void *arg)
  * initialization isn't necessary.
  */
 int
-start_idle_table_cycle(CONFIG *cfg, pthread_t *idle_table_cycle_thread)
+start_idle_table_cycle(WTPERF *wtperf, pthread_t *idle_table_cycle_thread)
 {
 	CONFIG_OPTS *opts;
 	pthread_t thread_id;
 	int ret;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
 	if (opts->idle_table_cycle == 0)
 		return (0);
 
-	cfg->idle_cycle_run = true;
+	wtperf->idle_cycle_run = true;
 	if ((ret = pthread_create(
-	    &thread_id, NULL, cycle_idle_tables, cfg)) != 0) {
-		lprintf(cfg, ret, 0, "Error creating idle table cycle thread.");
-		cfg->idle_cycle_run = false;
+	    &thread_id, NULL, cycle_idle_tables, wtperf)) != 0) {
+		lprintf(wtperf,
+		    ret, 0, "Error creating idle table cycle thread.");
+		wtperf->idle_cycle_run = false;
 		return (ret);
 	}
 	*idle_table_cycle_thread = thread_id;
@@ -183,20 +185,20 @@ start_idle_table_cycle(CONFIG *cfg, pthread_t *idle_table_cycle_thread)
 }
 
 int
-stop_idle_table_cycle(CONFIG *cfg, pthread_t idle_table_cycle_thread)
+stop_idle_table_cycle(WTPERF *wtperf, pthread_t idle_table_cycle_thread)
 {
 	CONFIG_OPTS *opts;
 	int ret;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
-	if (opts->idle_table_cycle == 0 || !cfg->idle_cycle_run)
+	if (opts->idle_table_cycle == 0 || !wtperf->idle_cycle_run)
 		return (0);
 
-	cfg->idle_cycle_run = false;
+	wtperf->idle_cycle_run = false;
 	if ((ret = pthread_join(idle_table_cycle_thread, NULL)) != 0) {
 		lprintf(
-		    cfg, ret, 0, "Error joining idle table cycle thread.");
+		    wtperf, ret, 0, "Error joining idle table cycle thread.");
 		return (ret);
 	}
 	return (0);
diff --git a/bench/wtperf/misc.c b/bench/wtperf/misc.c
index 6c1113a687d..24b3323a49a 100644
--- a/bench/wtperf/misc.c
+++ b/bench/wtperf/misc.c
@@ -30,33 +30,34 @@
 
 /* Setup the logging output mechanism. */
 int
-setup_log_file(CONFIG *cfg)
+setup_log_file(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
 	size_t len;
 	int ret;
 	char *fname;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 	ret = 0;
 
 	if (opts->verbose < 1)
 		return (0);
 
-	len = strlen(cfg->monitor_dir) +
+	len = strlen(wtperf->monitor_dir) +
 	    strlen(opts->table_name) + strlen(".stat") + 2;
 	fname = dmalloc(len);
-	snprintf(fname, len, "%s/%s.stat", cfg->monitor_dir, opts->table_name);
-	if ((cfg->logf = fopen(fname, "w")) == NULL) {
+	snprintf(fname, len,
+	    "%s/%s.stat", wtperf->monitor_dir, opts->table_name);
+	if ((wtperf->logf = fopen(fname, "w")) == NULL) {
 		ret = errno;
 		fprintf(stderr, "%s: %s\n", fname, strerror(ret));
 	}
 	free(fname);
-	if (cfg->logf == NULL)
+	if (wtperf->logf == NULL)
 		return (ret);
 
 	/* Use line buffering for the log file. */
-	__wt_stream_set_line_buffer(cfg->logf);
+	__wt_stream_set_line_buffer(wtperf->logf);
 	return (0);
 }
 
@@ -64,18 +65,18 @@ setup_log_file(CONFIG *cfg)
  * Log printf - output a log message.
  */
 void
-lprintf(const CONFIG *cfg, int err, uint32_t level, const char *fmt, ...)
+lprintf(const WTPERF *wtperf, int err, uint32_t level, const char *fmt, ...)
 {
 	CONFIG_OPTS *opts;
 	va_list ap;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
 	if (err == 0 && level <= opts->verbose) {
 		va_start(ap, fmt);
-		vfprintf(cfg->logf, fmt, ap);
+		vfprintf(wtperf->logf, fmt, ap);
 		va_end(ap);
-		fprintf(cfg->logf, "\n");
+		fprintf(wtperf->logf, "\n");
 
 		if (level < opts->verbose) {
 			va_start(ap, fmt);
@@ -92,11 +93,11 @@ lprintf(const CONFIG *cfg, int err, uint32_t level, const char *fmt, ...)
 	vfprintf(stderr, fmt, ap);
 	va_end(ap);
 	fprintf(stderr, " Error: %s\n", wiredtiger_strerror(err));
-	if (cfg->logf != NULL) {
+	if (wtperf->logf != NULL) {
 		va_start(ap, fmt);
-		vfprintf(cfg->logf, fmt, ap);
+		vfprintf(wtperf->logf, fmt, ap);
 		va_end(ap);
-		fprintf(cfg->logf, " Error: %s\n", wiredtiger_strerror(err));
+		fprintf(wtperf->logf, " Error: %s\n", wiredtiger_strerror(err));
 	}
 
 	/* Never attempt to continue if we got a panic from WiredTiger. */
diff --git a/bench/wtperf/track.c b/bench/wtperf/track.c
index 0464d22fb79..822bdaa4b4a 100644
--- a/bench/wtperf/track.c
+++ b/bench/wtperf/track.c
@@ -32,17 +32,17 @@
  * Return total insert operations for the populate phase.
  */
 uint64_t
-sum_pop_ops(CONFIG *cfg)
+sum_pop_ops(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
-	CONFIG_THREAD *thread;
+	WTPERF_THREAD *thread;
 	uint64_t total;
 	u_int i;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 	total = 0;
 
-	for (i = 0, thread = cfg->popthreads;
+	for (i = 0, thread = wtperf->popthreads;
 	    thread != NULL && i < opts->populate_threads; ++i, ++thread)
 		total += thread->insert.ops;
 	return (total);
@@ -52,17 +52,17 @@ sum_pop_ops(CONFIG *cfg)
  * Return total checkpoint operations.
  */
 uint64_t
-sum_ckpt_ops(CONFIG *cfg)
+sum_ckpt_ops(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
-	CONFIG_THREAD *thread;
+	WTPERF_THREAD *thread;
 	uint64_t total;
 	u_int i;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 	total = 0;
 
-	for (i = 0, thread = cfg->ckptthreads;
+	for (i = 0, thread = wtperf->ckptthreads;
 	    thread != NULL && i < opts->checkpoint_threads; ++i, ++thread)
 		total += thread->ckpt.ops;
 	return (total);
@@ -72,21 +72,21 @@ sum_ckpt_ops(CONFIG *cfg)
  * Return total operations count for the worker threads.
  */
 static uint64_t
-sum_ops(CONFIG *cfg, size_t field_offset)
+sum_ops(WTPERF *wtperf, size_t field_offset)
 {
 	CONFIG_OPTS *opts;
-	CONFIG_THREAD *thread;
+	WTPERF_THREAD *thread;
 	uint64_t total;
 	int64_t i, th_cnt;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 	total = 0;
 
-	if (cfg->popthreads == NULL) {
-		thread = cfg->workers;
-		th_cnt = cfg->workers_cnt;
+	if (wtperf->popthreads == NULL) {
+		thread = wtperf->workers;
+		th_cnt = wtperf->workers_cnt;
 	} else {
-		thread = cfg->popthreads;
+		thread = wtperf->popthreads;
 		th_cnt = opts->populate_threads;
 	}
 	for (i = 0; thread != NULL && i < th_cnt; ++i, ++thread)
@@ -95,24 +95,24 @@ sum_ops(CONFIG *cfg, size_t field_offset)
 	return (total);
 }
 uint64_t
-sum_insert_ops(CONFIG *cfg)
+sum_insert_ops(WTPERF *wtperf)
 {
-	return (sum_ops(cfg, offsetof(CONFIG_THREAD, insert)));
+	return (sum_ops(wtperf, offsetof(WTPERF_THREAD, insert)));
 }
 uint64_t
-sum_read_ops(CONFIG *cfg)
+sum_read_ops(WTPERF *wtperf)
 {
-	return (sum_ops(cfg, offsetof(CONFIG_THREAD, read)));
+	return (sum_ops(wtperf, offsetof(WTPERF_THREAD, read)));
 }
 uint64_t
-sum_truncate_ops(CONFIG *cfg)
+sum_truncate_ops(WTPERF *wtperf)
 {
-	return (sum_ops(cfg, offsetof(CONFIG_THREAD, truncate)));
+	return (sum_ops(wtperf, offsetof(WTPERF_THREAD, truncate)));
 }
 uint64_t
-sum_update_ops(CONFIG *cfg)
+sum_update_ops(WTPERF *wtperf)
 {
-	return (sum_ops(cfg, offsetof(CONFIG_THREAD, update)));
+	return (sum_ops(wtperf, offsetof(WTPERF_THREAD, update)));
 }
 
 /*
@@ -121,26 +121,26 @@ sum_update_ops(CONFIG *cfg)
  * particular operation.
  */
 static void
-latency_op(CONFIG *cfg,
+latency_op(WTPERF *wtperf,
     size_t field_offset, uint32_t *avgp, uint32_t *minp, uint32_t *maxp)
 {
 	CONFIG_OPTS *opts;
-	CONFIG_THREAD *thread;
 	TRACK *track;
+	WTPERF_THREAD *thread;
 	uint64_t ops, latency, tmp;
 	int64_t i, th_cnt;
 	uint32_t max, min;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 	ops = latency = 0;
 	max = 0;
 	min = UINT32_MAX;
 
-	if (cfg->popthreads == NULL) {
-		thread = cfg->workers;
-		th_cnt = cfg->workers_cnt;
+	if (wtperf->popthreads == NULL) {
+		thread = wtperf->workers;
+		th_cnt = wtperf->workers_cnt;
 	} else {
-		thread = cfg->popthreads;
+		thread = wtperf->popthreads;
 		th_cnt = opts->populate_threads;
 	}
 	for (i = 0; thread != NULL && i < th_cnt; ++i, ++thread) {
@@ -169,11 +169,11 @@ latency_op(CONFIG *cfg,
 	}
 }
 void
-latency_read(CONFIG *cfg, uint32_t *avgp, uint32_t *minp, uint32_t *maxp)
+latency_read(WTPERF *wtperf, uint32_t *avgp, uint32_t *minp, uint32_t *maxp)
 {
 	static uint32_t last_avg = 0, last_max = 0, last_min = 0;
 
-	latency_op(cfg, offsetof(CONFIG_THREAD, read), avgp, minp, maxp);
+	latency_op(wtperf, offsetof(WTPERF_THREAD, read), avgp, minp, maxp);
 
 	/*
 	 * If nothing happened, graph the average, minimum and maximum as they
@@ -190,11 +190,11 @@ latency_read(CONFIG *cfg, uint32_t *avgp, uint32_t *minp, uint32_t *maxp)
 	}
 }
 void
-latency_insert(CONFIG *cfg, uint32_t *avgp, uint32_t *minp, uint32_t *maxp)
+latency_insert(WTPERF *wtperf, uint32_t *avgp, uint32_t *minp, uint32_t *maxp)
 {
 	static uint32_t last_avg = 0, last_max = 0, last_min = 0;
 
-	latency_op(cfg, offsetof(CONFIG_THREAD, insert), avgp, minp, maxp);
+	latency_op(wtperf, offsetof(WTPERF_THREAD, insert), avgp, minp, maxp);
 
 	/*
 	 * If nothing happened, graph the average, minimum and maximum as they
@@ -211,11 +211,11 @@ latency_insert(CONFIG *cfg, uint32_t *avgp, uint32_t *minp, uint32_t *maxp)
 	}
 }
 void
-latency_update(CONFIG *cfg, uint32_t *avgp, uint32_t *minp, uint32_t *maxp)
+latency_update(WTPERF *wtperf, uint32_t *avgp, uint32_t *minp, uint32_t *maxp)
 {
 	static uint32_t last_avg = 0, last_max = 0, last_min = 0;
 
-	latency_op(cfg, offsetof(CONFIG_THREAD, update), avgp, minp, maxp);
+	latency_op(wtperf, offsetof(WTPERF_THREAD, update), avgp, minp, maxp);
 
 	/*
 	 * If nothing happened, graph the average, minimum and maximum as they
@@ -237,17 +237,17 @@ latency_update(CONFIG *cfg, uint32_t *avgp, uint32_t *minp, uint32_t *maxp)
  *	Sum latency for a set of threads.
  */
 static void
-sum_latency(CONFIG *cfg, size_t field_offset, TRACK *total)
+sum_latency(WTPERF *wtperf, size_t field_offset, TRACK *total)
 {
-	CONFIG_THREAD *thread;
+	WTPERF_THREAD *thread;
 	TRACK *trk;
 	int64_t i;
 	u_int j;
 
 	memset(total, 0, sizeof(*total));
 
-	for (i = 0, thread = cfg->workers;
-	    thread != NULL && i < cfg->workers_cnt; ++i, ++thread) {
+	for (i = 0, thread = wtperf->workers;
+	    thread != NULL && i < wtperf->workers_cnt; ++i, ++thread) {
 		trk = (TRACK *)((uint8_t *)thread + field_offset);
 
 		for (j = 0; j < ELEMENTS(trk->us); ++j) {
@@ -265,32 +265,33 @@ sum_latency(CONFIG *cfg, size_t field_offset, TRACK *total)
 	}
 }
 static void
-sum_insert_latency(CONFIG *cfg, TRACK *total)
+sum_insert_latency(WTPERF *wtperf, TRACK *total)
 {
-	sum_latency(cfg, offsetof(CONFIG_THREAD, insert), total);
+	sum_latency(wtperf, offsetof(WTPERF_THREAD, insert), total);
 }
 static void
-sum_read_latency(CONFIG *cfg, TRACK *total)
+sum_read_latency(WTPERF *wtperf, TRACK *total)
 {
-	sum_latency(cfg, offsetof(CONFIG_THREAD, read), total);
+	sum_latency(wtperf, offsetof(WTPERF_THREAD, read), total);
 }
 static void
-sum_update_latency(CONFIG *cfg, TRACK *total)
+sum_update_latency(WTPERF *wtperf, TRACK *total)
 {
-	sum_latency(cfg, offsetof(CONFIG_THREAD, update), total);
+	sum_latency(wtperf, offsetof(WTPERF_THREAD, update), total);
 }
 
 static void
-latency_print_single(CONFIG *cfg, TRACK *total, const char *name)
+latency_print_single(WTPERF *wtperf, TRACK *total, const char *name)
 {
 	FILE *fp;
 	u_int i;
 	uint64_t cumops;
 	char path[1024];
 
-	snprintf(path, sizeof(path), "%s/latency.%s", cfg->monitor_dir, name);
+	snprintf(path, sizeof(path),
+	    "%s/latency.%s", wtperf->monitor_dir, name);
 	if ((fp = fopen(path, "w")) == NULL) {
-		lprintf(cfg, errno, 0, "%s", path);
+		lprintf(wtperf, errno, 0, "%s", path);
 		return;
 	}
 
@@ -326,14 +327,14 @@ latency_print_single(CONFIG *cfg, TRACK *total, const char *name)
 }
 
 void
-latency_print(CONFIG *cfg)
+latency_print(WTPERF *wtperf)
 {
 	TRACK total;
 
-	sum_insert_latency(cfg, &total);
-	latency_print_single(cfg, &total, "insert");
-	sum_read_latency(cfg, &total);
-	latency_print_single(cfg, &total, "read");
-	sum_update_latency(cfg, &total);
-	latency_print_single(cfg, &total, "update");
+	sum_insert_latency(wtperf, &total);
+	latency_print_single(wtperf, &total, "insert");
+	sum_read_latency(wtperf, &total);
+	latency_print_single(wtperf, &total, "read");
+	sum_update_latency(wtperf, &total);
+	latency_print_single(wtperf, &total, "update");
 }
diff --git a/bench/wtperf/wtperf.c b/bench/wtperf/wtperf.c
index a0840eb83c0..6a2c9acb126 100644
--- a/bench/wtperf/wtperf.c
+++ b/bench/wtperf/wtperf.c
@@ -36,33 +36,33 @@ static const char * const debug_cconfig = "";
 static const char * const debug_tconfig = "";
 
 static void	*checkpoint_worker(void *);
-static int	 drop_all_tables(CONFIG *);
-static int	 execute_populate(CONFIG *);
-static int	 execute_workload(CONFIG *);
-static int	 find_table_count(CONFIG *);
+static int	 drop_all_tables(WTPERF *);
+static int	 execute_populate(WTPERF *);
+static int	 execute_workload(WTPERF *);
+static int	 find_table_count(WTPERF *);
 static void	*monitor(void *);
 static void	*populate_thread(void *);
-static void	 randomize_value(CONFIG_THREAD *, char *);
+static void	 randomize_value(WTPERF_THREAD *, char *);
 static void	 recreate_dir(const char *);
-static int	 start_all_runs(CONFIG *);
-static int	 start_run(CONFIG *);
-static int	 start_threads(CONFIG *,
-		    WORKLOAD *, CONFIG_THREAD *, u_int, void *(*)(void *));
-static int	 stop_threads(CONFIG *, u_int, CONFIG_THREAD *);
+static int	 start_all_runs(WTPERF *);
+static int	 start_run(WTPERF *);
+static int	 start_threads(WTPERF *,
+		    WORKLOAD *, WTPERF_THREAD *, u_int, void *(*)(void *));
+static int	 stop_threads(WTPERF *, u_int, WTPERF_THREAD *);
 static void	*thread_run_wtperf(void *);
-static void	 update_value_delta(CONFIG_THREAD *);
+static void	 update_value_delta(WTPERF_THREAD *);
 static void	*worker(void *);
 
-static uint64_t	 wtperf_rand(CONFIG_THREAD *);
-static uint64_t	 wtperf_value_range(CONFIG *);
+static uint64_t	 wtperf_rand(WTPERF_THREAD *);
+static uint64_t	 wtperf_value_range(WTPERF *);
 
 #define	INDEX_COL_NAMES	"columns=(key,val)"
 
 /* Retrieve an ID for the next insert operation. */
 static inline uint64_t
-get_next_incr(CONFIG *cfg)
+get_next_incr(WTPERF *wtperf)
 {
-	return (__wt_atomic_add64(&cfg->insert_key, 1));
+	return (__wt_atomic_add64(&wtperf->insert_key, 1));
 }
 
 /*
@@ -70,13 +70,13 @@ get_next_incr(CONFIG *cfg)
  * other element in the value buffer.
  */
 static void
-randomize_value(CONFIG_THREAD *thread, char *value_buf)
+randomize_value(WTPERF_THREAD *thread, char *value_buf)
 {
 	CONFIG_OPTS *opts;
 	uint8_t *vb;
 	uint32_t i, max_range, rand_val;
 
-	opts = thread->cfg->opts;
+	opts = thread->wtperf->opts;
 
 	/*
 	 * Limit how much of the buffer we validate for length, this means
@@ -120,12 +120,8 @@ randomize_value(CONFIG_THREAD *thread, char *value_buf)
  * Partition data by key ranges.
  */
 static uint32_t
-map_key_to_table(CONFIG *cfg, uint64_t k)
+map_key_to_table(CONFIG_OPTS *opts, uint64_t k)
 {
-	CONFIG_OPTS *opts;
-
-	opts = cfg->opts;
-
 	if (opts->range_partition) {
 		/* Take care to return a result in [0..table_count-1]. */
 		if (k > opts->icount + opts->random_range)
@@ -143,15 +139,15 @@ map_key_to_table(CONFIG *cfg, uint64_t k)
  * scratch buffer.
  */
 static inline void
-update_value_delta(CONFIG_THREAD *thread)
+update_value_delta(WTPERF_THREAD *thread)
 {
-	CONFIG *cfg;
 	CONFIG_OPTS *opts;
+	WTPERF *wtperf;
 	char * value;
 	int64_t delta, len, new_len;
 
-	cfg = thread->cfg;
-	opts = cfg->opts;
+	wtperf = thread->wtperf;
+	opts = wtperf->opts;
 	value = thread->value_buf;
 	delta = thread->workload->update_delta;
 	len = (int64_t)strlen(value);
@@ -184,24 +180,24 @@ update_value_delta(CONFIG_THREAD *thread)
 static int
 cb_asyncop(WT_ASYNC_CALLBACK *cb, WT_ASYNC_OP *op, int ret, uint32_t flags)
 {
-	CONFIG *cfg;
-	CONFIG_THREAD *thread;
 	TRACK *trk;
+	WTPERF *wtperf;
+	WTPERF_THREAD *thread;
 	WT_ASYNC_OPTYPE type;
-	char *value;
 	uint32_t *tables;
 	int t_ret;
+	char *value;
 
 	(void)cb;
 	(void)flags;
 
-	cfg = NULL;			/* -Wconditional-uninitialized */
+	wtperf = NULL;			/* -Wconditional-uninitialized */
 	thread = NULL;			/* -Wconditional-uninitialized */
 
 	type = op->get_type(op);
 	if (type != WT_AOP_COMPACT) {
-		thread = (CONFIG_THREAD *)op->app_private;
-		cfg = thread->cfg;
+		thread = (WTPERF_THREAD *)op->app_private;
+		wtperf = thread->wtperf;
 	}
 
 	trk = NULL;
@@ -218,7 +214,7 @@ cb_asyncop(WT_ASYNC_CALLBACK *cb, WT_ASYNC_OP *op, int ret, uint32_t flags)
 		if (ret == 0 &&
 		    (t_ret = op->get_value(op, &value)) != 0) {
 			ret = t_ret;
-			lprintf(cfg, ret, 0, "get_value in read.");
+			lprintf(wtperf, ret, 0, "get_value in read.");
 			goto err;
 		}
 		break;
@@ -228,7 +224,8 @@ cb_asyncop(WT_ASYNC_CALLBACK *cb, WT_ASYNC_OP *op, int ret, uint32_t flags)
 	case WT_AOP_NONE:
 	case WT_AOP_REMOVE:
 		/* We never expect this type. */
-		lprintf(cfg, ret, 0, "No type in op %" PRIu64, op->get_id(op));
+		lprintf(wtperf,
+		    ret, 0, "No type in op %" PRIu64, op->get_id(op));
 		goto err;
 	}
 
@@ -242,15 +239,14 @@ cb_asyncop(WT_ASYNC_CALLBACK *cb, WT_ASYNC_OP *op, int ret, uint32_t flags)
 	if (type == WT_AOP_COMPACT)
 		return (0);
 	if (ret == 0 || (ret == WT_NOTFOUND && type != WT_AOP_INSERT)) {
-		if (!cfg->in_warmup)
+		if (!wtperf->in_warmup)
 			(void)__wt_atomic_add64(&trk->ops, 1);
 		return (0);
 	}
 err:
 	/* Panic if error */
-	lprintf(cfg, ret, 0, "Error in op %" PRIu64,
-	    op->get_id(op));
-	cfg->error = cfg->stop = true;
+	lprintf(wtperf, ret, 0, "Error in op %" PRIu64, op->get_id(op));
+	wtperf->error = wtperf->stop = true;
 	return (1);
 }
 
@@ -322,9 +318,9 @@ op_name(uint8_t *op)
 static void *
 worker_async(void *arg)
 {
-	CONFIG *cfg;
 	CONFIG_OPTS *opts;
-	CONFIG_THREAD *thread;
+	WTPERF *wtperf;
+	WTPERF_THREAD *thread;
 	WT_ASYNC_OP *asyncop;
 	WT_CONNECTION *conn;
 	uint64_t next_val;
@@ -332,10 +328,10 @@ worker_async(void *arg)
 	int ret;
 	char *key_buf, *value_buf;
 
-	thread = (CONFIG_THREAD *)arg;
-	cfg = thread->cfg;
-	opts = cfg->opts;
-	conn = cfg->conn;
+	thread = (WTPERF_THREAD *)arg;
+	wtperf = thread->wtperf;
+	opts = wtperf->opts;
+	conn = wtperf->conn;
 
 	key_buf = thread->key_buf;
 	value_buf = thread->value_buf;
@@ -343,7 +339,7 @@ worker_async(void *arg)
 	op = thread->workload->ops;
 	op_end = op + sizeof(thread->workload->ops);
 
-	while (!cfg->stop) {
+	while (!wtperf->stop) {
 		/*
 		 * Generate the next key and setup operation specific
 		 * statistics tracking objects.
@@ -354,7 +350,7 @@ worker_async(void *arg)
 			if (opts->random_range)
 				next_val = wtperf_rand(thread);
 			else
-				next_val = opts->icount + get_next_incr(cfg);
+				next_val = opts->icount + get_next_incr(wtperf);
 			break;
 		case WORKER_READ:
 		case WORKER_UPDATE:
@@ -365,22 +361,22 @@ worker_async(void *arg)
 			 * we rely on at least one insert to get a valid item
 			 * id.
 			 */
-			if (wtperf_value_range(cfg) < next_val)
+			if (wtperf_value_range(wtperf) < next_val)
 				continue;
 			break;
 		default:
 			goto err;		/* can't happen */
 		}
 
-		generate_key(cfg, key_buf, next_val);
+		generate_key(opts, key_buf, next_val);
 
 		/*
 		 * Spread the data out around the multiple databases.
 		 * Sleep to allow workers a chance to run and process async ops.
 		 * Then retry to get an async op.
 		 */
-		while ((ret = conn->async_new_op(
-		    conn, cfg->uris[map_key_to_table(cfg, next_val)],
+		while ((ret = conn->async_new_op(conn,
+		    wtperf->uris[map_key_to_table(wtperf->opts, next_val)],
 		    NULL, &cb, &asyncop)) == EBUSY)
 			(void)usleep(10000);
 		if (ret != 0)
@@ -409,9 +405,9 @@ worker_async(void *arg)
 				break;
 			goto op_err;
 		default:
-op_err:			lprintf(cfg, ret, 0,
+op_err:			lprintf(wtperf, ret, 0,
 			    "%s failed for: %s, range: %"PRIu64,
-			    op_name(op), key_buf, wtperf_value_range(cfg));
+			    op_name(op), key_buf, wtperf_value_range(wtperf));
 			goto err;		/* can't happen */
 		}
 
@@ -425,7 +421,7 @@ op_err:			lprintf(cfg, ret, 0,
 
 	/* Notify our caller we failed and shut the system down. */
 	if (0) {
-err:		cfg->error = cfg->stop = true;
+err:		wtperf->error = wtperf->stop = true;
 	}
 	return (NULL);
 }
@@ -436,7 +432,7 @@ err:		cfg->error = cfg->stop = true;
  *	search do them. Ensuring the keys we see are always in order.
  */
 static int
-do_range_reads(CONFIG *cfg, WT_CURSOR *cursor)
+do_range_reads(WTPERF *wtperf, WT_CURSOR *cursor)
 {
 	CONFIG_OPTS *opts;
 	size_t range;
@@ -445,7 +441,7 @@ do_range_reads(CONFIG *cfg, WT_CURSOR *cursor)
 	char buf[512];
 	int ret;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 	ret = 0;
 
 	if (opts->read_range == 0)
@@ -469,7 +465,7 @@ do_range_reads(CONFIG *cfg, WT_CURSOR *cursor)
 		testutil_check(cursor->get_key(cursor, &range_key_buf));
 		extract_key(range_key_buf, &next_val);
 		if (next_val < prev_val) {
-			lprintf(cfg, EINVAL, 0,
+			lprintf(wtperf, EINVAL, 0,
 			    "Out of order keys %" PRIu64
 			    " came before %" PRIu64,
 			    prev_val, next_val);
@@ -483,10 +479,10 @@ static void *
 worker(void *arg)
 {
 	struct timespec start, stop;
-	CONFIG *cfg;
 	CONFIG_OPTS *opts;
-	CONFIG_THREAD *thread;
 	TRACK *trk;
+	WTPERF *wtperf;
+	WTPERF_THREAD *thread;
 	WT_CONNECTION *conn;
 	WT_CURSOR **cursors, *cursor, *log_table_cursor, *tmp_cursor;
 	WT_SESSION *session;
@@ -498,10 +494,10 @@ worker(void *arg)
 	char *value_buf, *key_buf, *value;
 	char buf[512];
 
-	thread = (CONFIG_THREAD *)arg;
-	cfg = thread->cfg;
-	opts = cfg->opts;
-	conn = cfg->conn;
+	thread = (WTPERF_THREAD *)arg;
+	wtperf = thread->wtperf;
+	opts = wtperf->opts;
+	conn = wtperf->conn;
 	cursors = NULL;
 	log_table_cursor = NULL;	/* -Wconditional-initialized */
 	ops = 0;
@@ -511,38 +507,38 @@ worker(void *arg)
 
 	if ((ret = conn->open_session(
 	    conn, NULL, opts->sess_config, &session)) != 0) {
-		lprintf(cfg, ret, 0, "worker: WT_CONNECTION.open_session");
+		lprintf(wtperf, ret, 0, "worker: WT_CONNECTION.open_session");
 		goto err;
 	}
 	cursors = dcalloc(opts->table_count, sizeof(WT_CURSOR *));
 	for (i = 0; i < opts->table_count_idle; i++) {
-		snprintf(buf, 512, "%s_idle%05d", cfg->uris[0], (int)i);
+		snprintf(buf, 512, "%s_idle%05d", wtperf->uris[0], (int)i);
 		if ((ret = session->open_cursor(
 		    session, buf, NULL, NULL, &tmp_cursor)) != 0) {
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			    "Error opening idle table %s", buf);
 			goto err;
 		}
 		if ((ret = tmp_cursor->close(tmp_cursor)) != 0) {
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			    "Error closing idle table %s", buf);
 			goto err;
 		}
 	}
 	for (i = 0; i < opts->table_count; i++) {
 		if ((ret = session->open_cursor(session,
-		    cfg->uris[i], NULL, NULL, &cursors[i])) != 0) {
-			lprintf(cfg, ret, 0,
+		    wtperf->uris[i], NULL, NULL, &cursors[i])) != 0) {
+			lprintf(wtperf, ret, 0,
 			    "worker: WT_SESSION.open_cursor: %s",
-			    cfg->uris[i]);
+			    wtperf->uris[i]);
 			goto err;
 		}
 	}
-	if (opts->log_like_table &&
-	    (ret = session->open_cursor(
-	    session, cfg->log_table_uri, NULL, NULL, &log_table_cursor)) != 0) {
-		lprintf(cfg, ret, 0,
-		    "worker: WT_SESSION.open_cursor: %s", cfg->log_table_uri);
+	if (opts->log_like_table && (ret = session->open_cursor(session,
+	    wtperf->log_table_uri, NULL, NULL, &log_table_cursor)) != 0) {
+		lprintf(wtperf, ret, 0,
+		    "worker: WT_SESSION.open_cursor: %s",
+		    wtperf->log_table_uri);
 		goto err;
 	}
 
@@ -552,7 +548,7 @@ worker(void *arg)
 
 	/* Setup for truncate */
 	if (thread->workload->truncate != 0)
-		if ((ret = setup_truncate(cfg, thread, session)) != 0)
+		if ((ret = setup_truncate(wtperf, thread, session)) != 0)
 			goto err;
 
 	key_buf = thread->key_buf;
@@ -563,11 +559,11 @@ worker(void *arg)
 
 	if ((ops_per_txn != 0 || opts->log_like_table) &&
 		(ret = session->begin_transaction(session, NULL)) != 0) {
-		lprintf(cfg, ret, 0, "First transaction begin failed");
+		lprintf(wtperf, ret, 0, "First transaction begin failed");
 		goto err;
 	}
 
-	while (!cfg->stop) {
+	while (!wtperf->stop) {
 		/*
 		 * Generate the next key and setup operation specific
 		 * statistics tracking objects.
@@ -579,7 +575,7 @@ worker(void *arg)
 			if (opts->random_range)
 				next_val = wtperf_rand(thread);
 			else
-				next_val = opts->icount + get_next_incr(cfg);
+				next_val = opts->icount + get_next_incr(wtperf);
 			break;
 		case WORKER_READ:
 			trk = &thread->read;
@@ -594,7 +590,7 @@ worker(void *arg)
 			 * we rely on at least one insert to get a valid item
 			 * id.
 			 */
-			if (wtperf_value_range(cfg) < next_val)
+			if (wtperf_value_range(wtperf) < next_val)
 				continue;
 			break;
 		case WORKER_TRUNCATE:
@@ -605,12 +601,12 @@ worker(void *arg)
 			goto err;		/* can't happen */
 		}
 
-		generate_key(cfg, key_buf, next_val);
+		generate_key(opts, key_buf, next_val);
 
 		/*
 		 * Spread the data out around the multiple databases.
 		 */
-		cursor = cursors[map_key_to_table(cfg, next_val)];
+		cursor = cursors[map_key_to_table(wtperf->opts, next_val)];
 
 		/*
 		 * Skip the first time we do an operation, when trk->ops
@@ -620,7 +616,7 @@ worker(void *arg)
 		    opts->sample_interval != 0 && trk != NULL &&
 		    trk->ops != 0 && (trk->ops % opts->sample_rate == 0);
 		if (measure_latency && (ret = __wt_epoch(NULL, &start)) != 0) {
-			lprintf(cfg, ret, 0, "Get time call failed");
+			lprintf(wtperf, ret, 0, "Get time call failed");
 			goto err;
 		}
 
@@ -639,7 +635,7 @@ worker(void *arg)
 			if (ret == 0) {
 				if ((ret = cursor->get_value(
 				    cursor, &value)) != 0) {
-					lprintf(cfg, ret, 0,
+					lprintf(wtperf, ret, 0,
 					    "get_value in read.");
 					goto err;
 				}
@@ -648,7 +644,7 @@ worker(void *arg)
 				 * for several operations, confirming that the
 				 * next key is in the correct order.
 				 */
-				ret = do_range_reads(cfg, cursor);
+				ret = do_range_reads(wtperf, cursor);
 			}
 
 			if (ret == 0 || ret == WT_NOTFOUND)
@@ -670,8 +666,8 @@ worker(void *arg)
 				break;
 			goto op_err;
 		case WORKER_TRUNCATE:
-			if ((ret = run_truncate(
-			    cfg, thread, cursor, session, &truncated)) == 0) {
+			if ((ret = run_truncate(wtperf,
+			    thread, cursor, session, &truncated)) == 0) {
 				if (truncated)
 					trk = &thread->truncate;
 				else
@@ -685,7 +681,7 @@ worker(void *arg)
 			if ((ret = cursor->search(cursor)) == 0) {
 				if ((ret = cursor->get_value(
 				    cursor, &value)) != 0) {
-					lprintf(cfg, ret, 0,
+					lprintf(wtperf, ret, 0,
 					    "get_value in update.");
 					goto err;
 				}
@@ -729,26 +725,26 @@ op_err:			if (ret == WT_ROLLBACK && ops_per_txn != 0) {
 				 * order in cases of ordered inserts, as we
 				 * aren't retrying here.
 				 */
-				lprintf(cfg, ret, 1,
+				lprintf(wtperf, ret, 1,
 				    "%s for: %s, range: %"PRIu64, op_name(op),
-				    key_buf, wtperf_value_range(cfg));
+				    key_buf, wtperf_value_range(wtperf));
 				if ((ret = session->rollback_transaction(
 				    session, NULL)) != 0) {
-					lprintf(cfg, ret, 0,
+					lprintf(wtperf, ret, 0,
 					     "Failed rollback_transaction");
 					goto err;
 				}
 				if ((ret = session->begin_transaction(
 				    session, NULL)) != 0) {
-					lprintf(cfg, ret, 0,
+					lprintf(wtperf, ret, 0,
 					    "Worker begin transaction failed");
 					goto err;
 				}
 				break;
 			}
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			    "%s failed for: %s, range: %"PRIu64,
-			    op_name(op), key_buf, wtperf_value_range(cfg));
+			    op_name(op), key_buf, wtperf_value_range(wtperf));
 			goto err;
 		default:
 			goto err;		/* can't happen */
@@ -757,13 +753,14 @@ op_err:			if (ret == WT_ROLLBACK && ops_per_txn != 0) {
 		/* Update the log-like table. */
 		if (opts->log_like_table &&
 		    (*op != WORKER_READ && *op != WORKER_TRUNCATE)) {
-			log_id = __wt_atomic_add64(&cfg->log_like_table_key, 1);
+			log_id =
+			    __wt_atomic_add64(&wtperf->log_like_table_key, 1);
 			log_table_cursor->set_key(log_table_cursor, log_id);
 			log_table_cursor->set_value(
 			    log_table_cursor, value_buf);
 			if ((ret =
 			    log_table_cursor->insert(log_table_cursor)) != 0) {
-				lprintf(cfg, ret, 0, "Cursor insert failed");
+				lprintf(wtperf, ret, 0, "Cursor insert failed");
 				goto err;
 			}
 		}
@@ -772,16 +769,16 @@ op_err:			if (ret == WT_ROLLBACK && ops_per_txn != 0) {
 		if (opts->table_count > 1 && ret == 0 &&
 		    *op != WORKER_INSERT && *op != WORKER_INSERT_RMW) {
 			if ((ret = cursor->reset(cursor)) != 0) {
-				lprintf(cfg, ret, 0, "Cursor reset failed");
+				lprintf(wtperf, ret, 0, "Cursor reset failed");
 				goto err;
 			}
 		}
 
 		/* Gather statistics */
-		if (!cfg->in_warmup) {
+		if (!wtperf->in_warmup) {
 			if (measure_latency) {
 				if ((ret = __wt_epoch(NULL, &stop)) != 0) {
-					lprintf(cfg, ret, 0,
+					lprintf(wtperf, ret, 0,
 					    "Get time call failed");
 					goto err;
 				}
@@ -801,13 +798,13 @@ op_err:			if (ret == WT_ROLLBACK && ops_per_txn != 0) {
 		    (ops_per_txn != 0 && ops++ % ops_per_txn == 0)) {
 			if ((ret = session->commit_transaction(
 			    session, NULL)) != 0) {
-				lprintf(cfg, ret, 0,
+				lprintf(wtperf, ret, 0,
 				    "Worker transaction commit failed");
 				goto err;
 			}
 			if ((ret = session->begin_transaction(
 			    session, NULL)) != 0) {
-				lprintf(cfg, ret, 0,
+				lprintf(wtperf, ret, 0,
 				    "Worker begin transaction failed");
 				goto err;
 			}
@@ -827,13 +824,13 @@ op_err:			if (ret == WT_ROLLBACK && ops_per_txn != 0) {
 	}
 
 	if ((ret = session->close(session, NULL)) != 0) {
-		lprintf(cfg, ret, 0, "Session close in worker failed");
+		lprintf(wtperf, ret, 0, "Session close in worker failed");
 		goto err;
 	}
 
 	/* Notify our caller we failed and shut the system down. */
 	if (0) {
-err:		cfg->error = cfg->stop = true;
+err:		wtperf->error = wtperf->stop = true;
 	}
 	free(cursors);
 
@@ -886,17 +883,17 @@ run_mix_schedule_op(WORKLOAD *workp, int op, int64_t op_cnt)
  *	Schedule the mixed-run operations.
  */
 static int
-run_mix_schedule(CONFIG *cfg, WORKLOAD *workp)
+run_mix_schedule(WTPERF *wtperf, WORKLOAD *workp)
 {
 	CONFIG_OPTS *opts;
 	int64_t pct;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
 	/* Confirm reads, inserts, truncates and updates cannot all be zero. */
 	if (workp->insert == 0 && workp->read == 0 &&
 	    workp->truncate == 0 && workp->update == 0) {
-		lprintf(cfg, EINVAL, 0, "no operations scheduled");
+		lprintf(wtperf, EINVAL, 0, "no operations scheduled");
 		return (EINVAL);
 	}
 
@@ -907,7 +904,7 @@ run_mix_schedule(CONFIG *cfg, WORKLOAD *workp)
 	if (workp->truncate != 0) {
 		if (workp->insert != 0 ||
 		    workp->read != 0 || workp->update != 0) {
-			lprintf(cfg, EINVAL, 0,
+			lprintf(wtperf, EINVAL, 0,
 			    "Can't configure truncate in a mixed workload");
 			return (EINVAL);
 		}
@@ -967,10 +964,10 @@ static void *
 populate_thread(void *arg)
 {
 	struct timespec start, stop;
-	CONFIG *cfg;
 	CONFIG_OPTS *opts;
-	CONFIG_THREAD *thread;
 	TRACK *trk;
+	WTPERF *wtperf;
+	WTPERF_THREAD *thread;
 	WT_CONNECTION *conn;
 	WT_CURSOR **cursors, *cursor;
 	WT_SESSION *session;
@@ -981,10 +978,10 @@ populate_thread(void *arg)
 	char *value_buf, *key_buf;
 	const char *cursor_config;
 
-	thread = (CONFIG_THREAD *)arg;
-	cfg = thread->cfg;
-	opts = cfg->opts;
-	conn = cfg->conn;
+	thread = (WTPERF_THREAD *)arg;
+	wtperf = thread->wtperf;
+	opts = wtperf->opts;
+	conn = wtperf->conn;
 	session = NULL;
 	cursors = NULL;
 	ret = stress_checkpoint_due = 0;
@@ -995,7 +992,7 @@ populate_thread(void *arg)
 
 	if ((ret = conn->open_session(
 	    conn, NULL, opts->sess_config, &session)) != 0) {
-		lprintf(cfg, ret, 0, "populate: WT_CONNECTION.open_session");
+		lprintf(wtperf, ret, 0, "populate: WT_CONNECTION.open_session");
 		goto err;
 	}
 
@@ -1006,25 +1003,25 @@ populate_thread(void *arg)
 	cursors = dcalloc(opts->table_count, sizeof(WT_CURSOR *));
 	for (i = 0; i < opts->table_count; i++) {
 		if ((ret = session->open_cursor(
-		    session, cfg->uris[i], NULL,
+		    session, wtperf->uris[i], NULL,
 		    cursor_config, &cursors[i])) != 0) {
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			    "populate: WT_SESSION.open_cursor: %s",
-			    cfg->uris[i]);
+			    wtperf->uris[i]);
 			goto err;
 		}
 	}
 
 	/* Populate the databases. */
 	for (intxn = 0, opcount = 0;;) {
-		op = get_next_incr(cfg);
+		op = get_next_incr(wtperf);
 		if (op > opts->icount)
 			break;
 
 		if (opts->populate_ops_per_txn != 0 && !intxn) {
 			if ((ret = session->begin_transaction(
 			    session, opts->transaction_config)) != 0) {
-				lprintf(cfg, ret, 0,
+				lprintf(wtperf, ret, 0,
 				    "Failed starting transaction.");
 				goto err;
 			}
@@ -1033,13 +1030,13 @@ populate_thread(void *arg)
 		/*
 		 * Figure out which table this op belongs to.
 		 */
-		cursor = cursors[map_key_to_table(cfg, op)];
-		generate_key(cfg, key_buf, op);
+		cursor = cursors[map_key_to_table(wtperf->opts, op)];
+		generate_key(opts, key_buf, op);
 		measure_latency =
 		    opts->sample_interval != 0 &&
 		    trk->ops != 0 && (trk->ops % opts->sample_rate == 0);
 		if (measure_latency && (ret = __wt_epoch(NULL, &start)) != 0) {
-			lprintf(cfg, ret, 0, "Get time call failed");
+			lprintf(wtperf, ret, 0, "Get time call failed");
 			goto err;
 		}
 		cursor->set_key(cursor, key_buf);
@@ -1047,17 +1044,17 @@ populate_thread(void *arg)
 			randomize_value(thread, value_buf);
 		cursor->set_value(cursor, value_buf);
 		if ((ret = cursor->insert(cursor)) == WT_ROLLBACK) {
-			lprintf(cfg, ret, 0, "insert retrying");
+			lprintf(wtperf, ret, 0, "insert retrying");
 			if ((ret = session->rollback_transaction(
 			    session, NULL)) != 0) {
-				lprintf(cfg, ret, 0,
+				lprintf(wtperf, ret, 0,
 				    "Failed rollback_transaction");
 				goto err;
 			}
 			intxn = 0;
 			continue;
 		} else if (ret != 0) {
-			lprintf(cfg, ret, 0, "Failed inserting");
+			lprintf(wtperf, ret, 0, "Failed inserting");
 			goto err;
 		}
 		/*
@@ -1068,7 +1065,7 @@ populate_thread(void *arg)
 		 */
 		if (measure_latency) {
 			if ((ret = __wt_epoch(NULL, &stop)) != 0) {
-				lprintf(cfg, ret, 0, "Get time call failed");
+				lprintf(wtperf, ret, 0, "Get time call failed");
 				goto err;
 			}
 			++trk->latency_ops;
@@ -1088,7 +1085,7 @@ populate_thread(void *arg)
 
 			if ((ret = session->commit_transaction(
 			    session, NULL)) != 0)
-				lprintf(cfg, ret, 0,
+				lprintf(wtperf, ret, 0,
 				    "Fail committing, transaction was aborted");
 			intxn = 0;
 		}
@@ -1096,24 +1093,24 @@ populate_thread(void *arg)
 		if (stress_checkpoint_due && intxn == 0) {
 			stress_checkpoint_due = 0;
 			if ((ret = session->checkpoint(session, NULL)) != 0) {
-				lprintf(cfg, ret, 0, "Checkpoint failed");
+				lprintf(wtperf, ret, 0, "Checkpoint failed");
 				goto err;
 			}
 		}
 	}
 	if (intxn &&
 	    (ret = session->commit_transaction(session, NULL)) != 0)
-		lprintf(cfg, ret, 0,
+		lprintf(wtperf, ret, 0,
 		    "Fail committing, transaction was aborted");
 
 	if ((ret = session->close(session, NULL)) != 0) {
-		lprintf(cfg, ret, 0, "Error closing session in populate");
+		lprintf(wtperf, ret, 0, "Error closing session in populate");
 		goto err;
 	}
 
 	/* Notify our caller we failed and shut the system down. */
 	if (0) {
-err:		cfg->error = cfg->stop = true;
+err:		wtperf->error = wtperf->stop = true;
 	}
 	free(cursors);
 
@@ -1124,10 +1121,10 @@ static void *
 populate_async(void *arg)
 {
 	struct timespec start, stop;
-	CONFIG *cfg;
 	CONFIG_OPTS *opts;
-	CONFIG_THREAD *thread;
 	TRACK *trk;
+	WTPERF *wtperf;
+	WTPERF_THREAD *thread;
 	WT_ASYNC_OP *asyncop;
 	WT_CONNECTION *conn;
 	WT_SESSION *session;
@@ -1135,10 +1132,10 @@ populate_async(void *arg)
 	int measure_latency, ret;
 	char *value_buf, *key_buf;
 
-	thread = (CONFIG_THREAD *)arg;
-	cfg = thread->cfg;
-	opts = cfg->opts;
-	conn = cfg->conn;
+	thread = (WTPERF_THREAD *)arg;
+	wtperf = thread->wtperf;
+	opts = wtperf->opts;
+	conn = wtperf->conn;
 	session = NULL;
 	ret = 0;
 	trk = &thread->insert;
@@ -1148,7 +1145,7 @@ populate_async(void *arg)
 
 	if ((ret = conn->open_session(
 	    conn, NULL, opts->sess_config, &session)) != 0) {
-		lprintf(cfg, ret, 0, "populate: WT_CONNECTION.open_session");
+		lprintf(wtperf, ret, 0, "populate: WT_CONNECTION.open_session");
 		goto err;
 	}
 
@@ -1161,32 +1158,32 @@ populate_async(void *arg)
 	    opts->sample_interval != 0 &&
 	    trk->ops != 0 && (trk->ops % opts->sample_rate == 0);
 	if (measure_latency && (ret = __wt_epoch(NULL, &start)) != 0) {
-		lprintf(cfg, ret, 0, "Get time call failed");
+		lprintf(wtperf, ret, 0, "Get time call failed");
 		goto err;
 	}
 	/* Populate the databases. */
 	for (;;) {
-		op = get_next_incr(cfg);
+		op = get_next_incr(wtperf);
 		if (op > opts->icount)
 			break;
 		/*
 		 * Allocate an async op for whichever table.
 		 */
 		while ((ret = conn->async_new_op(
-		    conn, cfg->uris[map_key_to_table(cfg, op)],
+		    conn, wtperf->uris[map_key_to_table(wtperf->opts, op)],
 		    NULL, &cb, &asyncop)) == EBUSY)
 			(void)usleep(10000);
 		if (ret != 0)
 			goto err;
 
 		asyncop->app_private = thread;
-		generate_key(cfg, key_buf, op);
+		generate_key(opts, key_buf, op);
 		asyncop->set_key(asyncop, key_buf);
 		if (opts->random_value)
 			randomize_value(thread, value_buf);
 		asyncop->set_value(asyncop, value_buf);
 		if ((ret = asyncop->insert(asyncop)) != 0) {
-			lprintf(cfg, ret, 0, "Failed inserting");
+			lprintf(wtperf, ret, 0, "Failed inserting");
 			goto err;
 		}
 	}
@@ -1202,7 +1199,7 @@ populate_async(void *arg)
 		goto err;
 	if (measure_latency) {
 		if ((ret = __wt_epoch(NULL, &stop)) != 0) {
-			lprintf(cfg, ret, 0, "Get time call failed");
+			lprintf(wtperf, ret, 0, "Get time call failed");
 			goto err;
 		}
 		++trk->latency_ops;
@@ -1210,13 +1207,13 @@ populate_async(void *arg)
 		track_operation(trk, usecs);
 	}
 	if ((ret = session->close(session, NULL)) != 0) {
-		lprintf(cfg, ret, 0, "Error closing session in populate");
+		lprintf(wtperf, ret, 0, "Error closing session in populate");
 		goto err;
 	}
 
 	/* Notify our caller we failed and shut the system down. */
 	if (0) {
-err:		cfg->error = cfg->stop = true;
+err:		wtperf->error = wtperf->stop = true;
 	}
 	return (NULL);
 }
@@ -1226,9 +1223,9 @@ monitor(void *arg)
 {
 	struct timespec t;
 	struct tm *tm, _tm;
-	CONFIG *cfg;
 	CONFIG_OPTS *opts;
 	FILE *fp;
+	WTPERF *wtperf;
 	size_t len;
 	uint64_t min_thr, reads, inserts, updates;
 	uint64_t cur_reads, cur_inserts, cur_updates;
@@ -1242,8 +1239,8 @@ monitor(void *arg)
 	const char *str;
 	char buf[64], *path;
 
-	cfg = (CONFIG *)arg;
-	opts = cfg->opts;
+	wtperf = (WTPERF *)arg;
+	opts = wtperf->opts;
 	assert(opts->sample_interval != 0);
 
 	fp = NULL;
@@ -1253,11 +1250,11 @@ monitor(void *arg)
 	latency_max = (uint32_t)ms_to_us(opts->max_latency);
 
 	/* Open the logging file. */
-	len = strlen(cfg->monitor_dir) + 100;
+	len = strlen(wtperf->monitor_dir) + 100;
 	path = dmalloc(len);
-	snprintf(path, len, "%s/monitor", cfg->monitor_dir);
+	snprintf(path, len, "%s/monitor", wtperf->monitor_dir);
 	if ((fp = fopen(path, "w")) == NULL) {
-		lprintf(cfg, errno, 0, "%s", path);
+		lprintf(wtperf, errno, 0, "%s", path);
 		goto err;
 	}
 	/* Set line buffering for monitor file. */
@@ -1280,31 +1277,31 @@ monitor(void *arg)
 	    "update maximum latency(uS)"
 	    "\n");
 	last_reads = last_inserts = last_updates = 0;
-	while (!cfg->stop) {
+	while (!wtperf->stop) {
 		for (i = 0; i < opts->sample_interval; i++) {
 			sleep(1);
-			if (cfg->stop)
+			if (wtperf->stop)
 				break;
 		}
 		/* If the workers are done, don't bother with a final call. */
-		if (cfg->stop)
+		if (wtperf->stop)
 			break;
-		if (cfg->in_warmup)
+		if (wtperf->in_warmup)
 			continue;
 
 		if ((ret = __wt_epoch(NULL, &t)) != 0) {
-			lprintf(cfg, ret, 0, "Get time call failed");
+			lprintf(wtperf, ret, 0, "Get time call failed");
 			goto err;
 		}
 		tm = localtime_r(&t.tv_sec, &_tm);
 		(void)strftime(buf, sizeof(buf), "%b %d %H:%M:%S", tm);
 
-		reads = sum_read_ops(cfg);
-		inserts = sum_insert_ops(cfg);
-		updates = sum_update_ops(cfg);
-		latency_read(cfg, &read_avg, &read_min, &read_max);
-		latency_insert(cfg, &insert_avg, &insert_min, &insert_max);
-		latency_update(cfg, &update_avg, &update_min, &update_max);
+		reads = sum_read_ops(wtperf);
+		inserts = sum_insert_ops(wtperf);
+		updates = sum_update_ops(wtperf);
+		latency_read(wtperf, &read_avg, &read_min, &read_max);
+		latency_insert(wtperf, &insert_avg, &insert_min, &insert_max);
+		latency_update(wtperf, &update_avg, &update_min, &update_max);
 
 		cur_reads = (reads - last_reads) / opts->sample_interval;
 		cur_updates = (updates - last_updates) / opts->sample_interval;
@@ -1327,9 +1324,9 @@ monitor(void *arg)
 		    ",%" PRIu32 ",%" PRIu32 ",%" PRIu32
 		    ",%" PRIu32 ",%" PRIu32 ",%" PRIu32
 		    "\n",
-		    buf, cfg->totalsec,
+		    buf, wtperf->totalsec,
 		    cur_reads, cur_inserts, cur_updates,
-		    cfg->ckpt ? 'Y' : 'N',
+		    wtperf->ckpt ? 'Y' : 'N',
 		    read_avg, read_min, read_max,
 		    insert_avg, insert_min, insert_max,
 		    update_avg, update_min, update_max);
@@ -1346,7 +1343,7 @@ monitor(void *arg)
 				msg_err = 0;
 				str = "WARNING";
 			}
-			lprintf(cfg, msg_err, level,
+			lprintf(wtperf, msg_err, level,
 			    "%s: max latency exceeded: threshold %" PRIu32
 			    " read max %" PRIu32 " insert max %" PRIu32
 			    " update max %" PRIu32, str, latency_max,
@@ -1365,7 +1362,7 @@ monitor(void *arg)
 				msg_err = 0;
 				str = "WARNING";
 			}
-			lprintf(cfg, msg_err, level,
+			lprintf(wtperf, msg_err, level,
 			    "%s: minimum throughput not met: threshold %" PRIu64
 			    " reads %" PRIu64 " inserts %" PRIu64
 			    " updates %" PRIu64, str, min_thr, cur_reads,
@@ -1378,7 +1375,7 @@ monitor(void *arg)
 
 	/* Notify our caller we failed and shut the system down. */
 	if (0) {
-err:		cfg->error = cfg->stop = true;
+err:		wtperf->error = wtperf->stop = true;
 	}
 
 	if (fp != NULL)
@@ -1391,78 +1388,80 @@ err:		cfg->error = cfg->stop = true;
 static void *
 checkpoint_worker(void *arg)
 {
-	CONFIG *cfg;
 	CONFIG_OPTS *opts;
-	CONFIG_THREAD *thread;
+	WTPERF *wtperf;
+	WTPERF_THREAD *thread;
 	WT_CONNECTION *conn;
 	WT_SESSION *session;
 	struct timespec e, s;
 	uint32_t i;
 	int ret;
 
-	thread = (CONFIG_THREAD *)arg;
-	cfg = thread->cfg;
-	opts = cfg->opts;
-	conn = cfg->conn;
+	thread = (WTPERF_THREAD *)arg;
+	wtperf = thread->wtperf;
+	opts = wtperf->opts;
+	conn = wtperf->conn;
 	session = NULL;
 
 	if ((ret = conn->open_session(
 	    conn, NULL, opts->sess_config, &session)) != 0) {
-		lprintf(cfg, ret, 0,
+		lprintf(wtperf, ret, 0,
 		    "open_session failed in checkpoint thread.");
 		goto err;
 	}
 
-	while (!cfg->stop) {
+	while (!wtperf->stop) {
 		/* Break the sleep up, so we notice interrupts faster. */
 		for (i = 0; i < opts->checkpoint_interval; i++) {
 			sleep(1);
-			if (cfg->stop)
+			if (wtperf->stop)
 				break;
 		}
 		/* If the workers are done, don't bother with a final call. */
-		if (cfg->stop)
+		if (wtperf->stop)
 			break;
 
 		if ((ret = __wt_epoch(NULL, &s)) != 0) {
-			lprintf(cfg, ret, 0, "Get time failed in checkpoint.");
+			lprintf(wtperf,
+			    ret, 0, "Get time failed in checkpoint.");
 			goto err;
 		}
-		cfg->ckpt = true;
+		wtperf->ckpt = true;
 		if ((ret = session->checkpoint(session, NULL)) != 0) {
-			lprintf(cfg, ret, 0, "Checkpoint failed.");
+			lprintf(wtperf, ret, 0, "Checkpoint failed.");
 			goto err;
 		}
-		cfg->ckpt = false;
+		wtperf->ckpt = false;
 		++thread->ckpt.ops;
 
 		if ((ret = __wt_epoch(NULL, &e)) != 0) {
-			lprintf(cfg, ret, 0, "Get time failed in checkpoint.");
+			lprintf(wtperf,
+			    ret, 0, "Get time failed in checkpoint.");
 			goto err;
 		}
 	}
 
 	if (session != NULL &&
 	    ((ret = session->close(session, NULL)) != 0)) {
-		lprintf(cfg, ret, 0,
+		lprintf(wtperf, ret, 0,
 		    "Error closing session in checkpoint worker.");
 		goto err;
 	}
 
 	/* Notify our caller we failed and shut the system down. */
 	if (0) {
-err:		cfg->error = cfg->stop = true;
+err:		wtperf->error = wtperf->stop = true;
 	}
 
 	return (NULL);
 }
 
 static int
-execute_populate(CONFIG *cfg)
+execute_populate(WTPERF *wtperf)
 {
 	struct timespec start, stop;
 	CONFIG_OPTS *opts;
-	CONFIG_THREAD *popth;
+	WTPERF_THREAD *popth;
 	WT_ASYNC_OP *asyncop;
 	pthread_t idle_table_cycle_thread;
 	size_t i;
@@ -1472,37 +1471,38 @@ execute_populate(CONFIG *cfg)
 	int elapsed, ret;
 	void *(*pfunc)(void *);
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
-	lprintf(cfg, 0, 1,
+	lprintf(wtperf, 0, 1,
 	    "Starting %" PRIu32
 	    " populate thread(s) for %" PRIu32 " items",
 	    opts->populate_threads, opts->icount);
 
 	/* Start cycling idle tables if configured. */
-	if ((ret = start_idle_table_cycle(cfg, &idle_table_cycle_thread)) != 0)
+	if ((ret =
+	    start_idle_table_cycle(wtperf, &idle_table_cycle_thread)) != 0)
 		return (ret);
 
-	cfg->insert_key = 0;
+	wtperf->insert_key = 0;
 
-	cfg->popthreads =
-	    dcalloc(opts->populate_threads, sizeof(CONFIG_THREAD));
-	if (cfg->use_asyncops) {
-		lprintf(cfg, 0, 1, "Starting %" PRIu32 " async thread(s)",
+	wtperf->popthreads =
+	    dcalloc(opts->populate_threads, sizeof(WTPERF_THREAD));
+	if (wtperf->use_asyncops) {
+		lprintf(wtperf, 0, 1, "Starting %" PRIu32 " async thread(s)",
 		    opts->async_threads);
 		pfunc = populate_async;
 	} else
 		pfunc = populate_thread;
-	if ((ret = start_threads(cfg, NULL,
-	    cfg->popthreads, opts->populate_threads, pfunc)) != 0)
+	if ((ret = start_threads(wtperf, NULL,
+	    wtperf->popthreads, opts->populate_threads, pfunc)) != 0)
 		return (ret);
 
 	if ((ret = __wt_epoch(NULL, &start)) != 0) {
-		lprintf(cfg, ret, 0, "Get time failed in populate.");
+		lprintf(wtperf, ret, 0, "Get time failed in populate.");
 		return (ret);
 	}
 	for (elapsed = 0, interval = 0, last_ops = 0;
-	    cfg->insert_key < opts->icount && !cfg->error;) {
+	    wtperf->insert_key < opts->icount && !wtperf->error;) {
 		/*
 		 * Sleep for 100th of a second, report_interval is in second
 		 * granularity, each 100th increment of elapsed is a single
@@ -1515,17 +1515,17 @@ execute_populate(CONFIG *cfg)
 		if (++interval < opts->report_interval)
 			continue;
 		interval = 0;
-		cfg->totalsec += opts->report_interval;
-		cfg->insert_ops = sum_pop_ops(cfg);
-		lprintf(cfg, 0, 1,
+		wtperf->totalsec += opts->report_interval;
+		wtperf->insert_ops = sum_pop_ops(wtperf);
+		lprintf(wtperf, 0, 1,
 		    "%" PRIu64 " populate inserts (%" PRIu64 " of %"
 		    PRIu32 ") in %" PRIu32 " secs (%" PRIu32 " total secs)",
-		    cfg->insert_ops - last_ops, cfg->insert_ops,
-		    opts->icount, opts->report_interval, cfg->totalsec);
-		last_ops = cfg->insert_ops;
+		    wtperf->insert_ops - last_ops, wtperf->insert_ops,
+		    opts->icount, opts->report_interval, wtperf->totalsec);
+		last_ops = wtperf->insert_ops;
 	}
 	if ((ret = __wt_epoch(NULL, &stop)) != 0) {
-		lprintf(cfg, ret, 0, "Get time failed in populate.");
+		lprintf(wtperf, ret, 0, "Get time failed in populate.");
 		return (ret);
 	}
 
@@ -1535,21 +1535,22 @@ execute_populate(CONFIG *cfg)
 	 * NULL when the populate phase is finished, to know that the workload
 	 * phase has started.
 	 */
-	popth = cfg->popthreads;
-	cfg->popthreads = NULL;
-	ret = stop_threads(cfg, opts->populate_threads, popth);
+	popth = wtperf->popthreads;
+	wtperf->popthreads = NULL;
+	ret = stop_threads(wtperf, opts->populate_threads, popth);
 	free(popth);
 	if (ret != 0)
 		return (ret);
 
 	/* Report if any worker threads didn't finish. */
-	if (cfg->error) {
-		lprintf(cfg, WT_ERROR, 0,
+	if (wtperf->error) {
+		lprintf(wtperf, WT_ERROR, 0,
 		    "Populate thread(s) exited without finishing.");
 		return (WT_ERROR);
 	}
 
-	lprintf(cfg, 0, 1, "Finished load of %" PRIu32 " items", opts->icount);
+	lprintf(wtperf,
+	    0, 1, "Finished load of %" PRIu32 " items", opts->icount);
 	msecs = WT_TIMEDIFF_MS(stop, start);
 
 	/*
@@ -1563,7 +1564,7 @@ execute_populate(CONFIG *cfg)
 		print_secs = (double)msecs / (double)MSEC_PER_SEC;
 		print_ops_sec = (uint64_t)(opts->icount / print_secs);
 	}
-	lprintf(cfg, 0, 1,
+	lprintf(wtperf, 0, 1,
 	    "Load time: %.2f\n" "load ops/sec: %" PRIu64,
 	    print_secs, print_ops_sec);
 
@@ -1574,9 +1575,9 @@ execute_populate(CONFIG *cfg)
 	 */
 	if (opts->compact) {
 		assert(opts->async_threads > 0);
-		lprintf(cfg, 0, 1, "Compact after populate");
+		lprintf(wtperf, 0, 1, "Compact after populate");
 		if ((ret = __wt_epoch(NULL, &start)) != 0) {
-			lprintf(cfg, ret, 0, "Get time failed in populate.");
+			lprintf(wtperf, ret, 0, "Get time failed in populate.");
 			return (ret);
 		}
 		tables = opts->table_count;
@@ -1585,46 +1586,48 @@ execute_populate(CONFIG *cfg)
 			 * If no ops are available, retry.  Any other error,
 			 * return.
 			 */
-			 while ((ret = cfg->conn->async_new_op(cfg->conn,
-			    cfg->uris[i], "timeout=0", &cb, &asyncop)) == EBUSY)
+			 while ((ret = wtperf->conn->async_new_op(
+			     wtperf->conn, wtperf->uris[i],
+			     "timeout=0", &cb, &asyncop)) == EBUSY)
 				(void)usleep(10000);
 			if (ret != 0)
 				return (ret);
 
 			asyncop->app_private = &tables;
 			if ((ret = asyncop->compact(asyncop)) != 0) {
-				lprintf(cfg, ret, 0, "Async compact failed.");
+				lprintf(wtperf,
+				    ret, 0, "Async compact failed.");
 				return (ret);
 			}
 		}
-		if ((ret = cfg->conn->async_flush(cfg->conn)) != 0) {
-			lprintf(cfg, ret, 0, "Populate async flush failed.");
+		if ((ret = wtperf->conn->async_flush(wtperf->conn)) != 0) {
+			lprintf(wtperf, ret, 0, "Populate async flush failed.");
 			return (ret);
 		}
 		if ((ret = __wt_epoch(NULL, &stop)) != 0) {
-			lprintf(cfg, ret, 0, "Get time failed in populate.");
+			lprintf(wtperf, ret, 0, "Get time failed in populate.");
 			return (ret);
 		}
-		lprintf(cfg, 0, 1,
+		lprintf(wtperf, 0, 1,
 		    "Compact completed in %" PRIu64 " seconds",
 		    (uint64_t)(WT_TIMEDIFF_SEC(stop, start)));
 		assert(tables == 0);
 	}
 
 	/* Stop cycling idle tables. */
-	if ((ret = stop_idle_table_cycle(cfg, idle_table_cycle_thread)) != 0)
+	if ((ret = stop_idle_table_cycle(wtperf, idle_table_cycle_thread)) != 0)
 		return (ret);
 
 	return (0);
 }
 
 static int
-close_reopen(CONFIG *cfg)
+close_reopen(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
 	int ret;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
 	if (!opts->readonly && !opts->reopen_connection)
 		return (0);
@@ -1634,16 +1637,16 @@ close_reopen(CONFIG *cfg)
 	 * be identified.  This is particularly important for LSM, where the
 	 * merge algorithm is more aggressive for read-only trees.
 	 */
-	/* cfg->conn is released no matter the return value from close(). */
-	ret = cfg->conn->close(cfg->conn, NULL);
-	cfg->conn = NULL;
+	/* wtperf->conn is released no matter the return value from close(). */
+	ret = wtperf->conn->close(wtperf->conn, NULL);
+	wtperf->conn = NULL;
 	if (ret != 0) {
-		lprintf(cfg, ret, 0, "Closing the connection failed");
+		lprintf(wtperf, ret, 0, "Closing the connection failed");
 		return (ret);
 	}
 	if ((ret = wiredtiger_open(
-	    cfg->home, NULL, cfg->reopen_config, &cfg->conn)) != 0) {
-		lprintf(cfg, ret, 0, "Re-opening the connection failed");
+	    wtperf->home, NULL, wtperf->reopen_config, &wtperf->conn)) != 0) {
+		lprintf(wtperf, ret, 0, "Re-opening the connection failed");
 		return (ret);
 	}
 	/*
@@ -1652,10 +1655,10 @@ close_reopen(CONFIG *cfg)
 	 * threads looking for work that will never arrive don't affect
 	 * performance.
 	 */
-	if (opts->compact && !cfg->use_asyncops) {
-		if ((ret = cfg->conn->reconfigure(
-		    cfg->conn, "async=(enabled=false)")) != 0) {
-			lprintf(cfg, ret, 0, "Reconfigure async off failed");
+	if (opts->compact && !wtperf->use_asyncops) {
+		if ((ret = wtperf->conn->reconfigure(
+		    wtperf->conn, "async=(enabled=false)")) != 0) {
+			lprintf(wtperf, ret, 0, "Reconfigure async off failed");
 			return (ret);
 		}
 	}
@@ -1663,11 +1666,11 @@ close_reopen(CONFIG *cfg)
 }
 
 static int
-execute_workload(CONFIG *cfg)
+execute_workload(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
-	CONFIG_THREAD *threads;
 	WORKLOAD *workp;
+	WTPERF_THREAD *threads;
 	WT_CONNECTION *conn;
 	WT_SESSION **sessions;
 	pthread_t idle_table_cycle_thread;
@@ -1678,11 +1681,11 @@ execute_workload(CONFIG *cfg)
 	int ret, t_ret;
 	void *(*pfunc)(void *);
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
-	cfg->insert_key = 0;
-	cfg->insert_ops = cfg->read_ops = cfg->truncate_ops = 0;
-	cfg->update_ops = 0;
+	wtperf->insert_key = 0;
+	wtperf->insert_ops = wtperf->read_ops = wtperf->truncate_ops = 0;
+	wtperf->update_ops = 0;
 
 	last_ckpts = last_inserts = last_reads = last_truncates = 0;
 	last_updates = 0;
@@ -1691,17 +1694,19 @@ execute_workload(CONFIG *cfg)
 	sessions = NULL;
 
 	/* Start cycling idle tables. */
-	if ((ret = start_idle_table_cycle(cfg, &idle_table_cycle_thread)) != 0)
+	if ((ret =
+	    start_idle_table_cycle(wtperf, &idle_table_cycle_thread)) != 0)
 		return (ret);
 
 	if (opts->warmup != 0)
-		cfg->in_warmup = true;
+		wtperf->in_warmup = true;
 
 	/* Allocate memory for the worker threads. */
-	cfg->workers = dcalloc((size_t)cfg->workers_cnt, sizeof(CONFIG_THREAD));
+	wtperf->workers =
+	    dcalloc((size_t)wtperf->workers_cnt, sizeof(WTPERF_THREAD));
 
-	if (cfg->use_asyncops) {
-		lprintf(cfg, 0, 1, "Starting %" PRIu32 " async thread(s)",
+	if (wtperf->use_asyncops) {
+		lprintf(wtperf, 0, 1, "Starting %" PRIu32 " async thread(s)",
 		    opts->async_threads);
 		pfunc = worker_async;
 	} else
@@ -1710,19 +1715,19 @@ execute_workload(CONFIG *cfg)
 	if (opts->session_count_idle != 0) {
 		sessions = dcalloc((size_t)opts->session_count_idle,
 		    sizeof(WT_SESSION *));
-		conn = cfg->conn;
+		conn = wtperf->conn;
 		for (i = 0; i < opts->session_count_idle; ++i)
 			if ((ret = conn->open_session(conn,
 			    NULL, opts->sess_config, &sessions[i])) != 0) {
-				lprintf(cfg, ret, 0,
+				lprintf(wtperf, ret, 0,
 				    "execute_workload: idle open_session");
 				goto err;
 			}
 	}
 	/* Start each workload. */
-	for (threads = cfg->workers, i = 0,
-	    workp = cfg->workload; i < cfg->workload_cnt; ++i, ++workp) {
-		lprintf(cfg, 0, 1,
+	for (threads = wtperf->workers, i = 0,
+	    workp = wtperf->workload; i < wtperf->workload_cnt; ++i, ++workp) {
+		lprintf(wtperf, 0, 1,
 		    "Starting workload #%u: %" PRId64 " threads, inserts=%"
 		    PRId64 ", reads=%" PRId64 ", updates=%" PRId64
 		    ", truncate=%" PRId64 ", throttle=%" PRId64,
@@ -1731,25 +1736,26 @@ execute_workload(CONFIG *cfg)
 		    workp->throttle);
 
 		/* Figure out the workload's schedule. */
-		if ((ret = run_mix_schedule(cfg, workp)) != 0)
+		if ((ret = run_mix_schedule(wtperf, workp)) != 0)
 			goto err;
 
 		/* Start the workload's threads. */
 		if ((ret = start_threads(
-		    cfg, workp, threads, (u_int)workp->threads, pfunc)) != 0)
+		    wtperf, workp, threads, (u_int)workp->threads, pfunc)) != 0)
 			goto err;
 		threads += workp->threads;
 	}
 
 	if (opts->warmup != 0) {
-		lprintf(cfg, 0, 1,
+		lprintf(wtperf, 0, 1,
 		    "Waiting for warmup duration of %" PRIu32, opts->warmup);
 		sleep(opts->warmup);
-		cfg->in_warmup = false;
+		wtperf->in_warmup = false;
 	}
 
 	for (interval = opts->report_interval,
-	    run_time = opts->run_time, run_ops = opts->run_ops; !cfg->error;) {
+	    run_time = opts->run_time, run_ops = opts->run_ops;
+	    !wtperf->error;) {
 		/*
 		 * Sleep for one second at a time.
 		 * If we are tracking run time, check to see if we're done, and
@@ -1764,59 +1770,60 @@ execute_workload(CONFIG *cfg)
 		}
 
 		/* Sum the operations we've done. */
-		cfg->ckpt_ops = sum_ckpt_ops(cfg);
-		cfg->insert_ops = sum_insert_ops(cfg);
-		cfg->read_ops = sum_read_ops(cfg);
-		cfg->update_ops = sum_update_ops(cfg);
-		cfg->truncate_ops = sum_truncate_ops(cfg);
+		wtperf->ckpt_ops = sum_ckpt_ops(wtperf);
+		wtperf->insert_ops = sum_insert_ops(wtperf);
+		wtperf->read_ops = sum_read_ops(wtperf);
+		wtperf->update_ops = sum_update_ops(wtperf);
+		wtperf->truncate_ops = sum_truncate_ops(wtperf);
 
 		/* If we're checking total operations, see if we're done. */
 		if (run_ops != 0 && run_ops <=
-		    cfg->insert_ops + cfg->read_ops + cfg->update_ops)
+		    wtperf->insert_ops + wtperf->read_ops + wtperf->update_ops)
 			break;
 
 		/* If writing out throughput information, see if it's time. */
 		if (interval == 0 || --interval > 0)
 			continue;
 		interval = opts->report_interval;
-		cfg->totalsec += opts->report_interval;
+		wtperf->totalsec += opts->report_interval;
 
-		lprintf(cfg, 0, 1,
+		lprintf(wtperf, 0, 1,
 		    "%" PRIu64 " reads, %" PRIu64 " inserts, %" PRIu64
 		    " updates, %" PRIu64 " truncates, %" PRIu64
 		    " checkpoints in %" PRIu32 " secs (%" PRIu32 " total secs)",
-		    cfg->read_ops - last_reads,
-		    cfg->insert_ops - last_inserts,
-		    cfg->update_ops - last_updates,
-		    cfg->truncate_ops - last_truncates,
-		    cfg->ckpt_ops - last_ckpts,
-		    opts->report_interval, cfg->totalsec);
-		last_reads = cfg->read_ops;
-		last_inserts = cfg->insert_ops;
-		last_updates = cfg->update_ops;
-		last_truncates = cfg->truncate_ops;
-		last_ckpts = cfg->ckpt_ops;
+		    wtperf->read_ops - last_reads,
+		    wtperf->insert_ops - last_inserts,
+		    wtperf->update_ops - last_updates,
+		    wtperf->truncate_ops - last_truncates,
+		    wtperf->ckpt_ops - last_ckpts,
+		    opts->report_interval, wtperf->totalsec);
+		last_reads = wtperf->read_ops;
+		last_inserts = wtperf->insert_ops;
+		last_updates = wtperf->update_ops;
+		last_truncates = wtperf->truncate_ops;
+		last_ckpts = wtperf->ckpt_ops;
 	}
 
 	/* Notify the worker threads they are done. */
-err:	cfg->stop = true;
+err:	wtperf->stop = true;
 
 	/* Stop cycling idle tables. */
-	if ((ret = stop_idle_table_cycle(cfg, idle_table_cycle_thread)) != 0)
+	if ((ret = stop_idle_table_cycle(wtperf, idle_table_cycle_thread)) != 0)
 		return (ret);
 
-	if ((t_ret = stop_threads(
-	    cfg, (u_int)cfg->workers_cnt, cfg->workers)) != 0 && ret == 0)
+	if ((t_ret = stop_threads(wtperf,
+	    (u_int)wtperf->workers_cnt, wtperf->workers)) != 0 && ret == 0)
 		ret = t_ret;
 
 	/* Drop tables if configured to and this isn't an error path */
-	if (ret == 0 && opts->drop_tables && (ret = drop_all_tables(cfg)) != 0)
-		lprintf(cfg, ret, 0, "Drop tables failed.");
+	if (ret == 0 &&
+	    opts->drop_tables && (ret = drop_all_tables(wtperf)) != 0)
+		lprintf(wtperf, ret, 0, "Drop tables failed.");
 
 	free(sessions);
 	/* Report if any worker threads didn't finish. */
-	if (cfg->error) {
-		lprintf(cfg, WT_ERROR, 0,
+	if (wtperf->error) {
+		lprintf(wtperf, WT_ERROR, 0,
 		    "Worker thread(s) exited without finishing.");
 		if (ret == 0)
 			ret = WT_ERROR;
@@ -1829,7 +1836,7 @@ err:	cfg->stop = true;
  * existing table.
  */
 static int
-find_table_count(CONFIG *cfg)
+find_table_count(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
 	WT_CONNECTION *conn;
@@ -1839,30 +1846,30 @@ find_table_count(CONFIG *cfg)
 	int ret, t_ret;
 	char *key;
 
-	opts = cfg->opts;
-	conn = cfg->conn;
+	opts = wtperf->opts;
+	conn = wtperf->conn;
 
 	max_icount = 0;
 	if ((ret = conn->open_session(
 	    conn, NULL, opts->sess_config, &session)) != 0) {
-		lprintf(cfg, ret, 0,
+		lprintf(wtperf, ret, 0,
 		    "find_table_count: open_session failed");
 		goto out;
 	}
 	for (i = 0; i < opts->table_count; i++) {
-		if ((ret = session->open_cursor(session, cfg->uris[i],
+		if ((ret = session->open_cursor(session, wtperf->uris[i],
 		    NULL, NULL, &cursor)) != 0) {
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			    "find_table_count: open_cursor failed");
 			goto err;
 		}
 		if ((ret = cursor->prev(cursor)) != 0) {
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			    "find_table_count: cursor prev failed");
 			goto err;
 		}
 		if ((ret = cursor->get_key(cursor, &key)) != 0) {
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			    "find_table_count: cursor get_key failed");
 			goto err;
 		}
@@ -1871,7 +1878,7 @@ find_table_count(CONFIG *cfg)
 			max_icount = table_icount;
 
 		if ((ret = cursor->close(cursor)) != 0) {
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			    "find_table_count: cursor close failed");
 			goto err;
 		}
@@ -1879,7 +1886,7 @@ find_table_count(CONFIG *cfg)
 err:	if ((t_ret = session->close(session, NULL)) != 0) {
 		if (ret == 0)
 			ret = t_ret;
-		lprintf(cfg, ret, 0,
+		lprintf(wtperf, ret, 0,
 		    "find_table_count: session close failed");
 	}
 	opts->icount = max_icount;
@@ -1890,37 +1897,37 @@ out:	return (ret);
  * Populate the uri array.
  */
 static void
-create_uris(CONFIG *cfg)
+create_uris(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
 	size_t len;
 	uint32_t i;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
-	cfg->uris = dcalloc(opts->table_count, sizeof(char *));
+	wtperf->uris = dcalloc(opts->table_count, sizeof(char *));
 	len = strlen("table:") + strlen(opts->table_name) + 20;
 	for (i = 0; i < opts->table_count; i++) {
 		/* If there is only one table, just use the base name. */
-		cfg->uris[i] = dmalloc(len);
+		wtperf->uris[i] = dmalloc(len);
 		if (opts->table_count == 1)
-			snprintf(cfg->uris[i],
+			snprintf(wtperf->uris[i],
 			    len, "table:%s", opts->table_name);
 		else
-			snprintf(cfg->uris[i],
+			snprintf(wtperf->uris[i],
 			    len, "table:%s%05d", opts->table_name, i);
 	}
 
 	/* Create the log-like-table URI. */
 	len = strlen("table:") +
 	    strlen(opts->table_name) + strlen("_log_table") + 1;
-	cfg->log_table_uri = dmalloc(len);
+	wtperf->log_table_uri = dmalloc(len);
 	snprintf(
-	    cfg->log_table_uri, len, "table:%s_log_table", opts->table_name);
+	    wtperf->log_table_uri, len, "table:%s_log_table", opts->table_name);
 }
 
 static int
-create_tables(CONFIG *cfg)
+create_tables(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
 	WT_SESSION *session;
@@ -1928,50 +1935,50 @@ create_tables(CONFIG *cfg)
 	int ret;
 	char buf[512];
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
-	if ((ret = cfg->conn->open_session(
-	    cfg->conn, NULL, opts->sess_config, &session)) != 0) {
-		lprintf(cfg, ret, 0,
-		    "Error opening a session on %s", cfg->home);
+	if ((ret = wtperf->conn->open_session(
+	    wtperf->conn, NULL, opts->sess_config, &session)) != 0) {
+		lprintf(wtperf, ret, 0,
+		    "Error opening a session on %s", wtperf->home);
 		return (ret);
 	}
 
 	for (i = 0; i < opts->table_count_idle; i++) {
-		snprintf(buf, 512, "%s_idle%05d", cfg->uris[0], (int)i);
+		snprintf(buf, 512, "%s_idle%05d", wtperf->uris[0], (int)i);
 		if ((ret = session->create(
 		    session, buf, opts->table_config)) != 0) {
-			lprintf(cfg, ret, 0,
+			lprintf(wtperf, ret, 0,
 			    "Error creating idle table %s", buf);
 			return (ret);
 		}
 	}
 	if (opts->log_like_table && (ret = session->create(session,
-	    cfg->log_table_uri, "key_format=Q,value_format=S")) != 0) {
-		lprintf(cfg, ret, 0, "Error creating log table %s", buf);
+	    wtperf->log_table_uri, "key_format=Q,value_format=S")) != 0) {
+		lprintf(wtperf, ret, 0, "Error creating log table %s", buf);
 		return (ret);
 	}
 
 	for (i = 0; i < opts->table_count; i++) {
 		if (opts->log_partial && i > 0) {
 			if (((ret = session->create(session,
-			    cfg->uris[i], cfg->partial_config)) != 0)) {
-				lprintf(cfg, ret, 0,
-				    "Error creating table %s", cfg->uris[i]);
+			    wtperf->uris[i], wtperf->partial_config)) != 0)) {
+				lprintf(wtperf, ret, 0,
+				    "Error creating table %s", wtperf->uris[i]);
 				return (ret);
 			}
 		} else if ((ret = session->create(
-		    session, cfg->uris[i], opts->table_config)) != 0) {
-			lprintf(cfg, ret, 0,
-			    "Error creating table %s", cfg->uris[i]);
+		    session, wtperf->uris[i], opts->table_config)) != 0) {
+			lprintf(wtperf, ret, 0,
+			    "Error creating table %s", wtperf->uris[i]);
 			return (ret);
 		}
 		if (opts->index) {
 			snprintf(buf, 512, "index:%s:val_idx",
-			    cfg->uris[i] + strlen("table:"));
+			    wtperf->uris[i] + strlen("table:"));
 			if ((ret = session->create(
 			    session, buf, "columns=(val)")) != 0) {
-				lprintf(cfg, ret, 0,
+				lprintf(wtperf, ret, 0,
 				    "Error creating index %s", buf);
 				return (ret);
 			}
@@ -1979,7 +1986,7 @@ create_tables(CONFIG *cfg)
 	}
 
 	if ((ret = session->close(session, NULL)) != 0) {
-		lprintf(cfg, ret, 0, "Error closing session");
+		lprintf(wtperf, ret, 0, "Error closing session");
 		return (ret);
 	}
 
@@ -1987,19 +1994,19 @@ create_tables(CONFIG *cfg)
 }
 
 /*
- * config_copy --
- *	Create a new CONFIG structure as a duplicate of a previous one.
+ * wtperf_copy --
+ *	Create a new WTPERF structure as a duplicate of a previous one.
  */
 static void
-config_copy(const CONFIG *src, CONFIG **retp)
+wtperf_copy(const WTPERF *src, WTPERF **retp)
 {
-	CONFIG *dest;
 	CONFIG_OPTS *opts;
+	WTPERF *dest;
 	size_t i;
 
 	opts = src->opts;
 
-	dest = dcalloc(1, sizeof(CONFIG));
+	dest = dcalloc(1, sizeof(WTPERF));
 
 	/*
 	 * Don't copy the home and monitor directories, they are filled in by
@@ -2040,38 +2047,38 @@ config_copy(const CONFIG *src, CONFIG **retp)
 }
 
 /*
- * config_free --
- *	Free any storage allocated in the CONFIG structure.
+ * wtperf_free --
+ *	Free any storage allocated in the WTPERF structure.
  */
 static void
-config_free(CONFIG *cfg)
+wtperf_free(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
 	size_t i;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
-	free(cfg->home);
-	free(cfg->monitor_dir);
-	free(cfg->partial_config);
-	free(cfg->reopen_config);
-	free(cfg->log_table_uri);
+	free(wtperf->home);
+	free(wtperf->monitor_dir);
+	free(wtperf->partial_config);
+	free(wtperf->reopen_config);
+	free(wtperf->log_table_uri);
 
-	if (cfg->uris != NULL) {
+	if (wtperf->uris != NULL) {
 		for (i = 0; i < opts->table_count; i++)
-			free(cfg->uris[i]);
-		free(cfg->uris);
+			free(wtperf->uris[i]);
+		free(wtperf->uris);
 	}
 
-	free(cfg->async_config);
+	free(wtperf->async_config);
 
-	free(cfg->ckptthreads);
-	free(cfg->popthreads);
+	free(wtperf->ckptthreads);
+	free(wtperf->popthreads);
 
-	free(cfg->workers);
-	free(cfg->workload);
+	free(wtperf->workers);
+	free(wtperf->workload);
 
-	cleanup_truncate_config(cfg);
+	cleanup_truncate_config(wtperf);
 }
 
 /*
@@ -2079,34 +2086,34 @@ config_free(CONFIG *cfg)
  *	Parse the compression configuration.
  */
 static int
-config_compress(CONFIG *cfg)
+config_compress(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
 	int ret;
 	const char *s;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 	ret = 0;
 
 	s = opts->compression;
 	if (strcmp(s, "none") == 0) {
-		cfg->compress_ext = NULL;
-		cfg->compress_table = NULL;
+		wtperf->compress_ext = NULL;
+		wtperf->compress_table = NULL;
 	} else if (strcmp(s, "lz4") == 0) {
 #ifndef HAVE_BUILTIN_EXTENSION_LZ4
-		cfg->compress_ext = LZ4_EXT;
+		wtperf->compress_ext = LZ4_EXT;
 #endif
-		cfg->compress_table = LZ4_BLK;
+		wtperf->compress_table = LZ4_BLK;
 	} else if (strcmp(s, "snappy") == 0) {
 #ifndef HAVE_BUILTIN_EXTENSION_SNAPPY
-		cfg->compress_ext = SNAPPY_EXT;
+		wtperf->compress_ext = SNAPPY_EXT;
 #endif
-		cfg->compress_table = SNAPPY_BLK;
+		wtperf->compress_table = SNAPPY_BLK;
 	} else if (strcmp(s, "zlib") == 0) {
 #ifndef HAVE_BUILTIN_EXTENSION_ZLIB
-		cfg->compress_ext = ZLIB_EXT;
+		wtperf->compress_ext = ZLIB_EXT;
 #endif
-		cfg->compress_table = ZLIB_BLK;
+		wtperf->compress_table = ZLIB_BLK;
 	} else {
 		fprintf(stderr,
 	    "invalid compression configuration: %s\n", s);
@@ -2117,52 +2124,53 @@ config_compress(CONFIG *cfg)
 }
 
 static int
-start_all_runs(CONFIG *cfg)
+start_all_runs(WTPERF *wtperf)
 {
-	CONFIG *next_cfg, **configs;
 	CONFIG_OPTS *opts;
+	WTPERF *next_wtperf, **wtperfs;
 	pthread_t *threads;
 	size_t i, len;
 	int ret, t_ret;
 
-	opts = cfg->opts;
-	configs = NULL;
+	opts = wtperf->opts;
+	wtperfs = NULL;
 	ret = 0;
 
 	if (opts->database_count == 1)
-		return (start_run(cfg));
+		return (start_run(wtperf));
 
-	/* Allocate an array to hold our config struct copies. */
-	configs = dcalloc(opts->database_count, sizeof(CONFIG *));
+	/* Allocate an array to hold our WTPERF copies. */
+	wtperfs = dcalloc(opts->database_count, sizeof(WTPERF *));
 
 	/* Allocate an array to hold our thread IDs. */
 	threads = dcalloc(opts->database_count, sizeof(pthread_t));
 
 	for (i = 0; i < opts->database_count; i++) {
-		config_copy(cfg, &next_cfg);
-		configs[i] = next_cfg;
+		wtperf_copy(wtperf, &next_wtperf);
+		wtperfs[i] = next_wtperf;
 
 		/*
 		 * Set up unique home/monitor directories for each database.
 		 * Re-create the directories if creating the databases.
 		 */
-		len = strlen(cfg->home) + 5;
-		next_cfg->home = dmalloc(len);
-		snprintf(next_cfg->home, len, "%s/D%02d", cfg->home, (int)i);
+		len = strlen(wtperf->home) + 5;
+		next_wtperf->home = dmalloc(len);
+		snprintf(
+		    next_wtperf->home, len, "%s/D%02d", wtperf->home, (int)i);
 		if (opts->create != 0)
-			recreate_dir(next_cfg->home);
+			recreate_dir(next_wtperf->home);
 
-		len = strlen(cfg->monitor_dir) + 5;
-		next_cfg->monitor_dir = dmalloc(len);
-		snprintf(next_cfg->monitor_dir,
-		    len, "%s/D%02d", cfg->monitor_dir, (int)i);
+		len = strlen(wtperf->monitor_dir) + 5;
+		next_wtperf->monitor_dir = dmalloc(len);
+		snprintf(next_wtperf->monitor_dir,
+		    len, "%s/D%02d", wtperf->monitor_dir, (int)i);
 		if (opts->create != 0 &&
-		    strcmp(next_cfg->home, next_cfg->monitor_dir) != 0)
-			recreate_dir(next_cfg->monitor_dir);
+		    strcmp(next_wtperf->home, next_wtperf->monitor_dir) != 0)
+			recreate_dir(next_wtperf->monitor_dir);
 
 		if ((ret = pthread_create(
-		    &threads[i], NULL, thread_run_wtperf, next_cfg)) != 0) {
-			lprintf(cfg, ret, 0, "Error creating thread");
+		    &threads[i], NULL, thread_run_wtperf, next_wtperf)) != 0) {
+			lprintf(wtperf, ret, 0, "Error creating thread");
 			goto err;
 		}
 	}
@@ -2170,16 +2178,16 @@ start_all_runs(CONFIG *cfg)
 	/* Wait for threads to finish. */
 	for (i = 0; i < opts->database_count; i++)
 		if ((t_ret = pthread_join(threads[i], NULL)) != 0) {
-			lprintf(cfg, ret, 0, "Error joining thread");
+			lprintf(wtperf, ret, 0, "Error joining thread");
 			if (ret == 0)
 				ret = t_ret;
 		}
 
-err:	for (i = 0; i < opts->database_count && configs[i] != NULL; i++) {
-		config_free(configs[i]);
-		free(configs[i]);
+err:	for (i = 0; i < opts->database_count && wtperfs[i] != NULL; i++) {
+		wtperf_free(wtperfs[i]);
+		free(wtperfs[i]);
 	}
-	free(configs);
+	free(wtperfs);
 	free(threads);
 
 	return (ret);
@@ -2189,17 +2197,17 @@ err:	for (i = 0; i < opts->database_count && configs[i] != NULL; i++) {
 static void *
 thread_run_wtperf(void *arg)
 {
-	CONFIG *cfg;
+	WTPERF *wtperf;
 	int ret;
 
-	cfg = (CONFIG *)arg;
-	if ((ret = start_run(cfg)) != 0)
-		lprintf(cfg, ret, 0, "Run failed for: %s.", cfg->home);
+	wtperf = (WTPERF *)arg;
+	if ((ret = start_run(wtperf)) != 0)
+		lprintf(wtperf, ret, 0, "Run failed for: %s.", wtperf->home);
 	return (NULL);
 }
 
 static int
-start_run(CONFIG *cfg)
+start_run(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
 	pthread_t monitor_thread;
@@ -2207,103 +2215,106 @@ start_run(CONFIG *cfg)
 	uint32_t run_time;
 	int monitor_created, ret, t_ret;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 	monitor_created = ret = 0;
 					/* [-Wconditional-uninitialized] */
 	memset(&monitor_thread, 0, sizeof(monitor_thread));
 
-	if ((ret = setup_log_file(cfg)) != 0)
+	if ((ret = setup_log_file(wtperf)) != 0)
 		goto err;
 
 	if ((ret = wiredtiger_open(	/* Open the real connection. */
-	    cfg->home, NULL, opts->conn_config, &cfg->conn)) != 0) {
-		lprintf(cfg, ret, 0, "Error connecting to %s", cfg->home);
+	    wtperf->home, NULL, opts->conn_config, &wtperf->conn)) != 0) {
+		lprintf(wtperf, ret, 0, "Error connecting to %s", wtperf->home);
 		goto err;
 	}
 
-	create_uris(cfg);
+	create_uris(wtperf);
 
 	/* If creating, create the tables. */
-	if (opts->create != 0 && (ret = create_tables(cfg)) != 0)
+	if (opts->create != 0 && (ret = create_tables(wtperf)) != 0)
 		goto err;
 
 	/* Start the monitor thread. */
 	if (opts->sample_interval != 0) {
 		if ((ret = pthread_create(
-		    &monitor_thread, NULL, monitor, cfg)) != 0) {
-			lprintf(cfg, ret, 0, "Error creating monitor thread.");
+		    &monitor_thread, NULL, monitor, wtperf)) != 0) {
+			lprintf(wtperf,
+			    ret, 0, "Error creating monitor thread.");
 			goto err;
 		}
 		monitor_created = 1;
 	}
 
 	/* If creating, populate the table. */
-	if (opts->create != 0 && execute_populate(cfg) != 0)
+	if (opts->create != 0 && execute_populate(wtperf) != 0)
 		goto err;
 
 	/* Optional workload. */
-	if (cfg->workers_cnt != 0 &&
+	if (wtperf->workers_cnt != 0 &&
 	    (opts->run_time != 0 || opts->run_ops != 0)) {
 		/*
 		 * If we have a workload, close and reopen the connection so
 		 * that LSM can detect read-only workloads.
 		 */
-		if (close_reopen(cfg) != 0)
+		if (close_reopen(wtperf) != 0)
 			goto err;
 
 		/* Didn't create, set insert count. */
 		if (opts->create == 0 &&
-		    opts->random_range == 0 && find_table_count(cfg) != 0)
+		    opts->random_range == 0 && find_table_count(wtperf) != 0)
 			goto err;
 		/* Start the checkpoint thread. */
 		if (opts->checkpoint_threads != 0) {
-			lprintf(cfg, 0, 1,
+			lprintf(wtperf, 0, 1,
 			    "Starting %" PRIu32 " checkpoint thread(s)",
 			    opts->checkpoint_threads);
-			cfg->ckptthreads = dcalloc(
-			     opts->checkpoint_threads, sizeof(CONFIG_THREAD));
-			if (start_threads(cfg, NULL, cfg->ckptthreads,
+			wtperf->ckptthreads = dcalloc(
+			     opts->checkpoint_threads, sizeof(WTPERF_THREAD));
+			if (start_threads(wtperf, NULL, wtperf->ckptthreads,
 			    opts->checkpoint_threads, checkpoint_worker) != 0)
 				goto err;
 		}
 		/* Execute the workload. */
-		if ((ret = execute_workload(cfg)) != 0)
+		if ((ret = execute_workload(wtperf)) != 0)
 			goto err;
 
 		/* One final summation of the operations we've completed. */
-		cfg->read_ops = sum_read_ops(cfg);
-		cfg->insert_ops = sum_insert_ops(cfg);
-		cfg->truncate_ops = sum_truncate_ops(cfg);
-		cfg->update_ops = sum_update_ops(cfg);
-		cfg->ckpt_ops = sum_ckpt_ops(cfg);
-		total_ops = cfg->read_ops + cfg->insert_ops + cfg->update_ops;
+		wtperf->read_ops = sum_read_ops(wtperf);
+		wtperf->insert_ops = sum_insert_ops(wtperf);
+		wtperf->truncate_ops = sum_truncate_ops(wtperf);
+		wtperf->update_ops = sum_update_ops(wtperf);
+		wtperf->ckpt_ops = sum_ckpt_ops(wtperf);
+		total_ops =
+		    wtperf->read_ops + wtperf->insert_ops + wtperf->update_ops;
 
 		run_time = opts->run_time == 0 ? 1 : opts->run_time;
-		lprintf(cfg, 0, 1,
+		lprintf(wtperf, 0, 1,
 		    "Executed %" PRIu64 " read operations (%" PRIu64
 		    "%%) %" PRIu64 " ops/sec",
-		    cfg->read_ops, (cfg->read_ops * 100) / total_ops,
-		    cfg->read_ops / run_time);
-		lprintf(cfg, 0, 1,
+		    wtperf->read_ops, (wtperf->read_ops * 100) / total_ops,
+		    wtperf->read_ops / run_time);
+		lprintf(wtperf, 0, 1,
 		    "Executed %" PRIu64 " insert operations (%" PRIu64
 		    "%%) %" PRIu64 " ops/sec",
-		    cfg->insert_ops, (cfg->insert_ops * 100) / total_ops,
-		    cfg->insert_ops / run_time);
-		lprintf(cfg, 0, 1,
+		    wtperf->insert_ops, (wtperf->insert_ops * 100) / total_ops,
+		    wtperf->insert_ops / run_time);
+		lprintf(wtperf, 0, 1,
 		    "Executed %" PRIu64 " truncate operations (%" PRIu64
 		    "%%) %" PRIu64 " ops/sec",
-		    cfg->truncate_ops, (cfg->truncate_ops * 100) / total_ops,
-		    cfg->truncate_ops / run_time);
-		lprintf(cfg, 0, 1,
+		    wtperf->truncate_ops,
+		    (wtperf->truncate_ops * 100) / total_ops,
+		    wtperf->truncate_ops / run_time);
+		lprintf(wtperf, 0, 1,
 		    "Executed %" PRIu64 " update operations (%" PRIu64
 		    "%%) %" PRIu64 " ops/sec",
-		    cfg->update_ops, (cfg->update_ops * 100) / total_ops,
-		    cfg->update_ops / run_time);
-		lprintf(cfg, 0, 1,
+		    wtperf->update_ops, (wtperf->update_ops * 100) / total_ops,
+		    wtperf->update_ops / run_time);
+		lprintf(wtperf, 0, 1,
 		    "Executed %" PRIu64 " checkpoint operations",
-		    cfg->ckpt_ops);
+		    wtperf->ckpt_ops);
 
-		latency_print(cfg);
+		latency_print(wtperf);
 	}
 
 	if (0) {
@@ -2312,41 +2323,41 @@ err:		if (ret == 0)
 	}
 
 	/* Notify the worker threads they are done. */
-	cfg->stop = true;
+	wtperf->stop = true;
 
-	if ((t_ret = stop_threads(cfg, 1, cfg->ckptthreads)) != 0)
+	if ((t_ret = stop_threads(wtperf, 1, wtperf->ckptthreads)) != 0)
 		if (ret == 0)
 			ret = t_ret;
 
 	if (monitor_created != 0 &&
 	    (t_ret = pthread_join(monitor_thread, NULL)) != 0) {
-		lprintf(cfg, ret, 0, "Error joining monitor thread.");
+		lprintf(wtperf, ret, 0, "Error joining monitor thread.");
 		if (ret == 0)
 			ret = t_ret;
 	}
 
-	if (cfg->conn != NULL &&
-	    (t_ret = cfg->conn->close(cfg->conn, NULL)) != 0) {
-		lprintf(cfg, t_ret, 0,
-		    "Error closing connection to %s", cfg->home);
+	if (wtperf->conn != NULL &&
+	    (t_ret = wtperf->conn->close(wtperf->conn, NULL)) != 0) {
+		lprintf(wtperf, t_ret, 0,
+		    "Error closing connection to %s", wtperf->home);
 		if (ret == 0)
 			ret = t_ret;
 	}
 
 	if (ret == 0) {
 		if (opts->run_time == 0 && opts->run_ops == 0)
-			lprintf(cfg, 0, 1, "Run completed");
+			lprintf(wtperf, 0, 1, "Run completed");
 		else
-			lprintf(cfg, 0, 1, "Run completed: %" PRIu32 " %s",
+			lprintf(wtperf, 0, 1, "Run completed: %" PRIu32 " %s",
 			    opts->run_time == 0 ?
 			    opts->run_ops : opts->run_time,
 			    opts->run_time == 0 ? "operations" : "seconds");
 	}
 
-	if (cfg->logf != NULL) {
-		if ((t_ret = fflush(cfg->logf)) != 0 && ret == 0)
+	if (wtperf->logf != NULL) {
+		if ((t_ret = fflush(wtperf->logf)) != 0 && ret == 0)
 			ret = t_ret;
-		if ((t_ret = fclose(cfg->logf)) != 0 && ret == 0)
+		if ((t_ret = fclose(wtperf->logf)) != 0 && ret == 0)
 			ret = t_ret;
 	}
 	return (ret);
@@ -2380,8 +2391,8 @@ usage(void)
 int
 main(int argc, char *argv[])
 {
-	CONFIG *cfg, _cfg;
 	CONFIG_OPTS *opts;
+	WTPERF *wtperf, _wtperf;
 	size_t req_len, sreq_len;
 	bool monitor_set;
 	int ch, ret;
@@ -2389,15 +2400,15 @@ main(int argc, char *argv[])
 	const char *config_opts;
 	char *cc_buf, *path, *sess_cfg, *tc_buf, *user_cconfig, *user_tconfig;
 
-	/* The first CONFIG structure (from which all others are derived). */
-	cfg = &_cfg;
-	memset(cfg, 0, sizeof(*cfg));
-	cfg->home = dstrdup(DEFAULT_HOME);
-	cfg->monitor_dir = dstrdup(DEFAULT_MONITOR_DIR);
-	TAILQ_INIT(&cfg->stone_head);
-	config_opt_init(&cfg->opts);
+	/* The first WTPERF structure (from which all others are derived). */
+	wtperf = &_wtperf;
+	memset(wtperf, 0, sizeof(*wtperf));
+	wtperf->home = dstrdup(DEFAULT_HOME);
+	wtperf->monitor_dir = dstrdup(DEFAULT_MONITOR_DIR);
+	TAILQ_INIT(&wtperf->stone_head);
+	config_opt_init(&wtperf->opts);
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 	monitor_set = false;
 	ret = 0;
 	config_opts = NULL;
@@ -2418,12 +2429,12 @@ main(int argc, char *argv[])
 			}
 			break;
 		case 'h':
-			free(cfg->home);
-			cfg->home = dstrdup(__wt_optarg);
+			free(wtperf->home);
+			wtperf->home = dstrdup(__wt_optarg);
 			break;
 		case 'm':
-			free(cfg->monitor_dir);
-			cfg->monitor_dir = dstrdup(__wt_optarg);
+			free(wtperf->monitor_dir);
+			wtperf->monitor_dir = dstrdup(__wt_optarg);
 			monitor_set = true;
 			break;
 		case 'O':
@@ -2450,12 +2461,12 @@ main(int argc, char *argv[])
 	 * monitor directory to the home dir.
 	 */
 	if (!monitor_set) {
-		free(cfg->monitor_dir);
-		cfg->monitor_dir = dstrdup(cfg->home);
+		free(wtperf->monitor_dir);
+		wtperf->monitor_dir = dstrdup(wtperf->home);
 	}
 
 	/* Parse configuration settings from configuration file. */
-	if (config_opts != NULL && config_opt_file(cfg, config_opts) != 0)
+	if (config_opts != NULL && config_opt_file(wtperf, config_opts) != 0)
 		goto einval;
 
 	/* Parse options that override values set via a configuration file. */
@@ -2464,29 +2475,30 @@ main(int argc, char *argv[])
 		switch (ch) {
 		case 'o':
 			/* Allow -o key=value */
-			if (config_opt_str(cfg, __wt_optarg) != 0)
+			if (config_opt_str(wtperf, __wt_optarg) != 0)
 				goto einval;
 			break;
 		}
 
 	if (opts->populate_threads == 0 && opts->icount != 0) {
-		lprintf(cfg, 1, 0,
+		lprintf(wtperf, 1, 0,
 		    "Cannot have 0 populate threads when icount is set\n");
 		goto err;
 	}
 
-	cfg->async_config = NULL;
+	wtperf->async_config = NULL;
 	/*
 	 * If the user specified async_threads we use async for all ops.
 	 * If the user wants compaction, then we also enable async for
 	 * the compact operation, but not for the workloads.
 	 */
 	if (opts->async_threads > 0) {
-		if (F_ISSET(cfg, CFG_TRUNCATE)) {
-			lprintf(cfg, 1, 0, "Cannot run truncate and async\n");
+		if (F_ISSET(wtperf, CFG_TRUNCATE)) {
+			lprintf(wtperf,
+			    1, 0, "Cannot run truncate and async\n");
 			goto err;
 		}
-		cfg->use_asyncops = true;
+		wtperf->use_asyncops = true;
 	}
 	if (opts->compact && opts->async_threads == 0)
 		opts->async_threads = 2;
@@ -2498,23 +2510,23 @@ main(int argc, char *argv[])
 		 * to 4096 if needed.
 		 */
 		req_len = strlen(",async=(enabled=true,threads=)") + 4;
-		cfg->async_config = dmalloc(req_len);
-		snprintf(cfg->async_config, req_len,
+		wtperf->async_config = dmalloc(req_len);
+		snprintf(wtperf->async_config, req_len,
 		    ",async=(enabled=true,threads=%" PRIu32 ")",
 		    opts->async_threads);
 	}
-	if ((ret = config_compress(cfg)) != 0)
+	if ((ret = config_compress(wtperf)) != 0)
 		goto err;
 
 	/* You can't have truncate on a random collection. */
-	if (F_ISSET(cfg, CFG_TRUNCATE) && opts->random_range) {
-		lprintf(cfg, 1, 0, "Cannot run truncate and random_range\n");
+	if (F_ISSET(wtperf, CFG_TRUNCATE) && opts->random_range) {
+		lprintf(wtperf, 1, 0, "Cannot run truncate and random_range\n");
 		goto err;
 	}
 
 	/* We can't run truncate with more than one table. */
-	if (F_ISSET(cfg, CFG_TRUNCATE) && opts->table_count > 1) {
-		lprintf(cfg, 1, 0, "Cannot truncate more than 1 table\n");
+	if (F_ISSET(wtperf, CFG_TRUNCATE) && opts->table_count > 1) {
+		lprintf(wtperf, 1, 0, "Cannot truncate more than 1 table\n");
 		goto err;
 	}
 
@@ -2523,15 +2535,15 @@ main(int argc, char *argv[])
 
 	/* Concatenate non-default configuration strings. */
 	if (opts->verbose > 1 || user_cconfig != NULL ||
-	    opts->session_count_idle > 0 || cfg->compress_ext != NULL ||
-	    cfg->async_config != NULL) {
+	    opts->session_count_idle > 0 || wtperf->compress_ext != NULL ||
+	    wtperf->async_config != NULL) {
 		req_len = strlen(debug_cconfig) + 20;
 		if (user_cconfig != NULL)
 			req_len += strlen(user_cconfig);
-		if (cfg->async_config != NULL)
-			req_len += strlen(cfg->async_config);
-		if (cfg->compress_ext != NULL)
-			req_len += strlen(cfg->compress_ext);
+		if (wtperf->async_config != NULL)
+			req_len += strlen(wtperf->async_config);
+		if (wtperf->compress_ext != NULL)
+			req_len += strlen(wtperf->compress_ext);
 		if (opts->session_count_idle > 0) {
 			sreq_len = strlen(",session_max=") + 6;
 			req_len += sreq_len;
@@ -2539,43 +2551,44 @@ main(int argc, char *argv[])
 			snprintf(sess_cfg, sreq_len,
 			    ",session_max=%" PRIu32,
 			    opts->session_count_idle +
-			    cfg->workers_cnt + opts->populate_threads + 10);
+			    wtperf->workers_cnt + opts->populate_threads + 10);
 		}
 		cc_buf = dmalloc(req_len);
 		snprintf(cc_buf, req_len, "%s,%s,%s,%s,%s",
-		    cfg->async_config ? cfg->async_config : "",
-		    cfg->compress_ext ? cfg->compress_ext : "",
+		    wtperf->async_config ? wtperf->async_config : "",
+		    wtperf->compress_ext ? wtperf->compress_ext : "",
 		    opts->verbose > 1 ? debug_cconfig : "",
 		    sess_cfg != NULL ? sess_cfg : "",
 		    user_cconfig != NULL ? user_cconfig : "");
 		if (strlen(cc_buf) && (ret =
-		    config_opt_name_value(cfg, "conn_config", cc_buf)) != 0)
+		    config_opt_name_value(wtperf, "conn_config", cc_buf)) != 0)
 			goto err;
 	}
 	if (opts->verbose > 1 || opts->index ||
-	    user_tconfig != NULL || cfg->compress_table != NULL) {
+	    user_tconfig != NULL || wtperf->compress_table != NULL) {
 		req_len = strlen(debug_tconfig) + 20;
 		if (user_tconfig != NULL)
 			req_len += strlen(user_tconfig);
-		if (cfg->compress_table != NULL)
-			req_len += strlen(cfg->compress_table);
+		if (wtperf->compress_table != NULL)
+			req_len += strlen(wtperf->compress_table);
 		if (opts->index)
 			req_len += strlen(INDEX_COL_NAMES);
 		tc_buf = dmalloc(req_len);
 		snprintf(tc_buf, req_len, "%s,%s,%s,%s",
 		    opts->index ? INDEX_COL_NAMES : "",
-		    cfg->compress_table != NULL ? cfg->compress_table : "",
+		    wtperf->compress_table != NULL ?
+		    wtperf->compress_table : "",
 		    opts->verbose > 1 ? debug_tconfig : "",
 		    user_tconfig ? user_tconfig : "");
 		if (strlen(tc_buf) && (ret =
-		    config_opt_name_value(cfg, "table_config", tc_buf)) != 0)
+		    config_opt_name_value(wtperf, "table_config", tc_buf)) != 0)
 			goto err;
 	}
 	if (opts->log_partial && opts->table_count > 1) {
 		req_len = strlen(opts->table_config) +
 		    strlen(LOG_PARTIAL_CONFIG) + 1;
-		cfg->partial_config = dmalloc(req_len);
-		snprintf(cfg->partial_config, req_len, "%s%s",
+		wtperf->partial_config = dmalloc(req_len);
+		snprintf(wtperf->partial_config, req_len, "%s%s",
 		    opts->table_config, LOG_PARTIAL_CONFIG);
 	}
 	/*
@@ -2587,40 +2600,41 @@ main(int argc, char *argv[])
 		    strlen(READONLY_CONFIG) + 1;
 	else
 		req_len = strlen(opts->conn_config) + 1;
-	cfg->reopen_config = dmalloc(req_len);
+	wtperf->reopen_config = dmalloc(req_len);
 	if (opts->readonly)
-		snprintf(cfg->reopen_config, req_len, "%s%s",
+		snprintf(wtperf->reopen_config, req_len, "%s%s",
 		    opts->conn_config, READONLY_CONFIG);
 	else
-		snprintf(cfg->reopen_config, req_len, "%s", opts->conn_config);
+		snprintf(wtperf->reopen_config,
+		    req_len, "%s", opts->conn_config);
 
 	/* Sanity-check the configuration. */
-	if ((ret = config_sanity(cfg)) != 0)
+	if ((ret = config_sanity(wtperf)) != 0)
 		goto err;
 
 	/* If creating, remove and re-create the home directory. */
 	if (opts->create != 0)
-		recreate_dir(cfg->home);
+		recreate_dir(wtperf->home);
 
 	/* Write a copy of the config. */
-	req_len = strlen(cfg->home) + strlen("/CONFIG.wtperf") + 1;
+	req_len = strlen(wtperf->home) + strlen("/CONFIG.wtperf") + 1;
 	path = dmalloc(req_len);
-	snprintf(path, req_len, "%s/CONFIG.wtperf", cfg->home);
+	snprintf(path, req_len, "%s/CONFIG.wtperf", wtperf->home);
 	config_opt_log(opts, path);
 	free(path);
 
 	/* Display the configuration. */
 	if (opts->verbose > 1)
-		config_opt_print(cfg);
+		config_opt_print(wtperf);
 
-	if ((ret = start_all_runs(cfg)) != 0)
+	if ((ret = start_all_runs(wtperf)) != 0)
 		goto err;
 
 	if (0) {
 einval:		ret = EINVAL;
 	}
 
-err:	config_free(cfg);
+err:	wtperf_free(wtperf);
 	config_opt_cleanup(opts);
 
 	free(cc_buf);
@@ -2633,19 +2647,19 @@ err:	config_free(cfg);
 }
 
 static int
-start_threads(CONFIG *cfg,
-    WORKLOAD *workp, CONFIG_THREAD *base, u_int num, void *(*func)(void *))
+start_threads(WTPERF *wtperf,
+    WORKLOAD *workp, WTPERF_THREAD *base, u_int num, void *(*func)(void *))
 {
 	CONFIG_OPTS *opts;
-	CONFIG_THREAD *thread;
+	WTPERF_THREAD *thread;
 	u_int i;
 	int ret;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
 	/* Initialize the threads. */
 	for (i = 0, thread = base; i < num; ++i, ++thread) {
-		thread->cfg = cfg;
+		thread->wtperf = wtperf;
 		thread->workload = workp;
 
 		/*
@@ -2653,7 +2667,7 @@ start_threads(CONFIG *cfg,
 		 * one differently.
 		 */
 		if ((ret = __wt_random_init_seed(NULL, &thread->rnd)) != 0) {
-			lprintf(cfg, ret, 0, "Error initializing RNG");
+			lprintf(wtperf, ret, 0, "Error initializing RNG");
 			return (ret);
 		}
 
@@ -2688,7 +2702,7 @@ start_threads(CONFIG *cfg,
 	for (i = 0, thread = base; i < num; ++i, ++thread)
 		if ((ret = pthread_create(
 		    &thread->handle, NULL, func, thread)) != 0) {
-			lprintf(cfg, ret, 0, "Error creating thread");
+			lprintf(wtperf, ret, 0, "Error creating thread");
 			return (ret);
 		}
 
@@ -2696,7 +2710,7 @@ start_threads(CONFIG *cfg,
 }
 
 static int
-stop_threads(CONFIG *cfg, u_int num, CONFIG_THREAD *threads)
+stop_threads(WTPERF *wtperf, u_int num, WTPERF_THREAD *threads)
 {
 	u_int i;
 	int ret;
@@ -2706,7 +2720,7 @@ stop_threads(CONFIG *cfg, u_int num, CONFIG_THREAD *threads)
 
 	for (i = 0; i < num; ++i, ++threads) {
 		if ((ret = pthread_join(threads->handle, NULL)) != 0) {
-			lprintf(cfg, ret, 0, "Error joining thread");
+			lprintf(wtperf, ret, 0, "Error joining thread");
 			return (ret);
 		}
 
@@ -2739,7 +2753,7 @@ recreate_dir(const char *name)
 }
 
 static int
-drop_all_tables(CONFIG *cfg)
+drop_all_tables(WTPERF *wtperf)
 {
 	struct timespec start, stop;
 	CONFIG_OPTS *opts;
@@ -2748,26 +2762,27 @@ drop_all_tables(CONFIG *cfg)
 	uint64_t msecs;
 	int ret, t_ret;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
 	/* Drop any tables. */
-	if ((ret = cfg->conn->open_session(
-	    cfg->conn, NULL, opts->sess_config, &session)) != 0) {
-		lprintf(cfg, ret, 0,
-		    "Error opening a session on %s", cfg->home);
+	if ((ret = wtperf->conn->open_session(
+	    wtperf->conn, NULL, opts->sess_config, &session)) != 0) {
+		lprintf(wtperf, ret, 0,
+		    "Error opening a session on %s", wtperf->home);
 		return (ret);
 	}
 	testutil_check(__wt_epoch(NULL, &start));
 	for (i = 0; i < opts->table_count; i++) {
-		if ((ret = session->drop(session, cfg->uris[i], NULL)) != 0) {
-			lprintf(cfg, ret, 0,
-			    "Error dropping table %s", cfg->uris[i]);
+		if ((ret =
+		    session->drop(session, wtperf->uris[i], NULL)) != 0) {
+			lprintf(wtperf, ret, 0,
+			    "Error dropping table %s", wtperf->uris[i]);
 			goto err;
 		}
 	}
 	testutil_check(__wt_epoch(NULL, &stop));
 	msecs = WT_TIMEDIFF_MS(stop, start);
-	lprintf(cfg, 0, 1,
+	lprintf(wtperf, 0, 1,
 	    "Executed %" PRIu32 " drop operations average time %" PRIu64 "ms",
 	    opts->table_count, msecs / opts->table_count);
 
@@ -2777,11 +2792,11 @@ err:	if ((t_ret = session->close(session, NULL)) != 0 && ret == 0)
 }
 
 static uint64_t
-wtperf_value_range(CONFIG *cfg)
+wtperf_value_range(WTPERF *wtperf)
 {
 	CONFIG_OPTS *opts;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 
 	if (opts->random_range)
 		return (opts->icount + opts->random_range);
@@ -2789,21 +2804,22 @@ wtperf_value_range(CONFIG *cfg)
 	 * It is legal to configure a zero size populate phase, hide that
 	 * from other code by pretending the range is 1 in that case.
 	 */
-	if (opts->icount + cfg->insert_key == 0)
+	if (opts->icount + wtperf->insert_key == 0)
 		return (1);
-	return (opts->icount + cfg->insert_key - (u_int)(cfg->workers_cnt + 1));
+	return (opts->icount +
+	    wtperf->insert_key - (u_int)(wtperf->workers_cnt + 1));
 }
 
 static uint64_t
-wtperf_rand(CONFIG_THREAD *thread)
+wtperf_rand(WTPERF_THREAD *thread)
 {
-	CONFIG *cfg;
 	CONFIG_OPTS *opts;
+	WTPERF *wtperf;
 	double S1, S2, U;
 	uint64_t rval;
 
-	cfg = thread->cfg;
-	opts = cfg->opts;
+	wtperf = thread->wtperf;
+	opts = wtperf->opts;
 
 	/*
 	 * Use WiredTiger's random number routine: it's lock-free and fairly
@@ -2815,7 +2831,7 @@ wtperf_rand(CONFIG_THREAD *thread)
 	if (opts->pareto != 0) {
 #define	PARETO_SHAPE	1.5
 		S1 = (-1 / PARETO_SHAPE);
-		S2 = wtperf_value_range(cfg) *
+		S2 = wtperf_value_range(wtperf) *
 		    (opts->pareto / 100.0) * (PARETO_SHAPE - 1);
 		U = 1 - (double)rval / (double)UINT32_MAX;
 		rval = (uint64_t)((pow(U, S1) - 1) * S2);
@@ -2824,13 +2840,13 @@ wtperf_rand(CONFIG_THREAD *thread)
 		 * 2% of the time, from my testing. That will lead to the
 		 * first item in the table being "hot".
 		 */
-		if (rval > wtperf_value_range(cfg))
+		if (rval > wtperf_value_range(wtperf))
 			rval = 0;
 	}
 	/*
 	 * Wrap the key to within the expected range and avoid zero: we never
 	 * insert that key.
 	 */
-	rval = (rval % wtperf_value_range(cfg)) + 1;
+	rval = (rval % wtperf_value_range(wtperf)) + 1;
 	return (rval);
 }
diff --git a/bench/wtperf/wtperf.h b/bench/wtperf/wtperf.h
index 0cba8503186..afce017d919 100644
--- a/bench/wtperf/wtperf.h
+++ b/bench/wtperf/wtperf.h
@@ -36,8 +36,8 @@
 
 #include "config_opt.h"
 
-typedef struct __config CONFIG;
-typedef struct __config_thread CONFIG_THREAD;
+typedef struct __wtperf WTPERF;
+typedef struct __wtperf_thread WTPERF_THREAD;
 typedef struct __truncate_queue_entry TRUNCATE_QUEUE_ENTRY;
 
 #define	EXT_PFX	",extensions=("
@@ -105,11 +105,7 @@ typedef struct {
 
 #define	LOG_PARTIAL_CONFIG	",log=(enabled=false)"
 #define	READONLY_CONFIG		",readonly=true"
-/*
- * NOTE:  If you add any fields to this structure here, you must also add
- * an initialization in wtperf.c in the default_cfg.
- */
-struct __config {			/* Configuration structure */
+struct __wtperf {			/* Per-database structure */
 	char *home;			/* WiredTiger home */
 	char *monitor_dir;		/* Monitor output dir */
 	char *partial_config;		/* Config string for partial logging */
@@ -127,10 +123,11 @@ struct __config {			/* Configuration structure */
 	const char *compress_ext;	/* Compression extension for conn */
 	const char *compress_table;	/* Compression arg to table create */
 
-	CONFIG_THREAD *ckptthreads, *popthreads;
+	WTPERF_THREAD *ckptthreads;	/* Checkpoint threads */
+	WTPERF_THREAD *popthreads;	/* Populate threads */
 
 #define	WORKLOAD_MAX	50
-	CONFIG_THREAD	*workers;	/* Worker threads */
+	WTPERF_THREAD	*workers;	/* Worker threads */
 	u_int		 workers_cnt;
 
 	WORKLOAD	*workload;	/* Workloads */
@@ -223,8 +220,8 @@ typedef struct {
 	uint32_t sec[100];		/* < 1s 2s ... 100s */
 } TRACK;
 
-struct __config_thread {		/* Per-thread structure */
-	CONFIG *cfg;			/* Enclosing configuration */
+struct __wtperf_thread {		/* Per-thread structure */
+	WTPERF *wtperf;			/* Enclosing configuration */
 
 	WT_RAND_STATE rnd;		/* Random number generation state */
 
@@ -246,52 +243,45 @@ struct __config_thread {		/* Per-thread structure */
 	TRACK truncate_sleep;		/* Truncate sleep operations */
 };
 
-void	 cleanup_truncate_config(CONFIG *);
-int	 config_opt_file(CONFIG *, const char *);
+void	 cleanup_truncate_config(WTPERF *);
+int	 config_opt_file(WTPERF *, const char *);
 void	 config_opt_cleanup(CONFIG_OPTS *);
 void	 config_opt_init(CONFIG_OPTS **);
 void	 config_opt_log(CONFIG_OPTS *, const char *);
-int	 config_opt_name_value(CONFIG *, const char *, const char *);
-void	 config_opt_print(CONFIG *);
-int	 config_opt_str(CONFIG *, const char *);
+int	 config_opt_name_value(WTPERF *, const char *, const char *);
+void	 config_opt_print(WTPERF *);
+int	 config_opt_str(WTPERF *, const char *);
 void	 config_opt_usage(void);
-int	 config_sanity(CONFIG *);
-void	 latency_insert(CONFIG *, uint32_t *, uint32_t *, uint32_t *);
-void	 latency_print(CONFIG *);
-void	 latency_read(CONFIG *, uint32_t *, uint32_t *, uint32_t *);
-void	 latency_update(CONFIG *, uint32_t *, uint32_t *, uint32_t *);
+int	 config_sanity(WTPERF *);
+void	 latency_insert(WTPERF *, uint32_t *, uint32_t *, uint32_t *);
+void	 latency_print(WTPERF *);
+void	 latency_read(WTPERF *, uint32_t *, uint32_t *, uint32_t *);
+void	 latency_update(WTPERF *, uint32_t *, uint32_t *, uint32_t *);
 int	 run_truncate(
-	    CONFIG *, CONFIG_THREAD *, WT_CURSOR *, WT_SESSION *, int *);
-int	 setup_log_file(CONFIG *);
-void	 setup_throttle(CONFIG_THREAD*);
-int	 setup_truncate(CONFIG *, CONFIG_THREAD *, WT_SESSION *);
-int	 start_idle_table_cycle(CONFIG *, pthread_t *);
-int	 stop_idle_table_cycle(CONFIG *, pthread_t);
-void	 worker_throttle(CONFIG_THREAD*);
-uint64_t sum_ckpt_ops(CONFIG *);
-uint64_t sum_insert_ops(CONFIG *);
-uint64_t sum_pop_ops(CONFIG *);
-uint64_t sum_read_ops(CONFIG *);
-uint64_t sum_truncate_ops(CONFIG *);
-uint64_t sum_update_ops(CONFIG *);
-
-void	 lprintf(const CONFIG *, int err, uint32_t, const char *, ...)
+	    WTPERF *, WTPERF_THREAD *, WT_CURSOR *, WT_SESSION *, int *);
+int	 setup_log_file(WTPERF *);
+void	 setup_throttle(WTPERF_THREAD *);
+int	 setup_truncate(WTPERF *, WTPERF_THREAD *, WT_SESSION *);
+int	 start_idle_table_cycle(WTPERF *, pthread_t *);
+int	 stop_idle_table_cycle(WTPERF *, pthread_t);
+void	 worker_throttle(WTPERF_THREAD *);
+uint64_t sum_ckpt_ops(WTPERF *);
+uint64_t sum_insert_ops(WTPERF *);
+uint64_t sum_pop_ops(WTPERF *);
+uint64_t sum_read_ops(WTPERF *);
+uint64_t sum_truncate_ops(WTPERF *);
+uint64_t sum_update_ops(WTPERF *);
+
+void	 lprintf(const WTPERF *, int err, uint32_t, const char *, ...)
 #if defined(__GNUC__)
 __attribute__((format (printf, 4, 5)))
 #endif
 ;
 
 static inline void
-generate_key(CONFIG *cfg, char *key_buf, uint64_t keyno)
+generate_key(CONFIG_OPTS *opts, char *key_buf, uint64_t keyno)
 {
-	CONFIG_OPTS *opts;
-
-	opts = cfg->opts;
-
-	/*
-	 * Don't change to snprintf, sprintf is faster in some tests.
-	 */
-	sprintf(key_buf, "%0*" PRIu64, opts->key_sz - 1, keyno);
+	u64_to_string_zf(keyno, key_buf, opts->key_sz);
 }
 
 static inline void
diff --git a/bench/wtperf/wtperf_throttle.c b/bench/wtperf/wtperf_throttle.c
index e49bca00d07..70b5084656f 100644
--- a/bench/wtperf/wtperf_throttle.c
+++ b/bench/wtperf/wtperf_throttle.c
@@ -32,7 +32,7 @@
  * Put the initial config together for running a throttled workload.
  */
 void
-setup_throttle(CONFIG_THREAD *thread)
+setup_throttle(WTPERF_THREAD *thread)
 {
 	THROTTLE_CONFIG *throttle_cfg;
 
@@ -78,7 +78,7 @@ setup_throttle(CONFIG_THREAD *thread)
  * counter to perform more operations.
  */
 void
-worker_throttle(CONFIG_THREAD *thread)
+worker_throttle(WTPERF_THREAD *thread)
 {
 	THROTTLE_CONFIG *throttle_cfg;
 	struct timespec now;
diff --git a/bench/wtperf/wtperf_truncate.c b/bench/wtperf/wtperf_truncate.c
index aac79b4b96d..3fbb740d2c8 100644
--- a/bench/wtperf/wtperf_truncate.c
+++ b/bench/wtperf/wtperf_truncate.c
@@ -35,7 +35,7 @@ decode_key(char *key_buf)
 }
 
 int
-setup_truncate(CONFIG *cfg, CONFIG_THREAD *thread, WT_SESSION *session)
+setup_truncate(WTPERF *wtperf, WTPERF_THREAD *thread, WT_SESSION *session)
 {
 	CONFIG_OPTS *opts;
 	TRUNCATE_CONFIG *trunc_cfg;
@@ -46,14 +46,14 @@ setup_truncate(CONFIG *cfg, CONFIG_THREAD *thread, WT_SESSION *session)
 	int ret;
 	uint64_t end_point, final_stone_gap, i, start_point;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 	end_point = final_stone_gap = start_point = 0;
 	trunc_cfg = &thread->trunc_cfg;
 	workload = thread->workload;
 
 	/* We are limited to only one table when running truncate. */
 	if ((ret = session->open_cursor(
-	    session, cfg->uris[0], NULL, NULL, &cursor)) != 0)
+	    session, wtperf->uris[0], NULL, NULL, &cursor)) != 0)
 		goto err;
 
 	/*
@@ -81,14 +81,14 @@ setup_truncate(CONFIG *cfg, CONFIG_THREAD *thread, WT_SESSION *session)
 	 */
 	if ((ret = cursor->next(cursor)) != 0 ||
 	    (ret = cursor->get_key(cursor, &key)) != 0) {
-		lprintf(cfg, ret, 0, "truncate setup start: failed");
+		lprintf(wtperf, ret, 0, "truncate setup start: failed");
 		goto err;
 	}
 
 	start_point = decode_key(key);
 	if ((cursor->reset(cursor)) != 0 || (ret = cursor->prev(cursor)) != 0 ||
 	    (ret = cursor->get_key(cursor, &key)) != 0) {
-		lprintf(cfg, ret, 0, "truncate setup end: failed");
+		lprintf(wtperf, ret, 0, "truncate setup end: failed");
 		goto err;
 	}
 	end_point = decode_key(key);
@@ -108,10 +108,11 @@ setup_truncate(CONFIG *cfg, CONFIG_THREAD *thread, WT_SESSION *session)
 			    dcalloc(sizeof(TRUNCATE_QUEUE_ENTRY), 1);
 			truncate_item->key = dcalloc(opts->key_sz, 1);
 			generate_key(
-			    cfg, truncate_item->key, trunc_cfg->stone_gap * i);
+			    opts, truncate_item->key, trunc_cfg->stone_gap * i);
 			truncate_item->diff =
 			    (trunc_cfg->stone_gap * i) - trunc_cfg->last_key;
-			TAILQ_INSERT_TAIL(&cfg->stone_head, truncate_item, q);
+			TAILQ_INSERT_TAIL(
+			    &wtperf->stone_head, truncate_item, q);
 			trunc_cfg->last_key = trunc_cfg->stone_gap * i;
 			trunc_cfg->num_stones++;
 		}
@@ -119,13 +120,13 @@ setup_truncate(CONFIG *cfg, CONFIG_THREAD *thread, WT_SESSION *session)
 	trunc_cfg->stone_gap = final_stone_gap;
 
 err:	if ((ret = cursor->close(cursor)) != 0) {
-		lprintf(cfg, ret, 0, "truncate setup: cursor close failed");
+		lprintf(wtperf, ret, 0, "truncate setup: cursor close failed");
 	}
 	return (ret);
 }
 
 int
-run_truncate(CONFIG *cfg, CONFIG_THREAD *thread,
+run_truncate(WTPERF *wtperf, WTPERF_THREAD *thread,
     WT_CURSOR *cursor, WT_SESSION *session, int *truncatedp)
 {
 	CONFIG_OPTS *opts;
@@ -135,13 +136,13 @@ run_truncate(CONFIG *cfg, CONFIG_THREAD *thread,
 	int ret, t_ret;
 	uint64_t used_stone_gap;
 
-	opts = cfg->opts;
+	opts = wtperf->opts;
 	trunc_cfg = &thread->trunc_cfg;
 	ret = 0;
 
 	*truncatedp = 0;
 	/* Update the total inserts */
-	trunc_cfg->total_inserts = sum_insert_ops(cfg);
+	trunc_cfg->total_inserts = sum_insert_ops(wtperf);
 	trunc_cfg->expected_total +=
 	    (trunc_cfg->total_inserts - trunc_cfg->last_total_inserts);
 	trunc_cfg->last_total_inserts = trunc_cfg->total_inserts;
@@ -175,9 +176,9 @@ run_truncate(CONFIG *cfg, CONFIG_THREAD *thread,
 		trunc_cfg->last_key += used_stone_gap;
 		truncate_item = dcalloc(sizeof(TRUNCATE_QUEUE_ENTRY), 1);
 		truncate_item->key = dcalloc(opts->key_sz, 1);
-		generate_key(cfg, truncate_item->key, trunc_cfg->last_key);
+		generate_key(opts, truncate_item->key, trunc_cfg->last_key);
 		truncate_item->diff = used_stone_gap;
-		TAILQ_INSERT_TAIL(&cfg->stone_head, truncate_item, q);
+		TAILQ_INSERT_TAIL(&wtperf->stone_head, truncate_item, q);
 		trunc_cfg->num_stones++;
 	}
 
@@ -186,9 +187,9 @@ run_truncate(CONFIG *cfg, CONFIG_THREAD *thread,
 	    trunc_cfg->expected_total <= thread->workload->truncate_count)
 		return (0);
 
-	truncate_item = TAILQ_FIRST(&cfg->stone_head);
+	truncate_item = TAILQ_FIRST(&wtperf->stone_head);
 	trunc_cfg->num_stones--;
-	TAILQ_REMOVE(&cfg->stone_head, truncate_item, q);
+	TAILQ_REMOVE(&wtperf->stone_head, truncate_item, q);
 
 	/*
 	 * Truncate the content via a single truncate call or a cursor walk
@@ -200,20 +201,21 @@ run_truncate(CONFIG *cfg, CONFIG_THREAD *thread,
 			if (strcmp(next_key, truncate_item->key) == 0)
 				break;
 			if ((ret = cursor->remove(cursor)) != 0) {
-				lprintf(cfg, ret, 0, "Truncate remove: failed");
+				lprintf(wtperf,
+				    ret, 0, "Truncate remove: failed");
 				goto err;
 			}
 		}
 	} else {
 		cursor->set_key(cursor,truncate_item->key);
 		if ((ret = cursor->search(cursor)) != 0) {
-			lprintf(cfg, ret, 0, "Truncate search: failed");
+			lprintf(wtperf, ret, 0, "Truncate search: failed");
 			goto err;
 		}
 
 		if ((ret = session->truncate(
 		    session, NULL, NULL, cursor, NULL)) != 0) {
-			lprintf(cfg, ret, 0, "Truncate: failed");
+			lprintf(wtperf, ret, 0, "Truncate: failed");
 			goto err;
 		}
 	}
@@ -225,19 +227,20 @@ err:	free(truncate_item->key);
 	free(truncate_item);
 	t_ret = cursor->reset(cursor);
 	if (t_ret != 0)
-		lprintf(cfg, t_ret, 0, "Cursor reset failed");
+		lprintf(wtperf, t_ret, 0, "Cursor reset failed");
 	if (ret == 0 && t_ret != 0)
 		ret = t_ret;
 	return (ret);
 }
 
 void
-cleanup_truncate_config(CONFIG *cfg) {
+cleanup_truncate_config(WTPERF *wtperf)
+{
 	TRUNCATE_QUEUE_ENTRY *truncate_item;
 
-	while (!TAILQ_EMPTY(&cfg->stone_head)) {
-		truncate_item = TAILQ_FIRST(&cfg->stone_head);
-		TAILQ_REMOVE(&cfg->stone_head, truncate_item, q);
+	while (!TAILQ_EMPTY(&wtperf->stone_head)) {
+		truncate_item = TAILQ_FIRST(&wtperf->stone_head);
+		TAILQ_REMOVE(&wtperf->stone_head, truncate_item, q);
 		free(truncate_item->key);
 		free(truncate_item);
 	}