/*
* __log_slot_close --
* Close out the slot the caller is using. The slot may already be
* closed or freed by another thread.
*/
static int
__log_slot_close(
WT_SESSION_IMPL *session, WT_LOGSLOT *slot, bool *releasep, bool forced)
{
WT_CONNECTION_IMPL *conn;
WT_LOG *log;
int64_t end_offset, new_state, old_state;
#ifdef HAVE_DIAGNOSTIC
uint64_t time_start, time_stop;
int count;
#endif
*releasep = false;
WT_ASSERT(session, F_ISSET(session, WT_SESSION_LOCKED_SLOT));
conn = S2C(session);
log = conn->log;
if (slot == NULL)
return (WT_NOTFOUND);
retry:
old_state = slot->slot_state;
/*
* If this close is coming from a forced close and a thread is in
* the middle of using the slot, return EBUSY. The caller can
* decide if retrying is necessary or not.
*/
if (forced && WT_LOG_SLOT_INPROGRESS(old_state))
return (__wt_set_return(session, EBUSY));
/*
* If someone else is switching out this slot we lost. Nothing to
* do but return. Return WT_NOTFOUND anytime the given slot was
* processed by another closing thread. Only return 0 when we
* actually closed the slot.
*/
if (WT_LOG_SLOT_CLOSED(old_state)) {
WT_STAT_CONN_INCR(session, log_slot_close_race);
return (WT_NOTFOUND);
}
/*
* If someone completely processed this slot, we're done.
*/
if (FLD_LOG_SLOT_ISSET(
(uint64_t)slot->slot_state, WT_LOG_SLOT_RESERVED)) {
WT_STAT_CONN_INCR(session, log_slot_close_race);
return (WT_NOTFOUND);
}
new_state = (old_state | WT_LOG_SLOT_CLOSE);
/*
* Close this slot. If we lose the race retry.
*/
if (!__wt_atomic_casiv64(&slot->slot_state, old_state, new_state))
goto retry;
/*
* We own the slot now. No one else can join.
* Set the end LSN.
*/
WT_STAT_CONN_INCR(session, log_slot_closes);
if (WT_LOG_SLOT_DONE(new_state))
*releasep = true;
slot->slot_end_lsn = slot->slot_start_lsn;
/*
* A thread setting the unbuffered flag sets the unbuffered size after
* setting the flag. There could be a delay between a thread setting
* the flag, a thread closing the slot, and the original thread setting
* that value. If the state is unbuffered, wait for the unbuffered
* size to be set.
*/
#ifdef HAVE_DIAGNOSTIC
count = 0;
time_start = __wt_clock(session);
#endif
if (WT_LOG_SLOT_UNBUFFERED_ISSET(old_state)) {
while (slot->slot_unbuffered == 0) {
WT_STAT_CONN_INCR(session, log_slot_close_unbuf);
__wt_yield();
#ifdef HAVE_DIAGNOSTIC
++count;
if (count > WT_MILLION) {
time_stop = __wt_clock(session);
if (WT_CLOCKDIFF_SEC(
time_stop, time_start) > 10) {
__wt_errx(session, "SLOT_CLOSE: Slot %"
PRIu32 " Timeout unbuffered, state 0x%"
PRIx64 " unbuffered %" PRId64,
(uint32_t)(slot - &log->slot_pool[0]),
(uint64_t)slot->slot_state,
slot->slot_unbuffered);
__log_slot_dump(session);
__wt_abort(session);
}
count = 0;
}
#endif
}
}
end_offset =
WT_LOG_SLOT_JOINED_BUFFERED(old_state) + slot->slot_unbuffered;
slot->slot_end_lsn.l.offset += (uint32_t)end_offset;
WT_STAT_CONN_INCRV(session, log_slot_consolidated, end_offset);
/*
* XXX Would like to change so one piece of code advances the LSN.
*/
log->alloc_lsn = slot->slot_end_lsn;
WT_ASSERT(session, log->alloc_lsn.l.file >= log->write_lsn.l.file);
return (0);
}
/*
* __log_slot_close --
* Close out the slot the caller is using. The slot may already be
* closed or freed by another thread.
*/
static int
__log_slot_close(
WT_SESSION_IMPL *session, WT_LOGSLOT *slot, bool *releasep, bool forced)
{
WT_CONNECTION_IMPL *conn;
WT_LOG *log;
int64_t end_offset, new_state, old_state;
WT_ASSERT(session, F_ISSET(session, WT_SESSION_LOCKED_SLOT));
WT_ASSERT(session, releasep != NULL);
conn = S2C(session);
log = conn->log;
*releasep = 0;
if (slot == NULL)
return (WT_NOTFOUND);
retry:
old_state = slot->slot_state;
/*
* If this close is coming from a forced close and a thread is in
* the middle of using the slot, return EBUSY. The caller can
* decide if retrying is necessary or not.
*/
if (forced && WT_LOG_SLOT_INPROGRESS(old_state))
return (EBUSY);
/*
* If someone else is switching out this slot we lost. Nothing to
* do but return. Return WT_NOTFOUND anytime the given slot was
* processed by another closing thread. Only return 0 when we
* actually closed the slot.
*/
if (WT_LOG_SLOT_CLOSED(old_state))
return (WT_NOTFOUND);
/*
* If someone completely processed this slot, we're done.
*/
if (FLD64_ISSET((uint64_t)slot->slot_state, WT_LOG_SLOT_RESERVED))
return (WT_NOTFOUND);
new_state = (old_state | WT_LOG_SLOT_CLOSE);
/*
* Close this slot. If we lose the race retry.
*/
if (!__wt_atomic_casiv64(&slot->slot_state, old_state, new_state))
goto retry;
/*
* We own the slot now. No one else can join.
* Set the end LSN.
*/
WT_STAT_FAST_CONN_INCR(session, log_slot_closes);
if (WT_LOG_SLOT_DONE(new_state))
*releasep = 1;
slot->slot_end_lsn = slot->slot_start_lsn;
end_offset =
WT_LOG_SLOT_JOINED_BUFFERED(old_state) + slot->slot_unbuffered;
slot->slot_end_lsn.offset += (wt_off_t)end_offset;
WT_STAT_FAST_CONN_INCRV(session,
log_slot_consolidated, end_offset);
/*
* XXX Would like to change so one piece of code advances the LSN.
*/
log->alloc_lsn = slot->slot_end_lsn;
WT_ASSERT(session, log->alloc_lsn.file >= log->write_lsn.file);
return (0);
}
/*
* __wt_log_slot_join --
* Join a consolidated logging slot.
*/
void
__wt_log_slot_join(WT_SESSION_IMPL *session, uint64_t mysize,
uint32_t flags, WT_MYSLOT *myslot)
{
WT_CONNECTION_IMPL *conn;
WT_LOG *log;
WT_LOGSLOT *slot;
uint64_t time_start, time_stop, usecs;
int64_t flag_state, new_state, old_state, released;
int32_t join_offset, new_join, wait_cnt;
bool closed, diag_yield, raced, slept, unbuffered, yielded;
conn = S2C(session);
log = conn->log;
time_start = time_stop = 0;
WT_ASSERT(session, !F_ISSET(session, WT_SESSION_LOCKED_SLOT));
WT_ASSERT(session, mysize != 0);
/*
* There should almost always be a slot open.
*/
unbuffered = yielded = false;
closed = raced = slept = false;
wait_cnt = 0;
#ifdef HAVE_DIAGNOSTIC
diag_yield = (++log->write_calls % 7) == 0;
if ((log->write_calls % WT_THOUSAND) == 0 ||
mysize > WT_LOG_SLOT_BUF_MAX) {
#else
diag_yield = false;
if (mysize > WT_LOG_SLOT_BUF_MAX) {
#endif
unbuffered = true;
F_SET(myslot, WT_MYSLOT_UNBUFFERED);
}
for (;;) {
WT_BARRIER();
slot = log->active_slot;
old_state = slot->slot_state;
if (WT_LOG_SLOT_OPEN(old_state)) {
/*
* Try to join our size into the existing size and
* atomically write it back into the state.
*/
flag_state = WT_LOG_SLOT_FLAGS(old_state);
released = WT_LOG_SLOT_RELEASED(old_state);
join_offset = WT_LOG_SLOT_JOINED(old_state);
if (unbuffered)
new_join = join_offset + WT_LOG_SLOT_UNBUFFERED;
else
new_join = join_offset + (int32_t)mysize;
new_state = (int64_t)WT_LOG_SLOT_JOIN_REL(
(int64_t)new_join, (int64_t)released,
(int64_t)flag_state);
/*
* Braces used due to potential empty body warning.
*/
if (diag_yield) {
WT_DIAGNOSTIC_YIELD;
}
/*
* Attempt to swap our size into the state.
*/
if (__wt_atomic_casiv64(
&slot->slot_state, old_state, new_state))
break;
WT_STAT_CONN_INCR(session, log_slot_races);
raced = true;
} else {
WT_STAT_CONN_INCR(session, log_slot_active_closed);
closed = true;
++wait_cnt;
}
if (!yielded)
time_start = __wt_clock(session);
yielded = true;
/*
* The slot is no longer open or we lost the race to
* update it. Yield and try again.
*/
if (wait_cnt < WT_THOUSAND)
__wt_yield();
else {
__wt_sleep(0, WT_THOUSAND);
slept = true;
}
}
/*
* We joined this slot. Fill in our information to return to
* the caller.
*/
if (!yielded)
WT_STAT_CONN_INCR(session, log_slot_immediate);
else {
WT_STAT_CONN_INCR(session, log_slot_yield);
time_stop = __wt_clock(session);
usecs = WT_CLOCKDIFF_US(time_stop, time_start);
WT_STAT_CONN_INCRV(session, log_slot_yield_duration, usecs);
if (closed)
WT_STAT_CONN_INCR(session, log_slot_yield_close);
if (raced)
WT_STAT_CONN_INCR(session, log_slot_yield_race);
if (slept)
WT_STAT_CONN_INCR(session, log_slot_yield_sleep);
}
if (LF_ISSET(WT_LOG_DSYNC | WT_LOG_FSYNC))
F_SET(slot, WT_SLOT_SYNC_DIR);
if (LF_ISSET(WT_LOG_FLUSH))
F_SET(slot, WT_SLOT_FLUSH);
if (LF_ISSET(WT_LOG_FSYNC))
F_SET(slot, WT_SLOT_SYNC);
if (F_ISSET(myslot, WT_MYSLOT_UNBUFFERED)) {
WT_ASSERT(session, slot->slot_unbuffered == 0);
WT_STAT_CONN_INCR(session, log_slot_unbuffered);
slot->slot_unbuffered = (int64_t)mysize;
}
myslot->slot = slot;
myslot->offset = join_offset;
myslot->end_offset = (wt_off_t)((uint64_t)join_offset + mysize);
}
/*
* __wt_log_slot_release --
* Each thread in a consolidated group releases its portion to
* signal it has completed copying its piece of the log into
* the memory buffer.
*/
int64_t
__wt_log_slot_release(WT_MYSLOT *myslot, int64_t size)
{
WT_LOGSLOT *slot;
wt_off_t cur_offset, my_start;
int64_t my_size, rel_size;
slot = myslot->slot;
my_start = slot->slot_start_offset + myslot->offset;
/*
* We maintain the last starting offset within this slot.
* This is used to know the offset of the last record that
* was written rather than the beginning record of the slot.
*/
while ((cur_offset = slot->slot_last_offset) < my_start) {
/*
* Set our offset if we are larger.
*/
if (__wt_atomic_casiv64(
&slot->slot_last_offset, cur_offset, my_start))
break;
/*
* If we raced another thread updating this, try again.
*/
WT_BARRIER();
}
/*
* Add my size into the state and return the new size.
*/
rel_size = size;
if (F_ISSET(myslot, WT_MYSLOT_UNBUFFERED))
rel_size = WT_LOG_SLOT_UNBUFFERED;
my_size = (int64_t)WT_LOG_SLOT_JOIN_REL((int64_t)0, rel_size, 0);
return (__wt_atomic_addiv64(&slot->slot_state, my_size));
}
/*
* __wt_log_slot_join --
* Join a consolidated logging slot. Must be called with
* the read lock held.
*/
void
__wt_log_slot_join(WT_SESSION_IMPL *session, uint64_t mysize,
uint32_t flags, WT_MYSLOT *myslot)
{
WT_CONNECTION_IMPL *conn;
WT_LOG *log;
WT_LOGSLOT *slot;
int64_t flag_state, new_state, old_state, released;
int32_t join_offset, new_join;
#ifdef HAVE_DIAGNOSTIC
bool unbuf_force;
#endif
conn = S2C(session);
log = conn->log;
/*
* Make sure the length cannot overflow. The caller should not
* even call this function if it doesn't fit but use direct
* writes.
*/
WT_ASSERT(session, !F_ISSET(session, WT_SESSION_LOCKED_SLOT));
/*
* There should almost always be a slot open.
*/
#ifdef HAVE_DIAGNOSTIC
unbuf_force = (++log->write_calls % 1000) == 0;
#endif
for (;;) {
WT_BARRIER();
slot = log->active_slot;
old_state = slot->slot_state;
/*
* Try to join our size into the existing size and
* atomically write it back into the state.
*/
flag_state = WT_LOG_SLOT_FLAGS(old_state);
released = WT_LOG_SLOT_RELEASED(old_state);
join_offset = WT_LOG_SLOT_JOINED(old_state);
#ifdef HAVE_DIAGNOSTIC
if (unbuf_force || mysize > WT_LOG_SLOT_BUF_MAX) {
#else
if (mysize > WT_LOG_SLOT_BUF_MAX) {
#endif
new_join = join_offset + WT_LOG_SLOT_UNBUFFERED;
F_SET(myslot, WT_MYSLOT_UNBUFFERED);
myslot->slot = slot;
} else
new_join = join_offset + (int32_t)mysize;
new_state = (int64_t)WT_LOG_SLOT_JOIN_REL(
(int64_t)new_join, (int64_t)released, (int64_t)flag_state);
/*
* Check if the slot is open for joining and we are able to
* swap in our size into the state.
*/
if (WT_LOG_SLOT_OPEN(old_state) &&
__wt_atomic_casiv64(
&slot->slot_state, old_state, new_state))
break;
/*
* The slot is no longer open or we lost the race to
* update it. Yield and try again.
*/
WT_STAT_FAST_CONN_INCR(session, log_slot_races);
__wt_yield();
}
/*
* We joined this slot. Fill in our information to return to
* the caller.
*/
if (mysize != 0)
WT_STAT_FAST_CONN_INCR(session, log_slot_joins);
if (LF_ISSET(WT_LOG_DSYNC | WT_LOG_FSYNC))
F_SET(slot, WT_SLOT_SYNC_DIR);
if (LF_ISSET(WT_LOG_FLUSH))
F_SET(slot, WT_SLOT_FLUSH);
if (LF_ISSET(WT_LOG_FSYNC))
F_SET(slot, WT_SLOT_SYNC);
if (F_ISSET(myslot, WT_MYSLOT_UNBUFFERED)) {
WT_ASSERT(session, slot->slot_unbuffered == 0);
WT_STAT_FAST_CONN_INCR(session, log_slot_unbuffered);
slot->slot_unbuffered = (int64_t)mysize;
}
myslot->slot = slot;
myslot->offset = join_offset;
myslot->end_offset = (wt_off_t)((uint64_t)join_offset + mysize);
}
/*
* __wt_log_slot_release --
* Each thread in a consolidated group releases its portion to
* signal it has completed copying its piece of the log into
* the memory buffer.
*/
int64_t
__wt_log_slot_release(WT_SESSION_IMPL *session, WT_MYSLOT *myslot, int64_t size)
{
WT_LOGSLOT *slot;
wt_off_t cur_offset, my_start;
int64_t my_size, rel_size;
WT_UNUSED(session);
slot = myslot->slot;
my_start = slot->slot_start_offset + myslot->offset;
while ((cur_offset = slot->slot_last_offset) < my_start) {
/*
* Set our offset if we are larger.
*/
if (__wt_atomic_casiv64(
&slot->slot_last_offset, cur_offset, my_start))
break;
/*
* If we raced another thread updating this, try again.
*/
WT_BARRIER();
}
/*
* Add my size into the state and return the new size.
*/
rel_size = size;
if (F_ISSET(myslot, WT_MYSLOT_UNBUFFERED))
rel_size = WT_LOG_SLOT_UNBUFFERED;
my_size = (int64_t)WT_LOG_SLOT_JOIN_REL((int64_t)0, rel_size, 0);
return (__wt_atomic_addiv64(&slot->slot_state, my_size));
}
