/*
* __wt_btcur_update --
* Update a record in the tree.
*/
int
__wt_btcur_update(WT_CURSOR_BTREE *cbt)
{
WT_BTREE *btree;
WT_CURSOR *cursor;
WT_DECL_RET;
WT_SESSION_IMPL *session;
btree = cbt->btree;
cursor = &cbt->iface;
session = (WT_SESSION_IMPL *)cursor->session;
WT_STAT_CONN_INCR(session, cursor_update);
WT_STAT_DATA_INCR(session, cursor_update);
WT_STAT_DATA_INCRV(session, cursor_update_bytes, cursor->value.size);
if (btree->type == BTREE_ROW)
WT_RET(__cursor_size_chk(session, &cursor->key));
WT_RET(__cursor_size_chk(session, &cursor->value));
/*
* The tree is no longer empty: eviction should pay attention to it,
* and it's no longer possible to bulk-load into it.
*/
if (btree->bulk_load_ok) {
btree->bulk_load_ok = false;
__wt_btree_evictable(session, true);
}
retry: WT_RET(__cursor_func_init(cbt, true));
switch (btree->type) {
case BTREE_COL_FIX:
case BTREE_COL_VAR:
WT_ERR(__cursor_col_search(session, cbt, NULL));
/*
* If not overwriting, fail if the key doesn't exist. If we
* find an update for the key, check for conflicts. Update the
* record if it exists. Creating a record past the end of the
* tree in a fixed-length column-store implicitly fills the gap
* with empty records. Update the record in that case, the
* record exists.
*/
if (!F_ISSET(cursor, WT_CURSTD_OVERWRITE)) {
WT_ERR(__curfile_update_check(cbt));
if ((cbt->compare != 0 || !__cursor_valid(cbt, NULL)) &&
!__cursor_fix_implicit(btree, cbt))
WT_ERR(WT_NOTFOUND);
}
ret = __cursor_col_modify(session, cbt, false);
break;
case BTREE_ROW:
WT_ERR(__cursor_row_search(session, cbt, NULL, true));
/*
* If not overwriting, check for conflicts and fail if the key
* does not exist.
*/
if (!F_ISSET(cursor, WT_CURSTD_OVERWRITE)) {
WT_ERR(__curfile_update_check(cbt));
if (cbt->compare != 0 || !__cursor_valid(cbt, NULL))
WT_ERR(WT_NOTFOUND);
}
ret = __cursor_row_modify(session, cbt, false);
break;
}
err: if (ret == WT_RESTART) {
WT_STAT_CONN_INCR(session, cursor_restart);
WT_STAT_DATA_INCR(session, cursor_restart);
goto retry;
}
/*
* If successful, point the cursor at internal copies of the data. We
* could shuffle memory in the cursor so the key/value pair are in local
* buffer memory, but that's a data copy. We don't want to do another
* search (and we might get a different update structure if we race).
* To make this work, we add a field to the btree cursor to pass back a
* pointer to the modify function's allocated update structure.
*/
if (ret == 0)
WT_TRET(__wt_kv_return(session, cbt, cbt->modify_update));
if (ret != 0)
WT_TRET(__cursor_reset(cbt));
return (ret);
}
/*
* __wt_lsm_checkpoint_chunk --
* Flush a single LSM chunk to disk.
*/
int
__wt_lsm_checkpoint_chunk(WT_SESSION_IMPL *session,
WT_LSM_TREE *lsm_tree, WT_LSM_CHUNK *chunk)
{
WT_DECL_RET;
WT_TXN_ISOLATION saved_isolation;
bool flush_set;
flush_set = false;
/*
* If the chunk is already checkpointed, make sure it is also evicted.
* Either way, there is no point trying to checkpoint it again.
*/
if (F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
!F_ISSET(chunk, WT_LSM_CHUNK_STABLE) &&
!chunk->evicted) {
WT_WITH_HANDLE_LIST_LOCK(session,
ret = __lsm_discard_handle(session, chunk->uri, NULL));
if (ret == 0)
chunk->evicted = 1;
else if (ret == EBUSY)
ret = 0;
else
WT_RET_MSG(session, ret, "discard handle");
}
if (F_ISSET(chunk, WT_LSM_CHUNK_ONDISK)) {
WT_RET(__wt_verbose(session, WT_VERB_LSM,
"LSM worker %s already on disk",
chunk->uri));
return (0);
}
/* Stop if a running transaction needs the chunk. */
__wt_txn_update_oldest(session, true);
if (chunk->switch_txn == WT_TXN_NONE ||
!__wt_txn_visible_all(session, chunk->switch_txn)) {
WT_RET(__wt_verbose(session, WT_VERB_LSM,
"LSM worker %s: running transaction, return",
chunk->uri));
return (0);
}
if (!__wt_atomic_cas8(&chunk->flushing, 0, 1))
return (0);
flush_set = true;
WT_ERR(__wt_verbose(session, WT_VERB_LSM, "LSM worker flushing %s",
chunk->uri));
/*
* Flush the file before checkpointing: this is the expensive part in
* terms of I/O.
*
* !!!
* We can wait here for checkpoints and fsyncs to complete, which can
* take a long time.
*/
if ((ret = __wt_session_get_btree(
session, chunk->uri, NULL, NULL, 0)) == 0) {
/*
* Set read-uncommitted: we have already checked that all of the
* updates in this chunk are globally visible, use the cheapest
* possible check in reconciliation.
*/
saved_isolation = session->txn.isolation;
session->txn.isolation = WT_ISO_READ_UNCOMMITTED;
ret = __wt_cache_op(session, NULL, WT_SYNC_WRITE_LEAVES);
session->txn.isolation = saved_isolation;
WT_TRET(__wt_session_release_btree(session));
}
WT_ERR(ret);
WT_ERR(__wt_verbose(session, WT_VERB_LSM, "LSM worker checkpointing %s",
chunk->uri));
/*
* Turn on metadata tracking to ensure the checkpoint gets the
* necessary handle locks.
*
* Ensure that we don't race with a running checkpoint: the checkpoint
* lock protects against us racing with an application checkpoint in
* this chunk. Don't wait for it, though: checkpoints can take a long
* time, and our checkpoint operation should be very quick.
*/
WT_ERR(__wt_meta_track_on(session));
WT_WITH_CHECKPOINT_LOCK(session, ret,
WT_WITH_SCHEMA_LOCK(session, ret,
ret = __wt_schema_worker(
session, chunk->uri, __wt_checkpoint, NULL, NULL, 0)));
WT_TRET(__wt_meta_track_off(session, false, ret != 0));
if (ret != 0)
WT_ERR_MSG(session, ret, "LSM checkpoint");
/* Now the file is written, get the chunk size. */
WT_ERR(__wt_lsm_tree_set_chunk_size(session, chunk));
/* Update the flush timestamp to help track ongoing progress. */
WT_ERR(__wt_epoch(session, &lsm_tree->last_flush_ts));
++lsm_tree->chunks_flushed;
/* Lock the tree, mark the chunk as on disk and update the metadata. */
WT_ERR(__wt_lsm_tree_writelock(session, lsm_tree));
F_SET(chunk, WT_LSM_CHUNK_ONDISK);
ret = __wt_lsm_meta_write(session, lsm_tree);
++lsm_tree->dsk_gen;
/* Update the throttle time. */
__wt_lsm_tree_throttle(session, lsm_tree, true);
WT_TRET(__wt_lsm_tree_writeunlock(session, lsm_tree));
if (ret != 0)
WT_ERR_MSG(session, ret, "LSM metadata write");
WT_PUBLISH(chunk->flushing, 0);
flush_set = false;
/*
* Clear the no-eviction flag so the primary can be evicted and
* eventually closed. Only do this once the checkpoint has succeeded:
* otherwise, accessing the leaf page during the checkpoint can trigger
* forced eviction.
*/
WT_ERR(__wt_session_get_btree(session, chunk->uri, NULL, NULL, 0));
__wt_btree_evictable(session, true);
WT_ERR(__wt_session_release_btree(session));
/* Make sure we aren't pinning a transaction ID. */
__wt_txn_release_snapshot(session);
WT_ERR(__wt_verbose(session, WT_VERB_LSM, "LSM worker checkpointed %s",
chunk->uri));
/* Schedule a bloom filter create for our newly flushed chunk. */
if (!FLD_ISSET(lsm_tree->bloom, WT_LSM_BLOOM_OFF))
WT_ERR(__wt_lsm_manager_push_entry(
session, WT_LSM_WORK_BLOOM, 0, lsm_tree));
else
WT_ERR(__wt_lsm_manager_push_entry(
session, WT_LSM_WORK_MERGE, 0, lsm_tree));
err: if (flush_set)
WT_PUBLISH(chunk->flushing, 0);
return (ret);
}
/*
* __wt_btcur_insert --
* Insert a record into the tree.
*/
int
__wt_btcur_insert(WT_CURSOR_BTREE *cbt)
{
WT_BTREE *btree;
WT_CURSOR *cursor;
WT_DECL_RET;
WT_SESSION_IMPL *session;
btree = cbt->btree;
cursor = &cbt->iface;
session = (WT_SESSION_IMPL *)cursor->session;
WT_STAT_CONN_INCR(session, cursor_insert);
WT_STAT_DATA_INCR(session, cursor_insert);
WT_STAT_DATA_INCRV(session,
cursor_insert_bytes, cursor->key.size + cursor->value.size);
if (btree->type == BTREE_ROW)
WT_RET(__cursor_size_chk(session, &cursor->key));
WT_RET(__cursor_size_chk(session, &cursor->value));
/*
* The tree is no longer empty: eviction should pay attention to it,
* and it's no longer possible to bulk-load into it.
*/
if (btree->bulk_load_ok) {
btree->bulk_load_ok = false;
__wt_btree_evictable(session, true);
}
retry: WT_RET(__cursor_func_init(cbt, true));
switch (btree->type) {
case BTREE_COL_FIX:
case BTREE_COL_VAR:
/*
* If WT_CURSTD_APPEND is set, insert a new record (ignoring
* the application's record number). The real record number
* is assigned by the serialized append operation.
*/
if (F_ISSET(cursor, WT_CURSTD_APPEND))
cbt->iface.recno = WT_RECNO_OOB;
WT_ERR(__cursor_col_search(session, cbt, NULL));
/*
* If not overwriting, fail if the key exists. Creating a
* record past the end of the tree in a fixed-length
* column-store implicitly fills the gap with empty records.
* Fail in that case, the record exists.
*/
if (!F_ISSET(cursor, WT_CURSTD_OVERWRITE) &&
((cbt->compare == 0 && __cursor_valid(cbt, NULL)) ||
(cbt->compare != 0 && __cursor_fix_implicit(btree, cbt))))
WT_ERR(WT_DUPLICATE_KEY);
WT_ERR(__cursor_col_modify(session, cbt, false));
if (F_ISSET(cursor, WT_CURSTD_APPEND))
cbt->iface.recno = cbt->recno;
break;
case BTREE_ROW:
WT_ERR(__cursor_row_search(session, cbt, NULL, true));
/*
* If not overwriting, fail if the key exists, else insert the
* key/value pair.
*/
if (!F_ISSET(cursor, WT_CURSTD_OVERWRITE) &&
cbt->compare == 0 && __cursor_valid(cbt, NULL))
WT_ERR(WT_DUPLICATE_KEY);
ret = __cursor_row_modify(session, cbt, false);
break;
}
err: if (ret == WT_RESTART) {
WT_STAT_CONN_INCR(session, cursor_restart);
WT_STAT_DATA_INCR(session, cursor_restart);
goto retry;
}
/* Insert doesn't maintain a position across calls, clear resources. */
if (ret == 0)
WT_TRET(__curfile_leave(cbt));
if (ret != 0)
WT_TRET(__cursor_reset(cbt));
return (ret);
}
/*
* __clsm_open_cursors --
* Open cursors for the current set of files.
*/
static int
__clsm_open_cursors(
WT_CURSOR_LSM *clsm, int update, u_int start_chunk, uint32_t start_id)
{
WT_CURSOR *c, **cp, *primary;
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_TREE *lsm_tree;
WT_SESSION_IMPL *session;
WT_TXN *txn;
const char *checkpoint, *ckpt_cfg[3];
uint64_t saved_gen;
u_int i, nchunks, ngood, nupdates;
int locked;
c = &clsm->iface;
session = (WT_SESSION_IMPL *)c->session;
txn = &session->txn;
lsm_tree = clsm->lsm_tree;
chunk = NULL;
ckpt_cfg[0] = WT_CONFIG_BASE(session, session_open_cursor);
ckpt_cfg[1] = "checkpoint=" WT_CHECKPOINT ",raw";
ckpt_cfg[2] = NULL;
/* Copy the key, so we don't lose the cursor position. */
if (F_ISSET(c, WT_CURSTD_KEY_INT) && !WT_DATA_IN_ITEM(&c->key))
WT_RET(__wt_buf_set(
session, &c->key, c->key.data, c->key.size));
F_CLR(clsm, WT_CLSM_ITERATE_NEXT | WT_CLSM_ITERATE_PREV);
if (update) {
if (txn->isolation == TXN_ISO_SNAPSHOT)
F_SET(clsm, WT_CLSM_OPEN_SNAPSHOT);
} else
F_SET(clsm, WT_CLSM_OPEN_READ);
WT_RET(__wt_lsm_tree_lock(session, lsm_tree, 0));
locked = 1;
/*
* If there is no in-memory chunk in the tree for an update operation,
* create one.
*
* !!!
* It is exceeding unlikely that we get here at all, but if there is a
* transaction in progress and it rolls back, it would leave the
* metadata inconsistent.
*/
if (update && (lsm_tree->nchunks == 0 ||
(chunk = lsm_tree->chunk[lsm_tree->nchunks - 1]) == NULL ||
F_ISSET(chunk, WT_LSM_CHUNK_ONDISK))) {
/* Release our lock because switch will get a write lock. */
locked = 0;
WT_ERR(__wt_lsm_tree_unlock(session, lsm_tree));
WT_ERR(__wt_lsm_tree_switch(session, lsm_tree));
WT_ERR(__wt_lsm_tree_lock(session, lsm_tree, 0));
locked = 1;
}
F_SET(session, WT_SESSION_NO_CACHE_CHECK);
/* Merge cursors have already figured out how many chunks they need. */
retry: if (F_ISSET(clsm, WT_CLSM_MERGE)) {
nchunks = clsm->nchunks;
ngood = 0;
/*
* We may have raced with another merge completing. Check that
* we're starting at the right offset in the chunk array.
*/
if (start_chunk >= lsm_tree->nchunks ||
lsm_tree->chunk[start_chunk]->id != start_id) {
for (start_chunk = 0;
start_chunk < lsm_tree->nchunks;
start_chunk++) {
chunk = lsm_tree->chunk[start_chunk];
if (chunk->id == start_id)
break;
}
/* We have to find the start chunk: merge locked it. */
WT_ASSERT(session, start_chunk < lsm_tree->nchunks);
}
WT_ASSERT(session, start_chunk + nchunks <= lsm_tree->nchunks);
} else {
nchunks = lsm_tree->nchunks;
/*
* If we are only opening the cursor for updates, only open the
* primary chunk, plus any other chunks that might be required
* to detect snapshot isolation conflicts.
*/
if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT))
WT_ERR(__wt_realloc_def(session,
&clsm->txnid_alloc, nchunks,
&clsm->txnid_max));
if (F_ISSET(clsm, WT_CLSM_OPEN_READ))
ngood = nupdates = 0;
else if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT)) {
/*
* Keep going until all updates in the next
* chunk are globally visible. Copy the maximum
* transaction IDs into the cursor as we go.
*/
for (ngood = nchunks - 1, nupdates = 1;
ngood > 0;
ngood--, nupdates++) {
chunk = lsm_tree->chunk[ngood - 1];
clsm->txnid_max[ngood - 1] =
chunk->txnid_max;
if (__wt_txn_visible_all(
session, chunk->txnid_max))
break;
}
} else {
nupdates = 1;
ngood = nchunks - 1;
}
/* Check how many cursors are already open. */
for (cp = clsm->cursors + ngood;
ngood < clsm->nchunks && ngood < nchunks;
cp++, ngood++) {
chunk = lsm_tree->chunk[ngood];
/* If the cursor isn't open yet, we're done. */
if (*cp == NULL)
break;
/* Easy case: the URIs don't match. */
if (strcmp((*cp)->uri, chunk->uri) != 0)
break;
/* Make sure the checkpoint config matches. */
checkpoint = ((WT_CURSOR_BTREE *)*cp)->
btree->dhandle->checkpoint;
if (checkpoint == NULL &&
F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
!chunk->empty)
break;
/* Make sure the Bloom config matches. */
if (clsm->blooms[ngood] == NULL &&
F_ISSET(chunk, WT_LSM_CHUNK_BLOOM))
break;
}
/* Spurious generation bump? */
if (ngood == clsm->nchunks && clsm->nchunks == nchunks) {
clsm->dsk_gen = lsm_tree->dsk_gen;
goto err;
}
/*
* Close any cursors we no longer need.
*
* Drop the LSM tree lock while we do this: if the cache is
* full, we may block while closing a cursor. Save the
* generation number and retry if it has changed under us.
*/
if (clsm->cursors != NULL && (ngood < clsm->nchunks ||
(!F_ISSET(clsm, WT_CLSM_OPEN_READ) && nupdates > 0))) {
saved_gen = lsm_tree->dsk_gen;
locked = 0;
WT_ERR(__wt_lsm_tree_unlock(session, lsm_tree));
if (!F_ISSET(clsm, WT_CLSM_OPEN_READ) && nupdates > 0)
WT_ERR(__clsm_close_cursors(
clsm, 0, nchunks - nupdates));
WT_ERR(__clsm_close_cursors(
clsm, ngood, clsm->nchunks));
WT_ERR(__wt_lsm_tree_lock(session, lsm_tree, 0));
locked = 1;
if (lsm_tree->dsk_gen != saved_gen)
goto retry;
}
/* Detach from our old primary. */
clsm->primary_chunk = NULL;
clsm->current = NULL;
}
WT_ERR(__wt_realloc_def(session,
&clsm->bloom_alloc, nchunks, &clsm->blooms));
WT_ERR(__wt_realloc_def(session,
&clsm->cursor_alloc, nchunks, &clsm->cursors));
clsm->nchunks = nchunks;
/* Open the cursors for chunks that have changed. */
for (i = ngood, cp = clsm->cursors + i; i != nchunks; i++, cp++) {
chunk = lsm_tree->chunk[i + start_chunk];
/* Copy the maximum transaction ID. */
if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT))
clsm->txnid_max[i] = chunk->txnid_max;
/*
* Read from the checkpoint if the file has been written.
* Once all cursors switch, the in-memory tree can be evicted.
*/
WT_ASSERT(session, *cp == NULL);
ret = __wt_open_cursor(session, chunk->uri, c,
(F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) && !chunk->empty) ?
ckpt_cfg : NULL, cp);
/*
* XXX kludge: we may have an empty chunk where no checkpoint
* was written. If so, try to open the ordinary handle on that
* chunk instead.
*/
if (ret == WT_NOTFOUND &&
F_ISSET(chunk, WT_LSM_CHUNK_ONDISK)) {
ret = __wt_open_cursor(
session, chunk->uri, c, NULL, cp);
if (ret == 0)
chunk->empty = 1;
}
WT_ERR(ret);
if (F_ISSET(chunk, WT_LSM_CHUNK_BLOOM) &&
!F_ISSET(clsm, WT_CLSM_MERGE))
WT_ERR(__wt_bloom_open(session, chunk->bloom_uri,
lsm_tree->bloom_bit_count,
lsm_tree->bloom_hash_count,
c, &clsm->blooms[i]));
/* Child cursors always use overwrite and raw mode. */
F_SET(*cp, WT_CURSTD_OVERWRITE | WT_CURSTD_RAW);
}
/* The last chunk is our new primary. */
if (chunk != NULL && !F_ISSET(chunk, WT_LSM_CHUNK_ONDISK)) {
clsm->primary_chunk = chunk;
primary = clsm->cursors[clsm->nchunks - 1];
WT_WITH_BTREE(session, ((WT_CURSOR_BTREE *)(primary))->btree,
__wt_btree_evictable(session, 0));
}
clsm->dsk_gen = lsm_tree->dsk_gen;
err: F_CLR(session, WT_SESSION_NO_CACHE_CHECK);
#ifdef HAVE_DIAGNOSTIC
/* Check that all cursors are open as expected. */
if (ret == 0 && F_ISSET(clsm, WT_CLSM_OPEN_READ)) {
for (i = 0, cp = clsm->cursors; i != clsm->nchunks; cp++, i++) {
chunk = lsm_tree->chunk[i + start_chunk];
/* Make sure the cursor is open. */
WT_ASSERT(session, *cp != NULL);
/* Easy case: the URIs should match. */
WT_ASSERT(session, strcmp((*cp)->uri, chunk->uri) == 0);
/* Make sure the checkpoint config matches. */
checkpoint = ((WT_CURSOR_BTREE *)*cp)->
btree->dhandle->checkpoint;
WT_ASSERT(session,
(F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
!chunk->empty) ?
checkpoint != NULL : checkpoint == NULL);
/* Make sure the Bloom config matches. */
WT_ASSERT(session,
(F_ISSET(chunk, WT_LSM_CHUNK_BLOOM) &&
!F_ISSET(clsm, WT_CLSM_MERGE)) ?
clsm->blooms[i] != NULL : clsm->blooms[i] == NULL);
}
}
#endif
if (locked)
WT_TRET(__wt_lsm_tree_unlock(session, lsm_tree));
return (ret);
}
/*
* __wt_lsm_checkpoint_worker --
* A worker thread for an LSM tree, responsible for flushing new chunks to
* disk.
*/
void *
__wt_lsm_checkpoint_worker(void *arg)
{
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_TREE *lsm_tree;
WT_LSM_WORKER_COOKIE cookie;
WT_SESSION_IMPL *session;
WT_TXN_ISOLATION saved_isolation;
u_int i, j;
int locked;
lsm_tree = arg;
session = lsm_tree->ckpt_session;
WT_CLEAR(cookie);
while (F_ISSET(lsm_tree, WT_LSM_TREE_WORKING)) {
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);
}
WT_ERR(__lsm_copy_chunks(session, lsm_tree, &cookie, 0));
/* Write checkpoints in all completed files. */
for (i = 0, j = 0; i < cookie.nchunks - 1; i++) {
if (!F_ISSET(lsm_tree, WT_LSM_TREE_WORKING))
goto err;
if (F_ISSET(lsm_tree, WT_LSM_TREE_NEED_SWITCH))
break;
chunk = cookie.chunk_array[i];
/* Stop if a running transaction needs the chunk. */
__wt_txn_update_oldest(session);
if (!__wt_txn_visible_all(session, chunk->txnid_max))
break;
/*
* If the chunk is already checkpointed, make sure it
* is also evicted. Either way, there is no point
* trying to checkpoint it again.
*/
if (F_ISSET_ATOMIC(chunk, WT_LSM_CHUNK_ONDISK)) {
if (F_ISSET_ATOMIC(chunk, WT_LSM_CHUNK_EVICTED))
continue;
if ((ret = __lsm_discard_handle(
session, chunk->uri, NULL)) == 0)
F_SET_ATOMIC(
chunk, WT_LSM_CHUNK_EVICTED);
else if (ret == EBUSY)
ret = 0;
else
WT_ERR_MSG(session, ret,
"discard handle");
continue;
}
WT_VERBOSE_ERR(session, lsm,
"LSM worker flushing %u", i);
/*
* Flush the file before checkpointing: this is the
* expensive part in terms of I/O: do it without
* holding the schema lock.
*
* Use the special eviction isolation level to avoid
* interfering with an application checkpoint: we have
* already checked that all of the updates in this
* chunk are globally visible.
*
* !!! We can wait here for checkpoints and fsyncs to
* complete, which can be a long time.
*
* Don't keep waiting for the lock if application
* threads are waiting for a switch. Don't skip
* flushing the leaves either: that just means we'll
* hold the schema lock for (much) longer, which blocks
* the world.
*/
WT_ERR(__wt_session_get_btree(
session, chunk->uri, NULL, NULL, 0));
for (locked = 0;
!locked && ret == 0 &&
!F_ISSET(lsm_tree, WT_LSM_TREE_NEED_SWITCH);) {
if ((ret = __wt_spin_trylock(session,
&S2C(session)->checkpoint_lock)) == 0)
locked = 1;
else if (ret == EBUSY) {
__wt_yield();
ret = 0;
}
}
if (locked) {
saved_isolation = session->txn.isolation;
session->txn.isolation = TXN_ISO_EVICTION;
ret = __wt_bt_cache_op(
session, NULL, WT_SYNC_WRITE_LEAVES);
session->txn.isolation = saved_isolation;
__wt_spin_unlock(
session, &S2C(session)->checkpoint_lock);
}
WT_TRET(__wt_session_release_btree(session));
WT_ERR(ret);
if (F_ISSET(lsm_tree, WT_LSM_TREE_NEED_SWITCH))
break;
WT_VERBOSE_ERR(session, lsm,
"LSM worker checkpointing %u", i);
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_schema_worker(session, chunk->uri,
__wt_checkpoint, NULL, NULL, 0));
if (ret != 0) {
__wt_err(session, ret, "LSM checkpoint");
break;
}
WT_ERR(__wt_lsm_tree_set_chunk_size(session, chunk));
/*
* Clear the "cache resident" flag so the primary can
* be evicted and eventually closed. Only do this once
* the checkpoint has succeeded: otherwise, accessing
* the leaf page during the checkpoint can trigger
* forced eviction.
*/
WT_ERR(__wt_session_get_btree(
session, chunk->uri, NULL, NULL, 0));
__wt_btree_evictable(session, 1);
WT_ERR(__wt_session_release_btree(session));
++j;
WT_ERR(__wt_lsm_tree_lock(session, lsm_tree, 1));
F_SET_ATOMIC(chunk, WT_LSM_CHUNK_ONDISK);
ret = __wt_lsm_meta_write(session, lsm_tree);
++lsm_tree->dsk_gen;
/* Update the throttle time. */
__wt_lsm_tree_throttle(session, lsm_tree);
WT_TRET(__wt_lsm_tree_unlock(session, lsm_tree));
/* Make sure we aren't pinning a transaction ID. */
__wt_txn_release_snapshot(session);
if (ret != 0) {
__wt_err(session, ret,
"LSM checkpoint metadata write");
break;
}
WT_VERBOSE_ERR(session, lsm,
"LSM worker checkpointed %u", i);
}
__lsm_unpin_chunks(session, &cookie);
if (j == 0 && F_ISSET(lsm_tree, WT_LSM_TREE_WORKING) &&
!F_ISSET(lsm_tree, WT_LSM_TREE_NEED_SWITCH))
WT_ERR_TIMEDOUT_OK(__wt_cond_wait(
session, lsm_tree->work_cond, 100000));
}
err: __lsm_unpin_chunks(session, &cookie);
__wt_free(session, cookie.chunk_array);
/*
* The thread will only exit with failure if we run out of memory or
* there is some other system driven failure. We can't keep going
* after such a failure - ensure WiredTiger shuts down.
*/
if (ret != 0 && ret != WT_NOTFOUND)
WT_PANIC_ERR(session, ret,
"Shutting down LSM checkpoint utility thread");
return (NULL);
}
/*
* __clsm_open_cursors --
* Open cursors for the current set of files.
*/
static int
__clsm_open_cursors(
WT_CURSOR_LSM *clsm, bool update, u_int start_chunk, uint32_t start_id)
{
WT_BTREE *btree;
WT_CURSOR *c, **cp, *primary;
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_TREE *lsm_tree;
WT_SESSION_IMPL *session;
WT_TXN *txn;
const char *checkpoint, *ckpt_cfg[3];
uint64_t saved_gen;
u_int i, nchunks, ngood, nupdates;
u_int close_range_end, close_range_start;
bool locked;
c = &clsm->iface;
session = (WT_SESSION_IMPL *)c->session;
txn = &session->txn;
chunk = NULL;
locked = false;
lsm_tree = clsm->lsm_tree;
/*
* Ensure that any snapshot update has cursors on the right set of
* chunks to guarantee visibility is correct.
*/
if (update && txn->isolation == WT_ISO_SNAPSHOT)
F_SET(clsm, WT_CLSM_OPEN_SNAPSHOT);
/*
* Query operations need a full set of cursors. Overwrite cursors
* do queries in service of updates.
*/
if (!update || !F_ISSET(c, WT_CURSTD_OVERWRITE))
F_SET(clsm, WT_CLSM_OPEN_READ);
if (lsm_tree->nchunks == 0)
return (0);
ckpt_cfg[0] = WT_CONFIG_BASE(session, WT_SESSION_open_cursor);
ckpt_cfg[1] = "checkpoint=" WT_CHECKPOINT ",raw";
ckpt_cfg[2] = NULL;
/*
* If the key is pointing to memory that is pinned by a chunk
* cursor, take a copy before closing cursors.
*/
if (F_ISSET(c, WT_CURSTD_KEY_INT))
WT_CURSOR_NEEDKEY(c);
F_CLR(clsm, WT_CLSM_ITERATE_NEXT | WT_CLSM_ITERATE_PREV);
WT_RET(__wt_lsm_tree_readlock(session, lsm_tree));
locked = true;
/* Merge cursors have already figured out how many chunks they need. */
retry: if (F_ISSET(clsm, WT_CLSM_MERGE)) {
nchunks = clsm->nchunks;
ngood = 0;
/*
* We may have raced with another merge completing. Check that
* we're starting at the right offset in the chunk array.
*/
if (start_chunk >= lsm_tree->nchunks ||
lsm_tree->chunk[start_chunk]->id != start_id) {
for (start_chunk = 0;
start_chunk < lsm_tree->nchunks;
start_chunk++) {
chunk = lsm_tree->chunk[start_chunk];
if (chunk->id == start_id)
break;
}
/* We have to find the start chunk: merge locked it. */
WT_ASSERT(session, start_chunk < lsm_tree->nchunks);
}
WT_ASSERT(session, start_chunk + nchunks <= lsm_tree->nchunks);
} else {
nchunks = lsm_tree->nchunks;
/*
* If we are only opening the cursor for updates, only open the
* primary chunk, plus any other chunks that might be required
* to detect snapshot isolation conflicts.
*/
if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT))
WT_ERR(__wt_realloc_def(session,
&clsm->txnid_alloc, nchunks,
&clsm->switch_txn));
if (F_ISSET(clsm, WT_CLSM_OPEN_READ))
ngood = nupdates = 0;
else if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT)) {
/*
* Keep going until all updates in the next
* chunk are globally visible. Copy the maximum
* transaction IDs into the cursor as we go.
*/
for (ngood = nchunks - 1, nupdates = 1;
ngood > 0;
ngood--, nupdates++) {
chunk = lsm_tree->chunk[ngood - 1];
clsm->switch_txn[ngood - 1] = chunk->switch_txn;
if (__wt_txn_visible_all(
session, chunk->switch_txn))
break;
}
} else {
nupdates = 1;
ngood = nchunks - 1;
}
/* Check how many cursors are already open. */
for (cp = clsm->cursors + ngood;
ngood < clsm->nchunks && ngood < nchunks;
cp++, ngood++) {
chunk = lsm_tree->chunk[ngood];
/* If the cursor isn't open yet, we're done. */
if (*cp == NULL)
break;
/* Easy case: the URIs don't match. */
if (strcmp((*cp)->uri, chunk->uri) != 0)
break;
/* Make sure the checkpoint config matches. */
checkpoint = ((WT_CURSOR_BTREE *)*cp)->
btree->dhandle->checkpoint;
if (checkpoint == NULL &&
F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
!chunk->empty)
break;
/* Make sure the Bloom config matches. */
if (clsm->blooms[ngood] == NULL &&
F_ISSET(chunk, WT_LSM_CHUNK_BLOOM))
break;
}
/* Spurious generation bump? */
if (ngood == clsm->nchunks && clsm->nchunks == nchunks) {
clsm->dsk_gen = lsm_tree->dsk_gen;
goto err;
}
/*
* Close any cursors we no longer need.
*
* Drop the LSM tree lock while we do this: if the cache is
* full, we may block while closing a cursor. Save the
* generation number and retry if it has changed under us.
*/
if (clsm->cursors != NULL && ngood < clsm->nchunks) {
close_range_start = ngood;
close_range_end = clsm->nchunks;
} else if (!F_ISSET(clsm, WT_CLSM_OPEN_READ) && nupdates > 0 ) {
close_range_start = 0;
close_range_end = WT_MIN(nchunks, clsm->nchunks);
if (close_range_end > nupdates)
close_range_end -= nupdates;
else
close_range_end = 0;
WT_ASSERT(session, ngood >= close_range_end);
} else {
close_range_end = 0;
close_range_start = 0;
}
if (close_range_end > close_range_start) {
saved_gen = lsm_tree->dsk_gen;
locked = false;
WT_ERR(__wt_lsm_tree_readunlock(session, lsm_tree));
WT_ERR(__clsm_close_cursors(
clsm, close_range_start, close_range_end));
WT_ERR(__wt_lsm_tree_readlock(session, lsm_tree));
locked = true;
if (lsm_tree->dsk_gen != saved_gen)
goto retry;
}
/* Detach from our old primary. */
clsm->primary_chunk = NULL;
clsm->current = NULL;
}
WT_ERR(__wt_realloc_def(session,
&clsm->bloom_alloc, nchunks, &clsm->blooms));
WT_ERR(__wt_realloc_def(session,
&clsm->cursor_alloc, nchunks, &clsm->cursors));
clsm->nchunks = nchunks;
/* Open the cursors for chunks that have changed. */
for (i = ngood, cp = clsm->cursors + i; i != nchunks; i++, cp++) {
chunk = lsm_tree->chunk[i + start_chunk];
/* Copy the maximum transaction ID. */
if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT))
clsm->switch_txn[i] = chunk->switch_txn;
/*
* Read from the checkpoint if the file has been written.
* Once all cursors switch, the in-memory tree can be evicted.
*/
WT_ASSERT(session, *cp == NULL);
ret = __wt_open_cursor(session, chunk->uri, c,
(F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) && !chunk->empty) ?
ckpt_cfg : NULL, cp);
/*
* XXX kludge: we may have an empty chunk where no checkpoint
* was written. If so, try to open the ordinary handle on that
* chunk instead.
*/
if (ret == WT_NOTFOUND && F_ISSET(chunk, WT_LSM_CHUNK_ONDISK)) {
ret = __wt_open_cursor(
session, chunk->uri, c, NULL, cp);
if (ret == 0)
chunk->empty = 1;
}
WT_ERR(ret);
/*
* Setup all cursors other than the primary to only do conflict
* checks on insert operations. This allows us to execute
* inserts on non-primary chunks as a way of checking for
* write conflicts with concurrent updates.
*/
if (i != nchunks - 1)
(*cp)->insert = __wt_curfile_update_check;
if (!F_ISSET(clsm, WT_CLSM_MERGE) &&
F_ISSET(chunk, WT_LSM_CHUNK_BLOOM))
WT_ERR(__wt_bloom_open(session, chunk->bloom_uri,
lsm_tree->bloom_bit_count,
lsm_tree->bloom_hash_count,
c, &clsm->blooms[i]));
/* Child cursors always use overwrite and raw mode. */
F_SET(*cp, WT_CURSTD_OVERWRITE | WT_CURSTD_RAW);
}
/* The last chunk is our new primary. */
if (chunk != NULL &&
!F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
chunk->switch_txn == WT_TXN_NONE) {
clsm->primary_chunk = chunk;
primary = clsm->cursors[clsm->nchunks - 1];
/*
* Disable eviction for the in-memory chunk. Also clear the
* bulk load flag here, otherwise eviction will be enabled by
* the first update.
*/
btree = ((WT_CURSOR_BTREE *)(primary))->btree;
if (btree->bulk_load_ok) {
btree->bulk_load_ok = false;
WT_WITH_BTREE(session, btree,
__wt_btree_evictable(session, false));
}
}
clsm->dsk_gen = lsm_tree->dsk_gen;
err:
#ifdef HAVE_DIAGNOSTIC
/* Check that all cursors are open as expected. */
if (ret == 0 && F_ISSET(clsm, WT_CLSM_OPEN_READ)) {
for (i = 0, cp = clsm->cursors; i != clsm->nchunks; cp++, i++) {
chunk = lsm_tree->chunk[i + start_chunk];
/* Make sure the cursor is open. */
WT_ASSERT(session, *cp != NULL);
/* Easy case: the URIs should match. */
WT_ASSERT(session, strcmp((*cp)->uri, chunk->uri) == 0);
/* Make sure the checkpoint config matches. */
checkpoint = ((WT_CURSOR_BTREE *)*cp)->
btree->dhandle->checkpoint;
WT_ASSERT(session,
(F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
!chunk->empty) ?
checkpoint != NULL : checkpoint == NULL);
/* Make sure the Bloom config matches. */
WT_ASSERT(session,
(F_ISSET(chunk, WT_LSM_CHUNK_BLOOM) &&
!F_ISSET(clsm, WT_CLSM_MERGE)) ?
clsm->blooms[i] != NULL : clsm->blooms[i] == NULL);
}
}
#endif
if (locked)
WT_TRET(__wt_lsm_tree_readunlock(session, lsm_tree));
return (ret);
}
/*
* __wt_lsm_checkpoint_chunk --
* Flush a single LSM chunk to disk.
*/
int
__wt_lsm_checkpoint_chunk(WT_SESSION_IMPL *session,
WT_LSM_TREE *lsm_tree, WT_LSM_CHUNK *chunk)
{
WT_DECL_RET;
WT_TXN_ISOLATION saved_isolation;
/*
* If the chunk is already checkpointed, make sure it is also evicted.
* Either way, there is no point trying to checkpoint it again.
*/
if (F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
!F_ISSET(chunk, WT_LSM_CHUNK_STABLE) &&
!chunk->evicted) {
if ((ret = __lsm_discard_handle(
session, chunk->uri, NULL)) == 0)
chunk->evicted = 1;
else if (ret == EBUSY)
ret = 0;
else
WT_RET_MSG(session, ret, "discard handle");
}
if (F_ISSET(chunk, WT_LSM_CHUNK_ONDISK)) {
WT_RET(__wt_verbose(session, WT_VERB_LSM,
"LSM worker %s already on disk",
chunk->uri));
return (0);
}
/* Stop if a running transaction needs the chunk. */
__wt_txn_update_oldest(session);
if (chunk->switch_txn == WT_TXN_NONE ||
!__wt_txn_visible_all(session, chunk->switch_txn)) {
WT_RET(__wt_verbose(session, WT_VERB_LSM,
"LSM worker %s: running transaction, return",
chunk->uri));
return (0);
}
WT_RET(__wt_verbose(session, WT_VERB_LSM, "LSM worker flushing %s",
chunk->uri));
/*
* Flush the file before checkpointing: this is the expensive part in
* terms of I/O.
*
* Use the special eviction isolation level to avoid interfering with
* an application checkpoint: we have already checked that all of the
* updates in this chunk are globally visible.
*
* !!! We can wait here for checkpoints and fsyncs to complete, which
* can be a long time.
*/
if ((ret = __wt_session_get_btree(
session, chunk->uri, NULL, NULL, 0)) == 0) {
saved_isolation = session->txn.isolation;
session->txn.isolation = TXN_ISO_EVICTION;
ret = __wt_cache_op(session, NULL, WT_SYNC_WRITE_LEAVES);
session->txn.isolation = saved_isolation;
WT_TRET(__wt_session_release_btree(session));
}
WT_RET(ret);
WT_RET(__wt_verbose(session, WT_VERB_LSM, "LSM worker checkpointing %s",
chunk->uri));
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_schema_worker(session, chunk->uri,
__wt_checkpoint, NULL, NULL, 0));
if (ret != 0)
WT_RET_MSG(session, ret, "LSM checkpoint");
/* Now the file is written, get the chunk size. */
WT_RET(__wt_lsm_tree_set_chunk_size(session, chunk));
/* Update the flush timestamp to help track ongoing progress. */
WT_RET(__wt_epoch(session, &lsm_tree->last_flush_ts));
/* Lock the tree, mark the chunk as on disk and update the metadata. */
WT_RET(__wt_lsm_tree_writelock(session, lsm_tree));
F_SET(chunk, WT_LSM_CHUNK_ONDISK);
ret = __wt_lsm_meta_write(session, lsm_tree);
++lsm_tree->dsk_gen;
/* Update the throttle time. */
__wt_lsm_tree_throttle(session, lsm_tree, 1);
WT_TRET(__wt_lsm_tree_writeunlock(session, lsm_tree));
if (ret != 0)
WT_RET_MSG(session, ret, "LSM metadata write");
/*
* Clear the no-eviction flag so the primary can be evicted and
* eventually closed. Only do this once the checkpoint has succeeded:
* otherwise, accessing the leaf page during the checkpoint can trigger
* forced eviction.
*/
WT_RET(__wt_session_get_btree(session, chunk->uri, NULL, NULL, 0));
__wt_btree_evictable(session, 1);
WT_RET(__wt_session_release_btree(session));
/* Make sure we aren't pinning a transaction ID. */
__wt_txn_release_snapshot(session);
WT_RET(__wt_verbose(session, WT_VERB_LSM, "LSM worker checkpointed %s",
chunk->uri));
/* Schedule a bloom filter create for our newly flushed chunk. */
if (!FLD_ISSET(lsm_tree->bloom, WT_LSM_BLOOM_OFF))
WT_RET(__wt_lsm_manager_push_entry(
session, WT_LSM_WORK_BLOOM, 0, lsm_tree));
else
WT_RET(__wt_lsm_manager_push_entry(
session, WT_LSM_WORK_MERGE, 0, lsm_tree));
return (0);
}
