/*
* __wt_lsm_tree_release --
* Release an LSM tree structure.
*/
void
__wt_lsm_tree_release(WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree)
{
WT_ASSERT(session, lsm_tree->refcnt > 0);
(void)WT_ATOMIC_SUB4(lsm_tree->refcnt, 1);
F_CLR_ATOMIC(lsm_tree, WT_LSM_TREE_EXCLUSIVE);
}
/*
* __lsm_unpin_chunks --
* Decrement the reference count for a set of chunks. Allowing those
* chunks to be considered for deletion.
*/
static void
__lsm_unpin_chunks(WT_SESSION_IMPL *session, WT_LSM_WORKER_COOKIE *cookie)
{
u_int i;
for (i = 0; i < cookie->nchunks; i++) {
if (cookie->chunk_array[i] == NULL)
continue;
WT_ASSERT(session, cookie->chunk_array[i]->refcnt > 0);
(void)WT_ATOMIC_SUB4(cookie->chunk_array[i]->refcnt, 1);
}
/* Ensure subsequent calls don't double decrement. */
cookie->nchunks = 0;
}
/*
* __lsm_worker_general_op --
* Execute a single bloom, drop or flush work unit.
*/
static int
__lsm_worker_general_op(
WT_SESSION_IMPL *session, WT_LSM_WORKER_ARGS *cookie, int *completed)
{
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_WORK_UNIT *entry;
int force;
*completed = 0;
/*
* Return if this thread cannot process a bloom, drop or flush.
*/
if (!FLD_ISSET(cookie->type,
WT_LSM_WORK_BLOOM | WT_LSM_WORK_DROP | WT_LSM_WORK_FLUSH))
return (WT_NOTFOUND);
if ((ret = __wt_lsm_manager_pop_entry(session,
cookie->type, &entry)) != 0 || entry == NULL)
return (ret);
if (entry->type == WT_LSM_WORK_FLUSH) {
force = F_ISSET(entry, WT_LSM_WORK_FORCE);
F_CLR(entry, WT_LSM_WORK_FORCE);
WT_ERR(__wt_lsm_get_chunk_to_flush(session,
entry->lsm_tree, force, &chunk));
/*
* If we got a chunk to flush, checkpoint it.
*/
if (chunk != NULL) {
WT_ERR(__wt_verbose(session, WT_VERB_LSM,
"Flush%s chunk %d %s",
force ? " w/ force" : "",
chunk->id, chunk->uri));
ret = __wt_lsm_checkpoint_chunk(
session, entry->lsm_tree, chunk);
WT_ASSERT(session, chunk->refcnt > 0);
(void)WT_ATOMIC_SUB4(chunk->refcnt, 1);
WT_ERR(ret);
}
} else if (entry->type == WT_LSM_WORK_DROP)
WT_ERR(__wt_lsm_free_chunks(session, entry->lsm_tree));
else if (entry->type == WT_LSM_WORK_BLOOM)
WT_ERR(__wt_lsm_work_bloom(session, entry->lsm_tree));
*completed = 1;
err: __wt_lsm_manager_free_work_unit(session, entry);
return (ret);
}
/*
* __wt_close --
* Close a file handle.
*/
int
__wt_close(WT_SESSION_IMPL *session, WT_FH **fhp)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_FH *fh;
uint64_t bucket;
conn = S2C(session);
if (*fhp == NULL)
return (0);
fh = *fhp;
*fhp = NULL;
__wt_spin_lock(session, &conn->fh_lock);
if (fh == NULL || fh->ref == 0 || --fh->ref > 0) {
__wt_spin_unlock(session, &conn->fh_lock);
return (0);
}
/* Remove from the list. */
bucket = fh->name_hash % WT_HASH_ARRAY_SIZE;
WT_CONN_FILE_REMOVE(conn, fh, bucket);
(void)WT_ATOMIC_SUB4(conn->open_file_count, 1);
__wt_spin_unlock(session, &conn->fh_lock);
/* Discard the memory.
* Note: For directories, we do not open valid directory handles on
* windows since it is not possible to sync a directory
*/
if (fh->filehandle != INVALID_HANDLE_VALUE &&
CloseHandle(fh->filehandle) == 0) {
ret = __wt_errno();
__wt_err(session, ret, "CloseHandle: %s", fh->name);
}
if (fh->filehandle_secondary != INVALID_HANDLE_VALUE &&
CloseHandle(fh->filehandle_secondary) == 0) {
ret = __wt_errno();
__wt_err(session, ret, "CloseHandle: secondary: %s", fh->name);
}
__wt_free(session, fh->name);
__wt_free(session, fh);
return (ret);
}
/*
* __wt_lsm_tree_get --
* Get an LSM tree structure for the given name. Optionally get exclusive
* access to the handle. Exclusive access works separately to the LSM
* tree lock - since operations that need exclusive access may also need
* to take the LSM tree lock for example outstanding work unit operations.
*/
int
__wt_lsm_tree_get(WT_SESSION_IMPL *session,
const char *uri, int exclusive, WT_LSM_TREE **treep)
{
WT_LSM_TREE *lsm_tree;
/* See if the tree is already open. */
TAILQ_FOREACH(lsm_tree, &S2C(session)->lsmqh, q)
if (strcmp(uri, lsm_tree->name) == 0) {
/*
* Short circuit if the handle is already held
* exclusively or exclusive access is requested and
* there are references held.
*/
if ((exclusive && lsm_tree->refcnt > 0) ||
F_ISSET_ATOMIC(lsm_tree, WT_LSM_TREE_EXCLUSIVE))
return (EBUSY);
if (exclusive) {
F_SET_ATOMIC(lsm_tree, WT_LSM_TREE_EXCLUSIVE);
if (!WT_ATOMIC_CAS4(lsm_tree->refcnt, 0, 1)) {
F_CLR(lsm_tree, WT_LSM_TREE_EXCLUSIVE);
return (EBUSY);
}
} else
(void)WT_ATOMIC_ADD4(lsm_tree->refcnt, 1);
/*
* If we got a reference, but an exclusive reference
* beat us to it, give our reference up.
*/
if (!exclusive &&
F_ISSET_ATOMIC(lsm_tree, WT_LSM_TREE_EXCLUSIVE)) {
(void)WT_ATOMIC_SUB4(lsm_tree->refcnt, 1);
return (EBUSY);
}
*treep = lsm_tree;
return (0);
}
/* Open a new tree. */
return (__lsm_tree_open(session, uri, treep));
}
/*
* __wt_txn_update_oldest --
* Sweep the running transactions to update the oldest ID required.
* !!!
* If a data-source is calling the WT_EXTENSION_API.transaction_oldest
* method (for the oldest transaction ID not yet visible to a running
* transaction), and then comparing that oldest ID against committed
* transactions to see if updates for a committed transaction are still
* visible to running transactions, the oldest transaction ID may be
* the same as the last committed transaction ID, if the transaction
* state wasn't refreshed after the last transaction committed. Push
* past the last committed transaction.
*/
void
__wt_txn_update_oldest(WT_SESSION_IMPL *session, int force)
{
WT_CONNECTION_IMPL *conn;
WT_SESSION_IMPL *oldest_session;
WT_TXN_GLOBAL *txn_global;
WT_TXN_STATE *s;
uint64_t current_id, id, last_running, oldest_id, prev_oldest_id;
uint32_t i, session_cnt;
int32_t count;
int last_running_moved;
conn = S2C(session);
txn_global = &conn->txn_global;
current_id = last_running = txn_global->current;
oldest_session = NULL;
prev_oldest_id = txn_global->oldest_id;
/*
* For pure read-only workloads, or if the update isn't forced and the
* oldest ID isn't too far behind, avoid scanning.
*/
if (prev_oldest_id == current_id ||
(!force && WT_TXNID_LT(current_id, prev_oldest_id + 100)))
return;
/*
* We're going to scan. Increment the count of scanners to prevent the
* oldest ID from moving forwards. Spin if the count is negative,
* which indicates that some thread is moving the oldest ID forwards.
*/
do {
if ((count = txn_global->scan_count) < 0)
WT_PAUSE();
} while (count < 0 ||
!WT_ATOMIC_CAS4(txn_global->scan_count, count, count + 1));
/* The oldest ID cannot change until the scan count goes to zero. */
prev_oldest_id = txn_global->oldest_id;
current_id = oldest_id = last_running = txn_global->current;
/* Walk the array of concurrent transactions. */
WT_ORDERED_READ(session_cnt, conn->session_cnt);
for (i = 0, s = txn_global->states; i < session_cnt; i++, s++) {
/*
* Update the oldest ID.
*
* Ignore: IDs older than the oldest ID we saw. This can happen
* if we race with a thread that is allocating an ID -- the ID
* will not be used because the thread will keep spinning until
* it gets a valid one.
*/
if ((id = s->id) != WT_TXN_NONE &&
WT_TXNID_LE(prev_oldest_id, id) &&
WT_TXNID_LT(id, last_running))
last_running = id;
/*
* !!!
* Note: Don't ignore snap_min values older than the previous
* oldest ID. Read-uncommitted operations publish snap_min
* values without incrementing scan_count to protect the global
* table. See the comment in __wt_txn_cursor_op for
* more details.
*/
if ((id = s->snap_min) != WT_TXN_NONE &&
WT_TXNID_LT(id, oldest_id)) {
oldest_id = id;
oldest_session = &conn->sessions[i];
}
}
if (WT_TXNID_LT(last_running, oldest_id))
oldest_id = last_running;
/* The oldest ID can't move past any named snapshots. */
if ((id = txn_global->nsnap_oldest_id) != WT_TXN_NONE &&
WT_TXNID_LT(id, oldest_id))
oldest_id = id;
/* Update the last running ID. */
last_running_moved =
WT_TXNID_LT(txn_global->last_running, last_running);
/* Update the oldest ID. */
if ((WT_TXNID_LT(prev_oldest_id, oldest_id) || last_running_moved) &&
WT_ATOMIC_CAS4(txn_global->scan_count, 1, -1)) {
WT_ORDERED_READ(session_cnt, conn->session_cnt);
for (i = 0, s = txn_global->states; i < session_cnt; i++, s++) {
if ((id = s->id) != WT_TXN_NONE &&
WT_TXNID_LT(id, last_running))
last_running = id;
if ((id = s->snap_min) != WT_TXN_NONE &&
WT_TXNID_LT(id, oldest_id))
oldest_id = id;
}
if (WT_TXNID_LT(last_running, oldest_id))
oldest_id = last_running;
#ifdef HAVE_DIAGNOSTIC
/*
* Make sure the ID doesn't move past any named snapshots.
*
* Don't include the read/assignment in the assert statement.
* Coverity complains if there are assignments only done in
* diagnostic builds, and when the read is from a volatile.
*/
id = txn_global->nsnap_oldest_id;
WT_ASSERT(session,
id == WT_TXN_NONE || !WT_TXNID_LT(id, oldest_id));
#endif
if (WT_TXNID_LT(txn_global->last_running, last_running))
txn_global->last_running = last_running;
if (WT_TXNID_LT(txn_global->oldest_id, oldest_id))
txn_global->oldest_id = oldest_id;
WT_ASSERT(session, txn_global->scan_count == -1);
txn_global->scan_count = 0;
} else {
if (WT_VERBOSE_ISSET(session, WT_VERB_TRANSACTION) &&
current_id - oldest_id > 10000 && last_running_moved &&
oldest_session != NULL) {
(void)__wt_verbose(session, WT_VERB_TRANSACTION,
"old snapshot %" PRIu64
" pinned in session %d [%s]"
" with snap_min %" PRIu64 "\n",
oldest_id, oldest_session->id,
oldest_session->lastop,
oldest_session->txn.snap_min);
}
WT_ASSERT(session, txn_global->scan_count > 0);
(void)WT_ATOMIC_SUB4(txn_global->scan_count, 1);
}
}
/*
* __wt_txn_get_snapshot --
* Allocate a snapshot.
*/
void
__wt_txn_get_snapshot(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_TXN *txn;
WT_TXN_GLOBAL *txn_global;
WT_TXN_STATE *s, *txn_state;
uint64_t current_id, id;
uint64_t prev_oldest_id, snap_min;
uint32_t i, n, session_cnt;
int32_t count;
conn = S2C(session);
txn = &session->txn;
txn_global = &conn->txn_global;
txn_state = WT_SESSION_TXN_STATE(session);
/*
* We're going to scan. Increment the count of scanners to prevent the
* oldest ID from moving forwards. Spin if the count is negative,
* which indicates that some thread is moving the oldest ID forwards.
*/
do {
if ((count = txn_global->scan_count) < 0)
WT_PAUSE();
} while (count < 0 ||
!WT_ATOMIC_CAS4(txn_global->scan_count, count, count + 1));
current_id = snap_min = txn_global->current;
prev_oldest_id = txn_global->oldest_id;
/* For pure read-only workloads, avoid scanning. */
if (prev_oldest_id == current_id) {
txn_state->snap_min = current_id;
__txn_sort_snapshot(session, 0, current_id);
/* Check that the oldest ID has not moved in the meantime. */
if (prev_oldest_id == txn_global->oldest_id) {
WT_ASSERT(session, txn_global->scan_count > 0);
(void)WT_ATOMIC_SUB4(txn_global->scan_count, 1);
return;
}
}
/* Walk the array of concurrent transactions. */
WT_ORDERED_READ(session_cnt, conn->session_cnt);
for (i = n = 0, s = txn_global->states; i < session_cnt; i++, s++) {
/*
* Build our snapshot of any concurrent transaction IDs.
*
* Ignore:
* - Our own ID: we always read our own updates.
* - The ID if it is older than the oldest ID we saw. This
* can happen if we race with a thread that is allocating
* an ID -- the ID will not be used because the thread will
* keep spinning until it gets a valid one.
*/
if (s != txn_state &&
(id = s->id) != WT_TXN_NONE &&
WT_TXNID_LE(prev_oldest_id, id)) {
txn->snapshot[n++] = id;
if (WT_TXNID_LT(id, snap_min))
snap_min = id;
}
}
/*
* If we got a new snapshot, update the published snap_min for this
* session.
*/
WT_ASSERT(session, WT_TXNID_LE(prev_oldest_id, snap_min));
WT_ASSERT(session, prev_oldest_id == txn_global->oldest_id);
txn_state->snap_min = snap_min;
WT_ASSERT(session, txn_global->scan_count > 0);
(void)WT_ATOMIC_SUB4(txn_global->scan_count, 1);
__txn_sort_snapshot(session, n, current_id);
}
/*
* __wt_lsm_compact --
* Compact an LSM tree called via __wt_schema_worker.
*/
int
__wt_lsm_compact(WT_SESSION_IMPL *session, const char *name, int *skip)
{
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_TREE *lsm_tree;
time_t begin, end;
uint64_t progress;
int i, compacting, flushing, locked, ref;
compacting = flushing = locked = ref = 0;
chunk = NULL;
/*
* This function is applied to all matching sources: ignore anything
* that is not an LSM tree.
*/
if (!WT_PREFIX_MATCH(name, "lsm:"))
return (0);
/* Tell __wt_schema_worker not to look inside the LSM tree. */
*skip = 1;
WT_RET(__wt_lsm_tree_get(session, name, 0, &lsm_tree));
if (!F_ISSET(S2C(session), WT_CONN_LSM_MERGE))
WT_ERR_MSG(session, EINVAL,
"LSM compaction requires active merge threads");
WT_ERR(__wt_seconds(session, &begin));
/*
* Compacting has two distinct phases.
* 1. All in-memory chunks up to and including the current
* current chunk must be flushed. Normally, the flush code
* does not flush the last, in-use chunk, so we set a force
* flag to include that last chunk. We monitor the state of the
* last chunk and periodically push another forced flush work
* unit until it is complete.
* 2. After all flushing is done, we move onto the merging
* phase for compaction. Again, we monitor the state and
* continue to push merge work units until all merging is done.
*/
/* Lock the tree: single-thread compaction. */
WT_ERR(__wt_lsm_tree_writelock(session, lsm_tree));
locked = 1;
/* Clear any merge throttle: compact throws out that calculation. */
lsm_tree->merge_throttle = 0;
lsm_tree->merge_aggressiveness = 0;
progress = lsm_tree->merge_progressing;
/* If another thread started a compact on this tree, we're done. */
if (F_ISSET(lsm_tree, WT_LSM_TREE_COMPACTING))
goto err;
/*
* Set the switch transaction on the current chunk, if it
* hasn't been set before. This prevents further writes, so it
* can be flushed by the checkpoint worker.
*/
if (lsm_tree->nchunks > 0 &&
(chunk = lsm_tree->chunk[lsm_tree->nchunks - 1]) != NULL) {
if (chunk->switch_txn == WT_TXN_NONE)
chunk->switch_txn = __wt_txn_new_id(session);
/*
* If we have a chunk, we want to look for it to be on-disk.
* So we need to add a reference to keep it available.
*/
(void)WT_ATOMIC_ADD4(chunk->refcnt, 1);
ref = 1;
}
locked = 0;
WT_ERR(__wt_lsm_tree_writeunlock(session, lsm_tree));
if (chunk != NULL) {
WT_ERR(__wt_verbose(session, WT_VERB_LSM,
"Compact force flush %s flags 0x%" PRIx32
" chunk %u flags 0x%"
PRIx32, name, lsm_tree->flags, chunk->id, chunk->flags));
flushing = 1;
/*
* Make sure the in-memory chunk gets flushed do not push a
* switch, because we don't want to create a new in-memory
* chunk if the tree is being used read-only now.
*/
WT_ERR(__wt_lsm_manager_push_entry(session,
WT_LSM_WORK_FLUSH, WT_LSM_WORK_FORCE, lsm_tree));
} else {
/*
* If there is no chunk to flush, go straight to the
* compacting state.
*/
compacting = 1;
progress = lsm_tree->merge_progressing;
F_SET(lsm_tree, WT_LSM_TREE_COMPACTING);
WT_ERR(__wt_verbose(session, WT_VERB_LSM,
"COMPACT: Start compacting %s", lsm_tree->name));
}
/* Wait for the work unit queues to drain. */
while (F_ISSET(lsm_tree, WT_LSM_TREE_ACTIVE)) {
/*
* The flush flag is cleared when the chunk has been flushed.
* Continue to push forced flushes until the chunk is on disk.
* Once it is on disk move to the compacting phase.
*/
if (flushing) {
WT_ASSERT(session, chunk != NULL);
if (F_ISSET(chunk, WT_LSM_CHUNK_ONDISK)) {
WT_ERR(__wt_verbose(session,
WT_VERB_LSM,
"Compact flush done %s chunk %u. "
"Start compacting progress %" PRIu64,
name, chunk->id,
lsm_tree->merge_progressing));
(void)WT_ATOMIC_SUB4(chunk->refcnt, 1);
flushing = ref = 0;
compacting = 1;
F_SET(lsm_tree, WT_LSM_TREE_COMPACTING);
progress = lsm_tree->merge_progressing;
} else {
WT_ERR(__wt_verbose(session, WT_VERB_LSM,
"Compact flush retry %s chunk %u",
name, chunk->id));
WT_ERR(__wt_lsm_manager_push_entry(session,
WT_LSM_WORK_FLUSH, WT_LSM_WORK_FORCE,
lsm_tree));
}
}
/*
* The compacting flag is cleared when no merges can be done.
* Ensure that we push through some aggressive merges before
* stopping otherwise we might not do merges that would
* span chunks with different generations.
*/
if (compacting && !F_ISSET(lsm_tree, WT_LSM_TREE_COMPACTING)) {
if (lsm_tree->merge_aggressiveness < 10 ||
(progress < lsm_tree->merge_progressing) ||
lsm_tree->merge_syncing) {
progress = lsm_tree->merge_progressing;
F_SET(lsm_tree, WT_LSM_TREE_COMPACTING);
lsm_tree->merge_aggressiveness = 10;
} else
break;
}
__wt_sleep(1, 0);
WT_ERR(__wt_seconds(session, &end));
if (session->compact->max_time > 0 &&
session->compact->max_time < (uint64_t)(end - begin)) {
WT_ERR(ETIMEDOUT);
}
/*
* Push merge operations while they are still getting work
* done. If we are pushing merges, make sure they are
* aggressive, to avoid duplicating effort.
*/
if (compacting)
#define COMPACT_PARALLEL_MERGES 5
for (i = lsm_tree->queue_ref;
i < COMPACT_PARALLEL_MERGES; i++) {
lsm_tree->merge_aggressiveness = 10;
WT_ERR(__wt_lsm_manager_push_entry(
session, WT_LSM_WORK_MERGE, 0, lsm_tree));
}
}
err:
/* Ensure anything we set is cleared. */
if (ref)
(void)WT_ATOMIC_SUB4(chunk->refcnt, 1);
if (compacting) {
F_CLR(lsm_tree, WT_LSM_TREE_COMPACTING);
lsm_tree->merge_aggressiveness = 0;
}
if (locked)
WT_TRET(__wt_lsm_tree_writeunlock(session, lsm_tree));
WT_TRET(__wt_verbose(session, WT_VERB_LSM,
"Compact %s complete, return %d", name, ret));
__wt_lsm_tree_release(session, lsm_tree);
return (ret);
}
/*
* __wt_lsm_merge --
* Merge a set of chunks of an LSM tree.
*/
int
__wt_lsm_merge(WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree, u_int id)
{
WT_BLOOM *bloom;
WT_CURSOR *dest, *src;
WT_DECL_RET;
WT_ITEM key, value;
WT_LSM_CHUNK *chunk;
uint32_t generation;
uint64_t insert_count, record_count;
u_int dest_id, end_chunk, i, nchunks, start_chunk, start_id;
u_int created_chunk, verb;
int create_bloom, locked, in_sync, tret;
const char *cfg[3];
const char *drop_cfg[] =
{ WT_CONFIG_BASE(session, session_drop), "force", NULL };
bloom = NULL;
chunk = NULL;
create_bloom = 0;
created_chunk = 0;
dest = src = NULL;
locked = 0;
start_id = 0;
in_sync = 0;
/* Fast path if it's obvious no merges could be done. */
if (lsm_tree->nchunks < lsm_tree->merge_min &&
lsm_tree->merge_aggressiveness < WT_LSM_AGGRESSIVE_THRESHOLD)
return (WT_NOTFOUND);
/*
* Use the lsm_tree lock to read the chunks (so no switches occur), but
* avoid holding it while the merge is in progress: that may take a
* long time.
*/
WT_RET(__wt_lsm_tree_writelock(session, lsm_tree));
locked = 1;
WT_ERR(__lsm_merge_span(session,
lsm_tree, id, &start_chunk, &end_chunk, &record_count));
nchunks = (end_chunk + 1) - start_chunk;
WT_ASSERT(session, nchunks > 0);
start_id = lsm_tree->chunk[start_chunk]->id;
/* Find the merge generation. */
for (generation = 0, i = 0; i < nchunks; i++)
generation = WT_MAX(generation,
lsm_tree->chunk[start_chunk + i]->generation + 1);
WT_ERR(__wt_lsm_tree_writeunlock(session, lsm_tree));
locked = 0;
/* Allocate an ID for the merge. */
dest_id = WT_ATOMIC_ADD4(lsm_tree->last, 1);
/*
* We only want to do the chunk loop if we're running with verbose,
* so we wrap these statements in the conditional. Avoid the loop
* in the normal path.
*/
if (WT_VERBOSE_ISSET(session, WT_VERB_LSM)) {
WT_ERR(__wt_verbose(session, WT_VERB_LSM,
"Merging %s chunks %u-%u into %u (%" PRIu64 " records)"
", generation %" PRIu32,
lsm_tree->name,
start_chunk, end_chunk, dest_id, record_count, generation));
for (verb = start_chunk; verb <= end_chunk; verb++)
WT_ERR(__wt_verbose(session, WT_VERB_LSM,
"%s: Chunk[%u] id %u",
lsm_tree->name, verb, lsm_tree->chunk[verb]->id));
}
WT_ERR(__wt_calloc_def(session, 1, &chunk));
created_chunk = 1;
chunk->id = dest_id;
if (FLD_ISSET(lsm_tree->bloom, WT_LSM_BLOOM_MERGED) &&
(FLD_ISSET(lsm_tree->bloom, WT_LSM_BLOOM_OLDEST) ||
start_chunk > 0) && record_count > 0)
create_bloom = 1;
/*
* Special setup for the merge cursor:
* first, reset to open the dependent cursors;
* then restrict the cursor to a specific number of chunks;
* then set MERGE so the cursor doesn't track updates to the tree.
*/
WT_ERR(__wt_open_cursor(session, lsm_tree->name, NULL, NULL, &src));
F_SET(src, WT_CURSTD_RAW);
WT_ERR(__wt_clsm_init_merge(src, start_chunk, start_id, nchunks));
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_lsm_tree_setup_chunk(session, lsm_tree, chunk));
WT_ERR(ret);
if (create_bloom) {
WT_ERR(__wt_lsm_tree_setup_bloom(session, lsm_tree, chunk));
WT_ERR(__wt_bloom_create(session, chunk->bloom_uri,
lsm_tree->bloom_config,
record_count, lsm_tree->bloom_bit_count,
lsm_tree->bloom_hash_count, &bloom));
}
/* Discard pages we read as soon as we're done with them. */
F_SET(session, WT_SESSION_NO_CACHE);
cfg[0] = WT_CONFIG_BASE(session, session_open_cursor);
cfg[1] = "bulk,raw,skip_sort_check";
cfg[2] = NULL;
WT_ERR(__wt_open_cursor(session, chunk->uri, NULL, cfg, &dest));
#define LSM_MERGE_CHECK_INTERVAL 1000
for (insert_count = 0; (ret = src->next(src)) == 0; insert_count++) {
if (insert_count % LSM_MERGE_CHECK_INTERVAL == 0) {
if (!F_ISSET(lsm_tree, WT_LSM_TREE_ACTIVE))
WT_ERR(EINTR);
WT_STAT_FAST_CONN_INCRV(session,
lsm_rows_merged, LSM_MERGE_CHECK_INTERVAL);
++lsm_tree->merge_progressing;
}
WT_ERR(src->get_key(src, &key));
dest->set_key(dest, &key);
WT_ERR(src->get_value(src, &value));
dest->set_value(dest, &value);
WT_ERR(dest->insert(dest));
if (create_bloom)
WT_ERR(__wt_bloom_insert(bloom, &key));
}
WT_ERR_NOTFOUND_OK(ret);
WT_STAT_FAST_CONN_INCRV(session,
lsm_rows_merged, insert_count % LSM_MERGE_CHECK_INTERVAL);
++lsm_tree->merge_progressing;
WT_ERR(__wt_verbose(session, WT_VERB_LSM,
"Bloom size for %" PRIu64 " has %" PRIu64 " items inserted.",
record_count, insert_count));
/*
* Closing and syncing the files can take a while. Set the
* merge_syncing field so that compact knows it is still in
* progress.
*/
(void)WT_ATOMIC_ADD4(lsm_tree->merge_syncing, 1);
in_sync = 1;
/*
* We've successfully created the new chunk. Now install it. We need
* to ensure that the NO_CACHE flag is cleared and the bloom filter
* is closed (even if a step fails), so track errors but don't return
* until we've cleaned up.
*/
WT_TRET(src->close(src));
WT_TRET(dest->close(dest));
src = dest = NULL;
F_CLR(session, WT_SESSION_NO_CACHE);
/*
* We're doing advisory reads to fault the new trees into cache.
* Don't block if the cache is full: our next unit of work may be to
* discard some trees to free space.
*/
F_SET(session, WT_SESSION_NO_CACHE_CHECK);
if (create_bloom) {
if (ret == 0)
WT_TRET(__wt_bloom_finalize(bloom));
/*
* Read in a key to make sure the Bloom filters btree handle is
* open before it becomes visible to application threads.
* Otherwise application threads will stall while it is opened
* and internal pages are read into cache.
*/
if (ret == 0) {
WT_CLEAR(key);
WT_TRET_NOTFOUND_OK(__wt_bloom_get(bloom, &key));
}
WT_TRET(__wt_bloom_close(bloom));
bloom = NULL;
}
WT_ERR(ret);
/*
* Open a handle on the new chunk before application threads attempt
* to access it, opening it pre-loads internal pages into the file
* system cache.
*/
cfg[1] = "checkpoint=" WT_CHECKPOINT;
WT_ERR(__wt_open_cursor(session, chunk->uri, NULL, cfg, &dest));
WT_TRET(dest->close(dest));
dest = NULL;
++lsm_tree->merge_progressing;
(void)WT_ATOMIC_SUB4(lsm_tree->merge_syncing, 1);
in_sync = 0;
WT_ERR_NOTFOUND_OK(ret);
WT_ERR(__wt_lsm_tree_set_chunk_size(session, chunk));
WT_ERR(__wt_lsm_tree_writelock(session, lsm_tree));
locked = 1;
/*
* Check whether we raced with another merge, and adjust the chunk
* array offset as necessary.
*/
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++)
if (lsm_tree->chunk[start_chunk]->id == start_id)
break;
/*
* It is safe to error out here - since the update can only fail
* prior to making updates to the tree.
*/
WT_ERR(__wt_lsm_merge_update_tree(
session, lsm_tree, start_chunk, nchunks, chunk));
if (create_bloom)
F_SET(chunk, WT_LSM_CHUNK_BLOOM);
chunk->count = insert_count;
chunk->generation = generation;
F_SET(chunk, WT_LSM_CHUNK_ONDISK);
/*
* We have no current way of continuing if the metadata update fails,
* so we will panic in that case. Put some effort into cleaning up
* after ourselves here - so things have a chance of shutting down.
*
* Any errors that happened after the tree was locked are
* fatal - we can't guarantee the state of the tree.
*/
if ((ret = __wt_lsm_meta_write(session, lsm_tree)) != 0)
WT_PANIC_ERR(session, ret, "Failed finalizing LSM merge");
lsm_tree->dsk_gen++;
/* Update the throttling while holding the tree lock. */
__wt_lsm_tree_throttle(session, lsm_tree, 1);
/* Schedule a pass to discard old chunks */
WT_ERR(__wt_lsm_manager_push_entry(
session, WT_LSM_WORK_DROP, 0, lsm_tree));
err: if (locked)
WT_TRET(__wt_lsm_tree_writeunlock(session, lsm_tree));
if (in_sync)
(void)WT_ATOMIC_SUB4(lsm_tree->merge_syncing, 1);
if (src != NULL)
WT_TRET(src->close(src));
if (dest != NULL)
WT_TRET(dest->close(dest));
if (bloom != NULL)
WT_TRET(__wt_bloom_close(bloom));
if (ret != 0 && created_chunk) {
/* Drop the newly-created files on error. */
if (chunk->uri != NULL) {
WT_WITH_SCHEMA_LOCK(session, tret =
__wt_schema_drop(session, chunk->uri, drop_cfg));
WT_TRET(tret);
}
if (create_bloom && chunk->bloom_uri != NULL) {
WT_WITH_SCHEMA_LOCK(session,
tret = __wt_schema_drop(
session, chunk->bloom_uri, drop_cfg));
WT_TRET(tret);
}
__wt_free(session, chunk->bloom_uri);
__wt_free(session, chunk->uri);
__wt_free(session, chunk);
if (ret == EINTR)
WT_TRET(__wt_verbose(session, WT_VERB_LSM,
"Merge aborted due to close"));
else
WT_TRET(__wt_verbose(session, WT_VERB_LSM,
"Merge failed with %s", wiredtiger_strerror(ret)));
}
F_CLR(session, WT_SESSION_NO_CACHE | WT_SESSION_NO_CACHE_CHECK);
return (ret);
}
