/*
* __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);
}
/*
* __compact_rewrite --
* Return if a page needs to be re-written.
*/
static int
__compact_rewrite(WT_SESSION_IMPL *session, WT_REF *ref, bool *skipp)
{
WT_BM *bm;
WT_DECL_RET;
WT_PAGE *page;
WT_PAGE_MODIFY *mod;
size_t addr_size;
const uint8_t *addr;
*skipp = true; /* Default skip. */
bm = S2BT(session)->bm;
page = ref->page;
mod = page->modify;
/*
* Ignore the root: it may not have a replacement address, and besides,
* if anything else gets written, so will it.
*/
if (__wt_ref_is_root(ref))
return (0);
/* Ignore currently dirty pages, they will be written regardless. */
if (__wt_page_is_modified(page))
return (0);
/*
* If the page is clean, test the original addresses.
* If the page is a 1-to-1 replacement, test the replacement addresses.
* Ignore empty pages, they get merged into the parent.
*/
if (mod == NULL || mod->rec_result == 0) {
WT_RET(__wt_ref_info(session, ref, &addr, &addr_size, NULL));
if (addr == NULL)
return (0);
WT_RET(
bm->compact_page_skip(bm, session, addr, addr_size, skipp));
} else if (mod->rec_result == WT_PM_REC_REPLACE) {
/*
* The page's modification information can change underfoot if
* the page is being reconciled, serialize with reconciliation.
*/
F_CAS_ATOMIC_WAIT(page, WT_PAGE_RECONCILIATION);
ret = bm->compact_page_skip(bm, session,
mod->mod_replace.addr, mod->mod_replace.size, skipp);
F_CLR_ATOMIC(page, WT_PAGE_RECONCILIATION);
WT_RET(ret);
}
return (0);
}
/*
* __lsm_free_chunks --
* Try to drop chunks from the tree that are no longer required.
*/
static int
__lsm_free_chunks(WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree)
{
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_WORKER_COOKIE cookie;
u_int i, skipped;
int progress;
/*
* Take a copy of the current state of the LSM tree and look for chunks
* to drop. We do it this way to avoid holding the LSM tree lock while
* doing I/O or waiting on the schema lock.
*
* This is safe because only one thread will be in this function at a
* time (the first merge thread). Merges may complete concurrently,
* and the old_chunks array may be extended, but we shuffle down the
* pointers each time we free one to keep the non-NULL slots at the
* beginning of the array.
*/
WT_CLEAR(cookie);
WT_RET(__lsm_copy_chunks(session, lsm_tree, &cookie, 1));
for (i = skipped = 0, progress = 0; i < cookie.nchunks; i++) {
chunk = cookie.chunk_array[i];
WT_ASSERT(session, chunk != NULL);
/* Skip the chunk if another worker is using it. */
if (chunk->refcnt > 1) {
++skipped;
continue;
}
if (F_ISSET_ATOMIC(chunk, WT_LSM_CHUNK_BLOOM)) {
/*
* An EBUSY return is acceptable - a cursor may still
* be positioned on this old chunk.
*/
if ((ret = __lsm_drop_file(
session, chunk->bloom_uri)) == EBUSY) {
WT_VERBOSE_ERR(session, lsm,
"LSM worker bloom drop busy: %s.",
chunk->bloom_uri);
++skipped;
continue;
} else
WT_ERR(ret);
F_CLR_ATOMIC(chunk, WT_LSM_CHUNK_BLOOM);
}
if (chunk->uri != NULL) {
/*
* An EBUSY return is acceptable - a cursor may still
* be positioned on this old chunk.
*/
if ((ret = __lsm_drop_file(
session, chunk->uri)) == EBUSY) {
WT_VERBOSE_ERR(session, lsm,
"LSM worker drop busy: %s.",
chunk->uri);
++skipped;
continue;
} else
WT_ERR(ret);
}
progress = 1;
/* Lock the tree to clear out the old chunk information. */
WT_ERR(__wt_lsm_tree_lock(session, lsm_tree, 1));
/*
* The chunk we are looking at should be the first one in the
* tree that we haven't already skipped over.
*/
WT_ASSERT(session, lsm_tree->old_chunks[skipped] == chunk);
__wt_free(session, chunk->bloom_uri);
__wt_free(session, chunk->uri);
__wt_free(session, lsm_tree->old_chunks[skipped]);
/* Shuffle down to keep all occupied slots at the beginning. */
if (--lsm_tree->nold_chunks > skipped) {
memmove(lsm_tree->old_chunks + skipped,
lsm_tree->old_chunks + skipped + 1,
(lsm_tree->nold_chunks - skipped) *
sizeof(WT_LSM_CHUNK *));
lsm_tree->old_chunks[lsm_tree->nold_chunks] = NULL;
}
/*
* Clear the chunk in the cookie so we don't attempt to
* decrement the reference count.
*/
cookie.chunk_array[i] = NULL;
/*
* Update the metadata. We used to try to optimize by only
* updating the metadata once at the end, but the error
* handling is not straightforward.
*/
WT_TRET(__wt_lsm_meta_write(session, lsm_tree));
WT_ERR(__wt_lsm_tree_unlock(session, lsm_tree));
}
err: __lsm_unpin_chunks(session, &cookie);
__wt_free(session, cookie.chunk_array);
/* Returning non-zero means there is no work to do. */
if (!progress)
WT_TRET(WT_NOTFOUND);
return (ret);
}
