/*
* __lsm_worker --
* A thread that executes work units for all open LSM trees.
*/
static WT_THREAD_RET
__lsm_worker(void *arg)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_LSM_WORK_UNIT *entry;
WT_LSM_WORKER_ARGS *cookie;
WT_SESSION_IMPL *session;
int progress, ran;
cookie = (WT_LSM_WORKER_ARGS *)arg;
session = cookie->session;
conn = S2C(session);
entry = NULL;
while (F_ISSET(conn, WT_CONN_SERVER_RUN) &&
F_ISSET(cookie, WT_LSM_WORKER_RUN)) {
progress = 0;
/*
* Workers process the different LSM work queues. Some workers
* can handle several or all work unit types. So the code is
* prioritized so important operations happen first.
* Switches are the highest priority.
*/
while (FLD_ISSET(cookie->type, WT_LSM_WORK_SWITCH) &&
(ret = __wt_lsm_manager_pop_entry(
session, WT_LSM_WORK_SWITCH, &entry)) == 0 &&
entry != NULL)
WT_ERR(
__wt_lsm_work_switch(session, &entry, &progress));
/* Flag an error if the pop failed. */
WT_ERR(ret);
/*
* Next the general operations.
*/
ret = __lsm_worker_general_op(session, cookie, &ran);
if (ret == EBUSY || ret == WT_NOTFOUND)
ret = 0;
WT_ERR(ret);
progress = progress || ran;
/*
* Finally see if there is any merge work we can do. This is
* last because the earlier operations may result in adding
* merge work to the queue.
*/
if (FLD_ISSET(cookie->type, WT_LSM_WORK_MERGE) &&
(ret = __wt_lsm_manager_pop_entry(
session, WT_LSM_WORK_MERGE, &entry)) == 0 &&
entry != NULL) {
WT_ASSERT(session, entry->type == WT_LSM_WORK_MERGE);
ret = __wt_lsm_merge(session,
entry->lsm_tree, cookie->id);
if (ret == WT_NOTFOUND) {
F_CLR(entry->lsm_tree, WT_LSM_TREE_COMPACTING);
ret = 0;
} else if (ret == EBUSY)
ret = 0;
/* Paranoia: clear session state. */
session->dhandle = NULL;
__wt_lsm_manager_free_work_unit(session, entry);
entry = NULL;
progress = 1;
}
/* Flag an error if the pop failed. */
WT_ERR(ret);
/* Don't busy wait if there was any work to do. */
if (!progress) {
WT_ERR(
__wt_cond_wait(session, cookie->work_cond, 10000));
continue;
}
}
if (ret != 0) {
err: __wt_lsm_manager_free_work_unit(session, entry);
WT_PANIC_MSG(session, ret,
"Error in LSM worker thread %d", cookie->id);
}
return (WT_THREAD_RET_VALUE);
}
/*
* __wt_lsm_merge_worker --
* The merge worker thread for an LSM tree, responsible for merging
* on-disk trees.
*/
void *
__wt_lsm_merge_worker(void *vargs)
{
WT_DECL_RET;
WT_LSM_WORKER_ARGS *args;
WT_LSM_TREE *lsm_tree;
WT_SESSION_IMPL *session;
u_int aggressive, chunk_wait, id, old_aggressive, stallms;
int progress;
args = vargs;
lsm_tree = args->lsm_tree;
id = args->id;
session = lsm_tree->worker_sessions[id];
__wt_free(session, args);
aggressive = stallms = 0;
while (F_ISSET(lsm_tree, WT_LSM_TREE_WORKING)) {
/*
* Help out with switching chunks in case the checkpoint worker
* is busy.
*/
if (F_ISSET(lsm_tree, WT_LSM_TREE_NEED_SWITCH)) {
WT_WITH_SCHEMA_LOCK(session, ret =
__wt_lsm_tree_switch(session, lsm_tree));
WT_ERR(ret);
}
progress = 0;
/* Clear any state from previous worker thread iterations. */
session->dhandle = NULL;
/* Try to create a Bloom filter. */
if (__lsm_bloom_work(session, lsm_tree) == 0)
progress = 1;
/* If we didn't create a Bloom filter, try to merge. */
if (progress == 0 &&
__wt_lsm_merge(session, lsm_tree, id, aggressive) == 0)
progress = 1;
/* Clear any state from previous worker thread iterations. */
WT_CLEAR_BTREE_IN_SESSION(session);
/*
* Only have one thread freeing old chunks, and only if there
* are chunks to free.
*/
if (id == 0 && lsm_tree->nold_chunks > 0 &&
__lsm_free_chunks(session, lsm_tree) == 0)
progress = 1;
if (progress)
stallms = 0;
else if (F_ISSET(lsm_tree, WT_LSM_TREE_WORKING) &&
!F_ISSET(lsm_tree, WT_LSM_TREE_NEED_SWITCH)) {
/* Poll 10 times per second. */
WT_ERR_TIMEDOUT_OK(__wt_cond_wait(
session, lsm_tree->work_cond, 100000));
stallms += 100;
/*
* Get aggressive if more than enough chunks for a
* merge should have been created while we waited.
* Use 10 seconds as a default if we don't have an
* estimate.
*/
chunk_wait = stallms / (lsm_tree->chunk_fill_ms == 0 ?
10000 : lsm_tree->chunk_fill_ms);
old_aggressive = aggressive;
aggressive = chunk_wait / lsm_tree->merge_min;
if (aggressive > old_aggressive)
WT_VERBOSE_ERR(session, lsm,
"LSM merge got aggressive (%u), "
"%u / %" PRIu64,
aggressive, stallms,
lsm_tree->chunk_fill_ms);
}
}
if (0) {
err: __wt_err(session, ret, "LSM merge worker failed");
}
return (NULL);
}
