/*
* __wt_page_in_func --
* Acquire a hazard pointer to a page; if the page is not in-memory,
* read it from the disk and build an in-memory version.
*/
int
__wt_page_in_func(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags
#ifdef HAVE_DIAGNOSTIC
, const char *file, int line
#endif
)
{
WT_BTREE *btree;
WT_DECL_RET;
WT_PAGE *page;
u_int sleep_cnt, wait_cnt;
int busy, cache_work, force_attempts, oldgen, stalled;
btree = S2BT(session);
stalled = 0;
for (force_attempts = oldgen = 0, sleep_cnt = wait_cnt = 0;;) {
switch (ref->state) {
case WT_REF_DISK:
case WT_REF_DELETED:
if (LF_ISSET(WT_READ_CACHE))
return (WT_NOTFOUND);
/*
* The page isn't in memory, read it. If this thread is
* allowed to do eviction work, check for space in the
* cache.
*/
if (!LF_ISSET(WT_READ_NO_EVICT))
WT_RET(__wt_cache_eviction_check(
session, 1, NULL));
WT_RET(__page_read(session, ref));
oldgen = LF_ISSET(WT_READ_WONT_NEED) ||
F_ISSET(session, WT_SESSION_NO_CACHE);
continue;
case WT_REF_READING:
if (LF_ISSET(WT_READ_CACHE))
return (WT_NOTFOUND);
if (LF_ISSET(WT_READ_NO_WAIT))
return (WT_NOTFOUND);
/* Waiting on another thread's read, stall. */
WT_STAT_FAST_CONN_INCR(session, page_read_blocked);
stalled = 1;
break;
case WT_REF_LOCKED:
if (LF_ISSET(WT_READ_NO_WAIT))
return (WT_NOTFOUND);
/* Waiting on eviction, stall. */
WT_STAT_FAST_CONN_INCR(session, page_locked_blocked);
stalled = 1;
break;
case WT_REF_SPLIT:
return (WT_RESTART);
case WT_REF_MEM:
/*
* The page is in memory.
*
* Get a hazard pointer if one is required. We cannot
* be evicting if no hazard pointer is required, we're
* done.
*/
if (F_ISSET(btree, WT_BTREE_IN_MEMORY))
goto skip_evict;
/*
* The expected reason we can't get a hazard pointer is
* because the page is being evicted, yield, try again.
*/
#ifdef HAVE_DIAGNOSTIC
WT_RET(
__wt_hazard_set(session, ref, &busy, file, line));
#else
WT_RET(__wt_hazard_set(session, ref, &busy));
#endif
if (busy) {
WT_STAT_FAST_CONN_INCR(
session, page_busy_blocked);
break;
}
/*
* If eviction is configured for this file, check to see
* if the page qualifies for forced eviction and update
* the page's generation number. If eviction isn't being
* done on this file, we're done.
*/
if (LF_ISSET(WT_READ_NO_EVICT) ||
F_ISSET(session, WT_SESSION_NO_EVICTION) ||
F_ISSET(btree, WT_BTREE_NO_EVICTION))
goto skip_evict;
/*
* Forcibly evict pages that are too big.
*/
page = ref->page;
if (force_attempts < 10 &&
__evict_force_check(session, page)) {
++force_attempts;
ret = __wt_page_release_evict(session, ref);
/* If forced eviction fails, stall. */
if (ret == EBUSY) {
ret = 0;
WT_STAT_FAST_CONN_INCR(session,
page_forcible_evict_blocked);
stalled = 1;
break;
}
WT_RET(ret);
/*
* The result of a successful forced eviction
* is a page-state transition (potentially to
* an in-memory page we can use, or a restart
* return for our caller), continue the outer
* page-acquisition loop.
*/
continue;
}
/*
* If we read the page and we are configured to not
* trash the cache, set the oldest read generation so
* the page is forcibly evicted as soon as possible.
*
* Otherwise, update the page's read generation.
*/
if (oldgen && page->read_gen == WT_READGEN_NOTSET)
__wt_page_evict_soon(page);
else if (!LF_ISSET(WT_READ_NO_GEN) &&
page->read_gen != WT_READGEN_OLDEST &&
page->read_gen < __wt_cache_read_gen(session))
page->read_gen =
__wt_cache_read_gen_bump(session);
skip_evict:
/*
* Check if we need an autocommit transaction.
* Starting a transaction can trigger eviction, so skip
* it if eviction isn't permitted.
*/
return (LF_ISSET(WT_READ_NO_EVICT) ? 0 :
__wt_txn_autocommit_check(session));
WT_ILLEGAL_VALUE(session);
}
/*
* We failed to get the page -- yield before retrying, and if
* we've yielded enough times, start sleeping so we don't burn
* CPU to no purpose.
*/
if (stalled)
wait_cnt += 1000;
else if (++wait_cnt < 1000) {
__wt_yield();
continue;
}
/*
* If stalling and this thread is allowed to do eviction work,
* check if the cache needs help. If we do work for the cache,
* substitute that for a sleep.
*/
if (!LF_ISSET(WT_READ_NO_EVICT)) {
WT_RET(
__wt_cache_eviction_check(session, 1, &cache_work));
if (cache_work)
continue;
}
sleep_cnt = WT_MIN(sleep_cnt + 1000, 10000);
WT_STAT_FAST_CONN_INCRV(session, page_sleep, sleep_cnt);
__wt_sleep(0, sleep_cnt);
}
}
/*
* __wt_txn_commit --
* Commit the current transaction.
*/
int
__wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[])
{
WT_CONFIG_ITEM cval;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_TXN *txn;
WT_TXN_GLOBAL *txn_global;
WT_TXN_OP *op;
u_int i;
bool locked, readonly;
#ifdef HAVE_TIMESTAMPS
wt_timestamp_t prev_commit_timestamp, ts;
bool update_timestamp;
#endif
txn = &session->txn;
conn = S2C(session);
txn_global = &conn->txn_global;
locked = false;
WT_ASSERT(session, F_ISSET(txn, WT_TXN_RUNNING));
WT_ASSERT(session, !F_ISSET(txn, WT_TXN_ERROR) ||
txn->mod_count == 0);
readonly = txn->mod_count == 0;
/*
* Look for a commit timestamp.
*/
WT_ERR(
__wt_config_gets_def(session, cfg, "commit_timestamp", 0, &cval));
if (cval.len != 0) {
#ifdef HAVE_TIMESTAMPS
WT_ERR(__wt_txn_parse_timestamp(session, "commit", &ts, &cval));
WT_ERR(__wt_timestamp_validate(session,
"commit", &ts, &cval, true, true, true));
__wt_timestamp_set(&txn->commit_timestamp, &ts);
__wt_txn_set_commit_timestamp(session);
#else
WT_ERR_MSG(session, EINVAL, "commit_timestamp requires a "
"version of WiredTiger built with timestamp support");
#endif
}
#ifdef HAVE_TIMESTAMPS
/*
* Debugging checks on timestamps, if user requested them.
*/
if (F_ISSET(txn, WT_TXN_TS_COMMIT_ALWAYS) &&
!F_ISSET(txn, WT_TXN_HAS_TS_COMMIT) &&
txn->mod_count != 0)
WT_ERR_MSG(session, EINVAL, "commit_timestamp required and "
"none set on this transaction");
if (F_ISSET(txn, WT_TXN_TS_COMMIT_NEVER) &&
F_ISSET(txn, WT_TXN_HAS_TS_COMMIT) &&
txn->mod_count != 0)
WT_ERR_MSG(session, EINVAL, "no commit_timestamp required and "
"timestamp set on this transaction");
#endif
/*
* The default sync setting is inherited from the connection, but can
* be overridden by an explicit "sync" setting for this transaction.
*/
WT_ERR(__wt_config_gets_def(session, cfg, "sync", 0, &cval));
/*
* If the user chose the default setting, check whether sync is enabled
* for this transaction (either inherited or via begin_transaction).
* If sync is disabled, clear the field to avoid the log write being
* flushed.
*
* Otherwise check for specific settings. We don't need to check for
* "on" because that is the default inherited from the connection. If
* the user set anything in begin_transaction, we only override with an
* explicit setting.
*/
if (cval.len == 0) {
if (!FLD_ISSET(txn->txn_logsync, WT_LOG_SYNC_ENABLED) &&
!F_ISSET(txn, WT_TXN_SYNC_SET))
txn->txn_logsync = 0;
} else {
/*
* If the caller already set sync on begin_transaction then
* they should not be using sync on commit_transaction.
* Flag that as an error.
*/
if (F_ISSET(txn, WT_TXN_SYNC_SET))
WT_ERR_MSG(session, EINVAL,
"Sync already set during begin_transaction");
if (WT_STRING_MATCH("background", cval.str, cval.len))
txn->txn_logsync = WT_LOG_BACKGROUND;
else if (WT_STRING_MATCH("off", cval.str, cval.len))
txn->txn_logsync = 0;
/*
* We don't need to check for "on" here because that is the
* default to inherit from the connection setting.
*/
}
/* Commit notification. */
if (txn->notify != NULL)
WT_ERR(txn->notify->notify(txn->notify,
(WT_SESSION *)session, txn->id, 1));
/*
* We are about to release the snapshot: copy values into any
* positioned cursors so they don't point to updates that could be
* freed once we don't have a snapshot.
*/
if (session->ncursors > 0) {
WT_DIAGNOSTIC_YIELD;
WT_ERR(__wt_session_copy_values(session));
}
/* If we are logging, write a commit log record. */
if (txn->logrec != NULL &&
FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED) &&
!F_ISSET(session, WT_SESSION_NO_LOGGING)) {
/*
* We are about to block on I/O writing the log.
* Release our snapshot in case it is keeping data pinned.
* This is particularly important for checkpoints.
*/
__wt_txn_release_snapshot(session);
/*
* We hold the visibility lock for reading from the time
* we write our log record until the time we release our
* transaction so that the LSN any checkpoint gets will
* always reflect visible data.
*/
__wt_readlock(session, &txn_global->visibility_rwlock);
locked = true;
WT_ERR(__wt_txn_log_commit(session, cfg));
}
/* Note: we're going to commit: nothing can fail after this point. */
/* Process and free updates. */
for (i = 0, op = txn->mod; i < txn->mod_count; i++, op++) {
switch (op->type) {
case WT_TXN_OP_BASIC:
case WT_TXN_OP_BASIC_TS:
case WT_TXN_OP_INMEM:
/*
* Switch reserved operations to abort to
* simplify obsolete update list truncation.
*/
if (op->u.upd->type == WT_UPDATE_RESERVED) {
op->u.upd->txnid = WT_TXN_ABORTED;
break;
}
/*
* Writes to the lookaside file can be evicted as soon
* as they commit.
*/
if (conn->cache->las_fileid != 0 &&
op->fileid == conn->cache->las_fileid) {
op->u.upd->txnid = WT_TXN_NONE;
break;
}
#ifdef HAVE_TIMESTAMPS
if (F_ISSET(txn, WT_TXN_HAS_TS_COMMIT) &&
op->type != WT_TXN_OP_BASIC_TS) {
WT_ASSERT(session,
op->fileid != WT_METAFILE_ID);
__wt_timestamp_set(&op->u.upd->timestamp,
&txn->commit_timestamp);
}
#endif
break;
case WT_TXN_OP_REF:
#ifdef HAVE_TIMESTAMPS
if (F_ISSET(txn, WT_TXN_HAS_TS_COMMIT))
__wt_timestamp_set(
&op->u.ref->page_del->timestamp,
&txn->commit_timestamp);
#endif
break;
case WT_TXN_OP_TRUNCATE_COL:
case WT_TXN_OP_TRUNCATE_ROW:
/* Other operations don't need timestamps. */
break;
}
__wt_txn_op_free(session, op);
}
txn->mod_count = 0;
#ifdef HAVE_TIMESTAMPS
/*
* Track the largest commit timestamp we have seen.
*
* We don't actually clear the local commit timestamp, just the flag.
* That said, we can't update the global commit timestamp until this
* transaction is visible, which happens when we release it.
*/
update_timestamp = F_ISSET(txn, WT_TXN_HAS_TS_COMMIT);
#endif
__wt_txn_release(session);
if (locked)
__wt_readunlock(session, &txn_global->visibility_rwlock);
#ifdef HAVE_TIMESTAMPS
/* First check if we've already committed something in the future. */
if (update_timestamp) {
WT_WITH_TIMESTAMP_READLOCK(session, &txn_global->rwlock,
__wt_timestamp_set(
&prev_commit_timestamp, &txn_global->commit_timestamp));
update_timestamp = __wt_timestamp_cmp(
&txn->commit_timestamp, &prev_commit_timestamp) > 0;
}
/*
* If it looks like we need to move the global commit timestamp,
* write lock and re-check.
*/
if (update_timestamp) {
#if WT_TIMESTAMP_SIZE == 8
while (__wt_timestamp_cmp(
&txn->commit_timestamp, &prev_commit_timestamp) > 0) {
if (__wt_atomic_cas64(
&txn_global->commit_timestamp.val,
prev_commit_timestamp.val,
txn->commit_timestamp.val)) {
txn_global->has_commit_timestamp = true;
break;
}
__wt_timestamp_set(
&prev_commit_timestamp, &txn_global->commit_timestamp);
}
#else
__wt_writelock(session, &txn_global->rwlock);
if (__wt_timestamp_cmp(&txn->commit_timestamp,
&txn_global->commit_timestamp) > 0) {
__wt_timestamp_set(&txn_global->commit_timestamp,
&txn->commit_timestamp);
txn_global->has_commit_timestamp = true;
}
__wt_writeunlock(session, &txn_global->rwlock);
#endif
}
#endif
/*
* We're between transactions, if we need to block for eviction, it's
* a good time to do so. Note that we must ignore any error return
* because the user's data is committed.
*/
if (!readonly)
(void)__wt_cache_eviction_check(session, false, false, NULL);
return (0);
err: /*
* If anything went wrong, roll back.
*
* !!!
* Nothing can fail after this point.
*/
if (locked)
__wt_readunlock(session, &txn_global->visibility_rwlock);
WT_TRET(__wt_txn_rollback(session, cfg));
return (ret);
}
/*
* __wt_txn_rollback --
* Roll back the current transaction.
*/
int
__wt_txn_rollback(WT_SESSION_IMPL *session, const char *cfg[])
{
WT_DECL_RET;
WT_TXN *txn;
WT_TXN_OP *op;
u_int i;
bool readonly;
WT_UNUSED(cfg);
txn = &session->txn;
readonly = txn->mod_count == 0;
WT_ASSERT(session, F_ISSET(txn, WT_TXN_RUNNING));
/* Rollback notification. */
if (txn->notify != NULL)
WT_TRET(txn->notify->notify(txn->notify, (WT_SESSION *)session,
txn->id, 0));
/* Rollback updates. */
for (i = 0, op = txn->mod; i < txn->mod_count; i++, op++) {
/* Metadata updates are never rolled back. */
if (op->fileid == WT_METAFILE_ID)
continue;
switch (op->type) {
case WT_TXN_OP_BASIC:
case WT_TXN_OP_BASIC_TS:
case WT_TXN_OP_INMEM:
WT_ASSERT(session, op->u.upd->txnid == txn->id);
WT_ASSERT(session,
S2C(session)->cache->las_fileid == 0 ||
op->fileid != S2C(session)->cache->las_fileid);
op->u.upd->txnid = WT_TXN_ABORTED;
break;
case WT_TXN_OP_REF:
__wt_delete_page_rollback(session, op->u.ref);
break;
case WT_TXN_OP_TRUNCATE_COL:
case WT_TXN_OP_TRUNCATE_ROW:
/*
* Nothing to do: these operations are only logged for
* recovery. The in-memory changes will be rolled back
* with a combination of WT_TXN_OP_REF and
* WT_TXN_OP_INMEM operations.
*/
break;
}
/* Free any memory allocated for the operation. */
__wt_txn_op_free(session, op);
}
txn->mod_count = 0;
__wt_txn_release(session);
/*
* We're between transactions, if we need to block for eviction, it's
* a good time to do so. Note that we must ignore any error return
* because the user's data is committed.
*/
if (!readonly)
(void)__wt_cache_eviction_check(session, false, false, NULL);
return (ret);
}
/*
* __wt_page_in_func --
* Acquire a hazard pointer to a page; if the page is not in-memory,
* read it from the disk and build an in-memory version.
*/
int
__wt_page_in_func(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags
#ifdef HAVE_DIAGNOSTIC
, const char *file, int line
#endif
)
{
WT_BTREE *btree;
WT_DECL_RET;
WT_PAGE *page;
u_int sleep_cnt, wait_cnt;
bool busy, cache_work, evict_soon, stalled;
int force_attempts;
btree = S2BT(session);
/*
* Ignore reads of pages already known to be in cache, otherwise the
* eviction server can dominate these statistics.
*/
if (!LF_ISSET(WT_READ_CACHE)) {
WT_STAT_FAST_CONN_INCR(session, cache_pages_requested);
WT_STAT_FAST_DATA_INCR(session, cache_pages_requested);
}
for (evict_soon = stalled = false,
force_attempts = 0, sleep_cnt = wait_cnt = 0;;) {
switch (ref->state) {
case WT_REF_DELETED:
if (LF_ISSET(WT_READ_NO_EMPTY) &&
__wt_delete_page_skip(session, ref, false))
return (WT_NOTFOUND);
/* FALLTHROUGH */
case WT_REF_DISK:
if (LF_ISSET(WT_READ_CACHE))
return (WT_NOTFOUND);
/*
* The page isn't in memory, read it. If this thread is
* allowed to do eviction work, check for space in the
* cache.
*/
if (!LF_ISSET(WT_READ_NO_EVICT))
WT_RET(__wt_cache_eviction_check(
session, 1, NULL));
WT_RET(__page_read(session, ref));
/*
* If configured to not trash the cache, leave the page
* generation unset, we'll set it before returning to
* the oldest read generation, so the page is forcibly
* evicted as soon as possible. We don't do that set
* here because we don't want to evict the page before
* we "acquire" it.
*/
evict_soon = LF_ISSET(WT_READ_WONT_NEED) ||
F_ISSET(session, WT_SESSION_NO_CACHE);
continue;
case WT_REF_READING:
if (LF_ISSET(WT_READ_CACHE))
return (WT_NOTFOUND);
if (LF_ISSET(WT_READ_NO_WAIT))
return (WT_NOTFOUND);
/* Waiting on another thread's read, stall. */
WT_STAT_FAST_CONN_INCR(session, page_read_blocked);
stalled = true;
break;
case WT_REF_LOCKED:
if (LF_ISSET(WT_READ_NO_WAIT))
return (WT_NOTFOUND);
/* Waiting on eviction, stall. */
WT_STAT_FAST_CONN_INCR(session, page_locked_blocked);
stalled = true;
break;
case WT_REF_SPLIT:
return (WT_RESTART);
case WT_REF_MEM:
/*
* The page is in memory.
*
* Get a hazard pointer if one is required. We cannot
* be evicting if no hazard pointer is required, we're
* done.
*/
if (F_ISSET(btree, WT_BTREE_IN_MEMORY))
goto skip_evict;
/*
* The expected reason we can't get a hazard pointer is
* because the page is being evicted, yield, try again.
*/
#ifdef HAVE_DIAGNOSTIC
WT_RET(
__wt_hazard_set(session, ref, &busy, file, line));
#else
WT_RET(__wt_hazard_set(session, ref, &busy));
#endif
if (busy) {
WT_STAT_FAST_CONN_INCR(
session, page_busy_blocked);
break;
}
/*
* If eviction is configured for this file, check to see
* if the page qualifies for forced eviction and update
* the page's generation number. If eviction isn't being
* done on this file, we're done.
* In-memory split of large pages is allowed while
* no_eviction is set on btree, whereas reconciliation
* is not allowed.
*/
if (LF_ISSET(WT_READ_NO_EVICT) ||
F_ISSET(session, WT_SESSION_NO_EVICTION) ||
(F_ISSET(btree, WT_BTREE_NO_EVICTION) &&
!F_ISSET(btree, WT_BTREE_NO_RECONCILE)))
goto skip_evict;
/*
* Forcibly evict pages that are too big.
*/
if (force_attempts < 10 &&
__evict_force_check(session, ref)) {
++force_attempts;
ret = __wt_page_release_evict(session, ref);
/* If forced eviction fails, stall. */
if (ret == EBUSY) {
ret = 0;
WT_STAT_FAST_CONN_INCR(session,
page_forcible_evict_blocked);
stalled = true;
break;
}
WT_RET(ret);
/*
* The result of a successful forced eviction
* is a page-state transition (potentially to
* an in-memory page we can use, or a restart
* return for our caller), continue the outer
* page-acquisition loop.
*/
continue;
}
/*
* If we read the page and are configured to not trash
* the cache, and no other thread has already used the
* page, set the oldest read generation so the page is
* forcibly evicted as soon as possible.
*
* Otherwise, if we read the page, or, if configured to
* update the page's read generation and the page isn't
* already flagged for forced eviction, update the page
* read generation.
*/
page = ref->page;
if (page->read_gen == WT_READGEN_NOTSET) {
if (evict_soon)
__wt_page_evict_soon(session, ref);
else
__wt_cache_read_gen_new(session, page);
} else if (!LF_ISSET(WT_READ_NO_GEN))
__wt_cache_read_gen_bump(session, page);
skip_evict:
/*
* Check if we need an autocommit transaction.
* Starting a transaction can trigger eviction, so skip
* it if eviction isn't permitted.
*/
return (LF_ISSET(WT_READ_NO_EVICT) ? 0 :
__wt_txn_autocommit_check(session));
WT_ILLEGAL_VALUE(session);
}
/*
* We failed to get the page -- yield before retrying, and if
* we've yielded enough times, start sleeping so we don't burn
* CPU to no purpose.
*/
if (stalled)
wait_cnt += WT_THOUSAND;
else if (++wait_cnt < WT_THOUSAND) {
__wt_yield();
continue;
}
/*
* If stalling and this thread is allowed to do eviction work,
* check if the cache needs help. If we do work for the cache,
* substitute that for a sleep.
*/
if (!LF_ISSET(WT_READ_NO_EVICT)) {
WT_RET(
__wt_cache_eviction_check(session, 1, &cache_work));
if (cache_work)
continue;
}
sleep_cnt = WT_MIN(sleep_cnt + WT_THOUSAND, 10000);
WT_STAT_FAST_CONN_INCRV(session, page_sleep, sleep_cnt);
__wt_sleep(0, sleep_cnt);
}
}
