/*
* __wt_async_op_enqueue --
* Enqueue an operation onto the work queue.
*/
int
__wt_async_op_enqueue(WT_SESSION_IMPL *session, WT_ASYNC_OP_IMPL *op)
{
WT_ASYNC *async;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
uint64_t cur_head, cur_tail, my_alloc, my_slot;
#ifdef HAVE_DIAGNOSTIC
WT_ASYNC_OP_IMPL *my_op;
#endif
conn = S2C(session);
async = conn->async;
/*
* If an application re-uses a WT_ASYNC_OP, we end up here with an
* invalid object.
*/
if (op->state != WT_ASYNCOP_READY)
WT_RET_MSG(session, EINVAL,
"application error: WT_ASYNC_OP already in use");
/*
* Enqueue op at the tail of the work queue.
* We get our slot in the ring buffer to use.
*/
my_alloc = WT_ATOMIC_ADD8(async->alloc_head, 1);
my_slot = my_alloc % async->async_qsize;
/*
* Make sure we haven't wrapped around the queue.
* If so, wait for the tail to advance off this slot.
*/
WT_ORDERED_READ(cur_tail, async->tail_slot);
while (cur_tail == my_slot) {
__wt_yield();
WT_ORDERED_READ(cur_tail, async->tail_slot);
}
#ifdef HAVE_DIAGNOSTIC
WT_ORDERED_READ(my_op, async->async_queue[my_slot]);
if (my_op != NULL)
return (__wt_panic(session));
#endif
WT_PUBLISH(async->async_queue[my_slot], op);
op->state = WT_ASYNCOP_ENQUEUED;
if (WT_ATOMIC_ADD4(async->cur_queue, 1) > async->max_queue)
WT_PUBLISH(async->max_queue, async->cur_queue);
/*
* Multiple threads may be adding ops to the queue. We need to wait
* our turn to make our slot visible to workers.
*/
WT_ORDERED_READ(cur_head, async->head);
while (cur_head != (my_alloc - 1)) {
__wt_yield();
WT_ORDERED_READ(cur_head, async->head);
}
WT_PUBLISH(async->head, my_alloc);
return (ret);
}
/*
* __wt_log_slot_release --
* Each thread in a consolidated group releases its portion to
* signal it has completed writing its piece of the log.
*/
int64_t
__wt_log_slot_release(WT_LOGSLOT *slot, uint64_t size)
{
int64_t newsize;
/*
* Add my size into the state. When it reaches WT_LOG_SLOT_DONE
* all participatory threads have completed copying their piece.
*/
newsize = WT_ATOMIC_ADD8(slot->slot_state, (int64_t)size);
return (newsize);
}
/*
* __wt_page_alloc --
* Create or read a page into the cache.
*/
int
__wt_page_alloc(WT_SESSION_IMPL *session, uint8_t type,
uint64_t recno, uint32_t alloc_entries, int alloc_refs, WT_PAGE **pagep)
{
WT_CACHE *cache;
WT_DECL_RET;
WT_PAGE *page;
WT_PAGE_INDEX *pindex;
size_t size;
uint32_t i;
void *p;
*pagep = NULL;
cache = S2C(session)->cache;
page = NULL;
size = sizeof(WT_PAGE);
switch (type) {
case WT_PAGE_COL_FIX:
case WT_PAGE_COL_INT:
case WT_PAGE_ROW_INT:
break;
case WT_PAGE_COL_VAR:
/*
* Variable-length column-store leaf page: allocate memory to
* describe the page's contents with the initial allocation.
*/
size += alloc_entries * sizeof(WT_COL);
break;
case WT_PAGE_ROW_LEAF:
/*
* Row-store leaf page: allocate memory to describe the page's
* contents with the initial allocation.
*/
size += alloc_entries * sizeof(WT_ROW);
break;
WT_ILLEGAL_VALUE(session);
}
WT_RET(__wt_calloc(session, 1, size, &page));
page->type = type;
page->read_gen = WT_READGEN_NOTSET;
switch (type) {
case WT_PAGE_COL_FIX:
page->pg_fix_recno = recno;
page->pg_fix_entries = alloc_entries;
break;
case WT_PAGE_COL_INT:
case WT_PAGE_ROW_INT:
page->pg_intl_recno = recno;
/*
* Internal pages have an array of references to objects so they
* can split. Allocate the array of references and optionally,
* the objects to which they point.
*/
WT_ERR(__wt_calloc(session, 1,
sizeof(WT_PAGE_INDEX) + alloc_entries * sizeof(WT_REF *),
&p));
size +=
sizeof(WT_PAGE_INDEX) + alloc_entries * sizeof(WT_REF *);
pindex = p;
pindex->index = (WT_REF **)((WT_PAGE_INDEX *)p + 1);
pindex->entries = alloc_entries;
WT_INTL_INDEX_SET(page, pindex);
if (alloc_refs)
for (i = 0; i < pindex->entries; ++i) {
WT_ERR(__wt_calloc_def(
session, 1, &pindex->index[i]));
size += sizeof(WT_REF);
}
if (0) {
err: if ((pindex = WT_INTL_INDEX_COPY(page)) != NULL) {
for (i = 0; i < pindex->entries; ++i)
__wt_free(session, pindex->index[i]);
__wt_free(session, pindex);
}
__wt_free(session, page);
return (ret);
}
break;
case WT_PAGE_COL_VAR:
page->pg_var_recno = recno;
page->pg_var_d = (WT_COL *)((uint8_t *)page + sizeof(WT_PAGE));
page->pg_var_entries = alloc_entries;
break;
case WT_PAGE_ROW_LEAF:
page->pg_row_d = (WT_ROW *)((uint8_t *)page + sizeof(WT_PAGE));
page->pg_row_entries = alloc_entries;
break;
WT_ILLEGAL_VALUE(session);
}
/* Increment the cache statistics. */
__wt_cache_page_inmem_incr(session, page, size);
(void)WT_ATOMIC_ADD8(cache->pages_inmem, 1);
*pagep = page;
return (0);
}
