/*
* __merge_walk --
* Visit all of the child references in a locked subtree and apply a
* callback function to them.
*/
static int
__merge_walk(WT_SESSION_IMPL *session, WT_PAGE *page, u_int depth,
void (*visit)(WT_PAGE *, WT_REF *, WT_VISIT_STATE *),
WT_VISIT_STATE *state)
{
WT_PAGE *child;
WT_REF *ref;
uint32_t i;
if (depth > state->maxdepth)
state->maxdepth = depth;
WT_REF_FOREACH(page, ref, i)
switch (ref->state) {
case WT_REF_LOCKED:
child = ref->page;
/*
* Visit internal pages recursively. This must match
* the walk in __rec_review: if the merge succeeds, we
* have to unlock everything.
*/
if (child->type == page->type &&
__wt_btree_mergeable(child)) {
WT_RET(__merge_walk(
session, child, depth + 1, visit, state));
break;
}
/* FALLTHROUGH */
case WT_REF_DELETED:
case WT_REF_DISK:
(*visit)(page, ref, state);
break;
case WT_REF_EVICT_WALK:
case WT_REF_MEM:
case WT_REF_READING:
WT_ILLEGAL_VALUE(session);
}
return (0);
}
/*
* __wt_merge_tree --
* Attempt to collapse a stack of split-merge pages in memory into a
* shallow tree. If enough keys are found, create a real internal node
* that can be evicted (and, if necessary, split further).
*
* This code is designed to deal with workloads that otherwise create
* arbitrarily deep (and slow) trees in memory.
*/
int
__wt_merge_tree(WT_SESSION_IMPL *session, WT_PAGE *top)
{
WT_DECL_RET;
WT_PAGE *lchild, *newtop, *rchild;
WT_REF *newref;
WT_VISIT_STATE visit_state;
uint32_t refcnt, split;
int promote;
u_int levels;
uint8_t page_type;
WT_CLEAR(visit_state);
visit_state.session = session;
lchild = newtop = rchild = NULL;
page_type = top->type;
WT_ASSERT(session, __wt_btree_mergeable(top));
WT_ASSERT(session, top->ref->state == WT_REF_LOCKED);
/*
* Walk the subtree, count the references at the bottom level and
* calculate the maximum depth.
*/
WT_RET(__merge_walk(session, top, 1, __merge_count, &visit_state));
/* If there aren't enough useful levels, give up. */
if (visit_state.maxdepth < WT_MERGE_STACK_MIN)
return (EBUSY);
/*
* Don't allow split merges to generate arbitrarily large pages.
* Ideally we would choose a size based on the internal_page_max
* setting for the btree, but we don't have the correct btree handle
* available.
*/
if (visit_state.refcnt > WT_MERGE_MAX_REFS)
return (EBUSY);
/*
* Now we either collapse the internal pages into one split-merge page,
* or if there are "enough" keys, we split into two equal internal
* pages, each of which can be evicted independently.
*
* We set a flag (WT_PM_REC_SPLIT_MERGE) on the created page if it
* isn't big enough to justify the cost of evicting it. If splits
* continue, it will be merged again until it gets over this limit.
*/
promote = 0;
refcnt = (uint32_t)visit_state.refcnt;
if (refcnt >= WT_MERGE_FULL_PAGE && visit_state.seen_live) {
/*
* In the normal case where there are live children spread
* through the subtree, create two child pages.
*
* Handle the case where the only live child is first / last
* specially: put the live child into the top-level page.
*
* Set SPLIT_MERGE on the internal pages if there are any live
* children: they can't be evicted, so there is no point
* permanently deepening the tree.
*/
if (visit_state.first_live == visit_state.last_live &&
(visit_state.first_live == 0 ||
visit_state.first_live == refcnt - 1))
split = (visit_state.first_live == 0) ? 1 : refcnt - 1;
else
split = (refcnt + 1) / 2;
/* Only promote if we can create a real page. */
if (split == 1 || split == refcnt - 1)
promote = 1;
else if (split >= WT_MERGE_FULL_PAGE &&
visit_state.first_live >= split)
promote = 1;
else if (refcnt - split >= WT_MERGE_FULL_PAGE &&
visit_state.last_live < split)
promote = 1;
}
if (promote) {
/* Create a new top-level split-merge page with two entries. */
WT_ERR(__merge_new_page(session, page_type, 2, 1, &newtop));
visit_state.split = split;
/* Left split. */
if (split == 1)
visit_state.first = newtop;
else {
WT_ERR(__merge_new_page(session, page_type, split,
visit_state.first_live < split, &lchild));
visit_state.first = lchild;
}
/* Right split. */
if (split == refcnt - 1) {
visit_state.second = newtop;
visit_state.second_ref = &newtop->u.intl.t[1];
} else {
WT_ERR(__merge_new_page(session, page_type,
refcnt - split, visit_state.last_live >= split,
&rchild));
visit_state.second = rchild;
visit_state.second_ref =
&visit_state.second->u.intl.t[0];
}
} else {
/*
* Create a new split-merge page for small merges, or if the
* page above is a split merge page. When we do a big enough
* merge, we create a real page at the top and don't consider
* it as a merge candidate again. Over time with an insert
* workload the tree will grow deeper, but that's inevitable,
* and this keeps individual merges small.
*/
WT_ERR(__merge_new_page(session, page_type, refcnt,
refcnt < WT_MERGE_FULL_PAGE ||
__wt_btree_mergeable(top->parent),
&newtop));
visit_state.first = newtop;
}
/*
* Copy the references into the new tree, but don't update anything in
* the locked tree in case there is an error and we need to back out.
* We do this in a separate pass so that we can figure out the key for
* the split point: that allocates memory and so it could still fail.
*/
visit_state.page = visit_state.first;
visit_state.ref = visit_state.page->u.intl.t;
visit_state.refcnt = 0;
WT_ERR(__merge_walk(session, top, 0, __merge_copy_ref, &visit_state));
if (promote) {
/* Promote keys into the top-level page. */
if (lchild != NULL) {
newref = &newtop->u.intl.t[0];
WT_LINK_PAGE(newtop, newref, lchild);
newref->state = WT_REF_MEM;
WT_ERR(__merge_promote_key(session, newref));
}
if (rchild != NULL) {
newref = &newtop->u.intl.t[1];
WT_LINK_PAGE(newtop, newref, rchild);
newref->state = WT_REF_MEM;
WT_ERR(__merge_promote_key(session, newref));
}
}
/*
* We have copied everything into place and allocated all of the memory
* we need. Now link all pages into the new tree and unlock them.
*
* The only way this could fail is if a reference state has been
* changed by another thread since they were locked. Panic in that
* case: that should never happen.
*/
visit_state.page = visit_state.first;
visit_state.ref = visit_state.page->u.intl.t;
visit_state.refcnt = 0;
ret = __merge_walk(session, top, 0, __merge_switch_page, &visit_state);
if (ret != 0)
WT_ERR(__wt_illegal_value(session, "__wt_merge_tree"));
newtop->u.intl.recno = top->u.intl.recno;
newtop->parent = top->parent;
newtop->ref = top->ref;
#ifdef HAVE_DIAGNOSTIC
/*
* Before swapping in the new tree, walk the pages we are discarding,
* check that everything looks right.
*/
__merge_check_discard(session, top);
#endif
/*
* Set up the new top-level page as a split so that it will be swapped
* into place by our caller.
*/
top->modify->flags = WT_PM_REC_SPLIT;
top->modify->u.split = newtop;
WT_VERBOSE_ERR(session, evict,
"Successfully %s %" PRIu32
" split-merge pages containing %" PRIu32 " keys\n",
promote ? "promoted" : "merged", visit_state.maxdepth, refcnt);
/* Evict new child pages as soon as possible. */
if (lchild != NULL && !F_ISSET(lchild->modify, WT_PM_REC_SPLIT_MERGE))
lchild->read_gen = WT_READ_GEN_OLDEST;
if (rchild != NULL && !F_ISSET(rchild->modify, WT_PM_REC_SPLIT_MERGE))
rchild->read_gen = WT_READ_GEN_OLDEST;
/* Update statistics. */
WT_CSTAT_INCR(session, cache_eviction_merge);
WT_DSTAT_INCR(session, cache_eviction_merge);
/* How many levels did we remove? */
levels = visit_state.maxdepth - (promote ? 2 : 1);
WT_CSTAT_INCRV(session, cache_eviction_merge_levels, levels);
WT_DSTAT_INCRV(session, cache_eviction_merge_levels, levels);
return (0);
err: WT_VERBOSE_TRET(session, evict,
"Failed to merge %" PRIu32
" split-merge pages containing %" PRIu32 " keys\n",
visit_state.maxdepth, refcnt);
WT_CSTAT_INCR(session, cache_eviction_merge_fail);
WT_DSTAT_INCR(session, cache_eviction_merge_fail);
if (newtop != NULL)
__wt_page_out(session, &newtop);
if (lchild != NULL)
__wt_page_out(session, &lchild);
if (rchild != NULL)
__wt_page_out(session, &rchild);
return (ret);
}
/*
* __wt_rec_evict --
* Reconciliation plus eviction.
*/
int
__wt_rec_evict(WT_SESSION_IMPL *session, WT_PAGE *page, int exclusive)
{
WT_DECL_RET;
WT_PAGE_MODIFY *mod;
int merge;
WT_VERBOSE_RET(session, evict,
"page %p (%s)", page, __wt_page_type_string(page->type));
WT_ASSERT(session, session->excl_next == 0);
/*
* If we get a split-merge page during normal eviction, try to collapse
* it. During close, it will be merged into its parent.
*/
mod = page->modify;
merge = __wt_btree_mergeable(page);
if (merge && exclusive)
return (EBUSY);
WT_ASSERT(session, merge || mod == NULL ||
!F_ISSET(mod, WT_PM_REC_SPLIT_MERGE));
/*
* Get exclusive access to the page and review the page and its subtree
* for conditions that would block our eviction of the page. If the
* check fails (for example, we find a child page that can't be merged),
* we're done. We have to make this check for clean pages, too: while
* unlikely eviction would choose an internal page with children, it's
* not disallowed anywhere.
*
* Note that page->ref may be NULL in some cases (e.g., for root pages
* or during salvage). That's OK if exclusive is set: we won't check
* hazard pointers in that case.
*/
WT_ERR(__rec_review(session, page->ref, page, exclusive, merge, 1));
/* Try to merge internal pages. */
if (merge)
WT_ERR(__wt_merge_tree(session, page));
/*
* Update the page's modification reference, reconciliation might have
* changed it.
*/
mod = page->modify;
/* Count evictions of internal pages during normal operation. */
if (!exclusive && !merge &&
(page->type == WT_PAGE_COL_INT || page->type == WT_PAGE_ROW_INT)) {
WT_CSTAT_INCR(session, cache_eviction_internal);
WT_DSTAT_INCR(session, cache_eviction_internal);
}
/*
* Update the parent and discard the page.
*/
if (mod == NULL || !F_ISSET(mod, WT_PM_REC_MASK)) {
WT_ASSERT(session,
exclusive || page->ref->state == WT_REF_LOCKED);
if (WT_PAGE_IS_ROOT(page))
__rec_root_update(session);
else
__rec_page_clean_update(session, page);
/* Discard the page. */
__rec_discard_page(session, page, exclusive);
WT_CSTAT_INCR(session, cache_eviction_clean);
WT_DSTAT_INCR(session, cache_eviction_clean);
} else {
if (WT_PAGE_IS_ROOT(page))
__rec_root_update(session);
else
WT_ERR(__rec_page_dirty_update(session, page));
/* Discard the tree rooted in this page. */
__rec_discard_tree(session, page, exclusive);
WT_CSTAT_INCR(session, cache_eviction_dirty);
WT_DSTAT_INCR(session, cache_eviction_dirty);
}
if (0) {
err: /*
* If unable to evict this page, release exclusive reference(s)
* we've acquired.
*/
__rec_excl_clear(session);
WT_CSTAT_INCR(session, cache_eviction_fail);
WT_DSTAT_INCR(session, cache_eviction_fail);
}
session->excl_next = 0;
return (ret);
}
