/*
* __compact_checkpoint --
* Perform a checkpoint for compaction.
*/
static int
__compact_checkpoint(WT_SESSION_IMPL *session)
{
WT_DECL_RET;
WT_TXN_GLOBAL *txn_global;
uint64_t txn_gen;
/*
* Force compaction checkpoints: we don't want to skip it because the
* work we need to have done is done in the underlying block manager.
*/
const char *checkpoint_cfg[] = {
WT_CONFIG_BASE(session, WT_SESSION_checkpoint), "force=1", NULL };
/* Checkpoints take a lot of time, check if we've run out. */
WT_RET(__wt_session_compact_check_timeout(session));
if ((ret = __wt_txn_checkpoint(session, checkpoint_cfg, false)) == 0)
return (0);
WT_RET_BUSY_OK(ret);
/*
* If there's a checkpoint running, wait for it to complete, checking if
* we're out of time. If there's no checkpoint running or the checkpoint
* generation number changes, the checkpoint blocking us has completed.
*/
txn_global = &S2C(session)->txn_global;
for (txn_gen = __wt_gen(session, WT_GEN_CHECKPOINT);;) {
/*
* This loop only checks objects that are declared volatile,
* therefore no barriers are needed.
*/
if (!txn_global->checkpoint_running ||
txn_gen != __wt_gen(session, WT_GEN_CHECKPOINT))
break;
WT_RET(__wt_session_compact_check_timeout(session));
__wt_sleep(2, 0);
}
return (0);
}
/*
* __wt_compact --
* Compact a file.
*/
int
__wt_compact(WT_SESSION_IMPL *session)
{
WT_BM *bm;
WT_BTREE *btree;
WT_DECL_RET;
WT_REF *ref;
u_int i;
bool skip;
btree = S2BT(session);
bm = btree->bm;
ref = NULL;
WT_STAT_DATA_INCR(session, session_compact);
/*
* Check if compaction might be useful -- the API layer will quit trying
* to compact the data source if we make no progress, set a flag if the
* block layer thinks compaction is possible.
*/
WT_RET(bm->compact_skip(bm, session, &skip));
if (skip)
return (0);
/*
* Reviewing in-memory pages requires looking at page reconciliation
* results, because we care about where the page is stored now, not
* where the page was stored when we first read it into the cache.
* We need to ensure we don't race with page reconciliation as it's
* writing the page modify information.
*
* There are two ways we call reconciliation: checkpoints and eviction.
* Get the tree's flush lock which blocks threads writing pages for
* checkpoints.
*/
__wt_spin_lock(session, &btree->flush_lock);
/* Walk the tree reviewing pages to see if they should be re-written. */
for (i = 0;;) {
/* Periodically check if we've run out of time. */
if (++i > 100) {
WT_ERR(__wt_session_compact_check_timeout(session));
i = 0;
}
/*
* Pages read for compaction aren't "useful"; don't update the
* read generation of pages already in memory, and if a page is
* read, set its generation to a low value so it is evicted
* quickly.
*/
WT_ERR(__wt_tree_walk(session, &ref,
WT_READ_COMPACT | WT_READ_NO_GEN | WT_READ_WONT_NEED));
if (ref == NULL)
break;
WT_ERR(__compact_rewrite(session, ref, &skip));
if (skip)
continue;
session->compact_state = WT_COMPACT_SUCCESS;
/* Rewrite the page: mark the page and tree dirty. */
WT_ERR(__wt_page_modify_init(session, ref->page));
__wt_page_modify_set(session, ref->page);
WT_STAT_DATA_INCR(session, btree_compact_rewrite);
}
err: if (ref != NULL)
WT_TRET(__wt_page_release(session, ref, 0));
/* Unblock threads writing leaf pages. */
__wt_spin_unlock(session, &btree->flush_lock);
return (ret);
}
