greg/wterl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
wterl/c_src/async_nif.h

468 lines
20 KiB
C
Raw Normal View History

Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
/*
* async_nif: An async thread-pool layer for Erlang's NIF API
*
* Copyright (c) 2012 Basho Technologies, Inc. All Rights Reserved.
* Author: Gregory Burd <greg@basho.com> <greg@burd.me>
*
* This file is provided to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain
* a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
#ifndef __ASYNC_NIF_H__
#define __ASYNC_NIF_H__
#if defined(__cplusplus)
extern "C" {
#endif
A bit of cleanup
2013-04-14 23:33:14 +00:00
#ifdef ASYNC_NIF_STATS
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
#include "stats.h" // TODO: measure, measure... measure again
A bit of cleanup
2013-04-14 23:33:14 +00:00
#endif
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
#define ASYNC_NIF_MAX_WORKERS 128
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
#define ASYNC_NIF_WORKER_QUEUE_SIZE 500
#define FIFO_QUEUE_TYPE(name) \
struct fifo_q__ ## name *
#define DECL_FIFO_QUEUE(name, type) \
struct fifo_q__ ## name { \
unsigned int h, t, s; \
Return to alloc'ed requests because there may be many more in flight than those in the various queues. Reenable the (still failing) truncate tests (because they don't SEGV anymore). Still might be a memory leak, next up is valgrind.
2013-04-15 21:37:14 +00:00
type *items[]; \
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
}; \
static struct fifo_q__ ## name *fifo_q_ ## name ## _new(unsigned int n) { \
Return to alloc'ed requests because there may be many more in flight than those in the various queues. Reenable the (still failing) truncate tests (because they don't SEGV anymore). Still might be a memory leak, next up is valgrind.
2013-04-15 21:37:14 +00:00
int sz = sizeof(struct fifo_q__ ## name) + ((n+1) * sizeof(type *));\
struct fifo_q__ ## name *q = enif_alloc(sz); \
if (!q) \
return 0; \
memset(q, 0, sz); \
q->s = n + 1; \
return q; \
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
} \
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
static inline type *fifo_q_ ## name ## _put(struct fifo_q__ ## name *q, type *n) { \
Return to alloc'ed requests because there may be many more in flight than those in the various queues. Reenable the (still failing) truncate tests (because they don't SEGV anymore). Still might be a memory leak, next up is valgrind.
2013-04-15 21:37:14 +00:00
q->items[q->h] = n; \
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
q->h = (q->h + 1) % q->s; \
Return to alloc'ed requests because there may be many more in flight than those in the various queues. Reenable the (still failing) truncate tests (because they don't SEGV anymore). Still might be a memory leak, next up is valgrind.
2013-04-15 21:37:14 +00:00
return n; \
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
} \
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
static inline type *fifo_q_ ## name ## _get(struct fifo_q__ ## name *q) { \
Return to alloc'ed requests because there may be many more in flight than those in the various queues. Reenable the (still failing) truncate tests (because they don't SEGV anymore). Still might be a memory leak, next up is valgrind.
2013-04-15 21:37:14 +00:00
type *n = q->items[q->t]; \
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
q->items[q->t] = 0; \
q->t = (q->t + 1) % q->s; \
Return to alloc'ed requests because there may be many more in flight than those in the various queues. Reenable the (still failing) truncate tests (because they don't SEGV anymore). Still might be a memory leak, next up is valgrind.
2013-04-15 21:37:14 +00:00
return n; \
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
} \
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
static inline void fifo_q_ ## name ## _free(struct fifo_q__ ## name *q) { \
memset(q, 0, sizeof(struct fifo_q__ ## name) + (q->s * sizeof(type *))); \
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
enif_free(q); \
} \
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
static inline unsigned int fifo_q_ ## name ## _size(struct fifo_q__ ## name *q) { \
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
return (q->h - q->t + q->s) % q->s; \
} \
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
static inline unsigned int fifo_q_ ## name ## _capacity(struct fifo_q__ ## name *q) { \
Return to alloc'ed requests because there may be many more in flight than those in the various queues. Reenable the (still failing) truncate tests (because they don't SEGV anymore). Still might be a memory leak, next up is valgrind.
2013-04-15 21:37:14 +00:00
return q->s - 1; \
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
} \
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
static inline int fifo_q_ ## name ## _empty(struct fifo_q__ ## name *q) { \
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
return (q->t == q->h); \
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
} \
static inline int fifo_q_ ## name ## _full(struct fifo_q__ ## name *q) { \
return ((q->h + 1) % q->s) == q->t; \
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
}
#define fifo_q_new(name, size) fifo_q_ ## name ## _new(size)
#define fifo_q_free(name, queue) fifo_q_ ## name ## _free(queue)
#define fifo_q_get(name, queue) fifo_q_ ## name ## _get(queue)
#define fifo_q_put(name, queue, item) fifo_q_ ## name ## _put(queue, item)
#define fifo_q_size(name, queue) fifo_q_ ## name ## _size(queue)
#define fifo_q_capacity(name, queue) fifo_q_ ## name ## _capacity(queue)
#define fifo_q_empty(name, queue) fifo_q_ ## name ## _empty(queue)
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
#define fifo_q_full(name, queue) fifo_q_ ## name ## _full(queue)
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
#define fifo_q_foreach(name, queue, item, task) do { \
while((item = fifo_q_ ## name ## _get(queue)) != NULL) { \
do task while(0); \
} \
} while(0);
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
struct async_nif_req_entry {
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
ERL_NIF_TERM ref;
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
ErlNifEnv *env;
ErlNifPid pid;
void *args;
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
void (*fn_work)(ErlNifEnv*, ERL_NIF_TERM, ErlNifPid*, unsigned int, void *);
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
void (*fn_post)(void *);
};
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
DECL_FIFO_QUEUE(reqs, struct async_nif_req_entry);
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
struct async_nif_work_queue {
ErlNifMutex *reqs_mutex;
ErlNifCond *reqs_cnd;
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
FIFO_QUEUE_TYPE(reqs) reqs;
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
};
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
struct async_nif_worker_entry {
ErlNifTid tid;
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
unsigned int worker_id;
struct async_nif_state *async_nif;
struct async_nif_work_queue *q;
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
};
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
struct async_nif_state {
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
unsigned int shutdown;
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
unsigned int num_workers;
struct async_nif_worker_entry worker_entries[ASYNC_NIF_MAX_WORKERS];
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
unsigned int num_queues;
unsigned int next_q;
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
struct async_nif_work_queue queues[];
WIP-- Compiling, not yet tested/functional -- WIP Changes required to iron out compiler errors, warnings, etc. Code now compiles with clang or gcc.
2013-04-06 15:05:41 +00:00
};
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
#define ASYNC_NIF_DECL(decl, frame, pre_block, work_block, post_block) \
struct decl ## _args frame; \
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
static void fn_work_ ## decl (ErlNifEnv *env, ERL_NIF_TERM ref, ErlNifPid *pid, unsigned int worker_id, struct decl ## _args *args) work_block \
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
static void fn_post_ ## decl (struct decl ## _args *args) { \
Clean up
2013-04-16 21:09:34 +00:00
do post_block while(0); \
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
} \
static ERL_NIF_TERM decl(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv_in[]) { \
struct decl ## _args on_stack_args; \
struct decl ## _args *args = &on_stack_args; \
struct decl ## _args *copy_of_args; \
Clean up
2013-04-16 21:09:34 +00:00
struct async_nif_req_entry *req = NULL; \
Use the table name in get/put/delete calls to form an "affinity" with a worker queue so that we spread work around and make it more likely that work for a given table goes first to a given set of worker threads.
2013-04-15 22:46:06 +00:00
const char *affinity = NULL; \
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
ErlNifEnv *new_env = NULL; \
/* argv[0] is a ref used for selective recv */ \
We don't use the scheduler id from Erlang anymore in async_nif so stop sending it over. Allow the user to set a "type" of storage in their config to either 'table' for btree or 'lsm' for a log structured merge tree. Various other cleanup.
2013-04-15 04:08:01 +00:00
const ERL_NIF_TERM *argv = argv_in + 1; \
argc -= 1; \
WIP-- Compiling, not yet tested/functional -- WIP Changes required to iron out compiler errors, warnings, etc. Code now compiles with clang or gcc.
2013-04-06 15:05:41 +00:00
struct async_nif_state *async_nif = (struct async_nif_state*)enif_priv_data(env); \
Clean up
2013-04-16 21:09:34 +00:00
if (async_nif->shutdown) \
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
return enif_make_tuple2(env, enif_make_atom(env, "error"), \
enif_make_atom(env, "shutdown")); \
if (!(new_env = enif_alloc_env())) { \
return enif_make_tuple2(env, enif_make_atom(env, "error"), \
enif_make_atom(env, "enomem")); \
} \
do pre_block while(0); \
Return to alloc'ed requests because there may be many more in flight than those in the various queues. Reenable the (still failing) truncate tests (because they don't SEGV anymore). Still might be a memory leak, next up is valgrind.
2013-04-15 21:37:14 +00:00
req = (struct async_nif_req_entry*)enif_alloc(sizeof(struct async_nif_req_entry)); \
if (!req) { \
fn_post_ ## decl (args); \
enif_free_env(new_env); \
return enif_make_tuple2(env, enif_make_atom(env, "error"), \
enif_make_atom(env, "enomem")); \
} \
Clean up
2013-04-16 21:09:34 +00:00
memset(req, 0, sizeof(struct async_nif_req_entry)); \
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
copy_of_args = (struct decl ## _args *)enif_alloc(sizeof(struct decl ## _args)); \
if (!copy_of_args) { \
fn_post_ ## decl (args); \
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
enif_free(req); \
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
enif_free_env(new_env); \
return enif_make_tuple2(env, enif_make_atom(env, "error"), \
enif_make_atom(env, "enomem")); \
} \
memcpy(copy_of_args, args, sizeof(struct decl ## _args)); \
Return to alloc'ed requests because there may be many more in flight than those in the various queues. Reenable the (still failing) truncate tests (because they don't SEGV anymore). Still might be a memory leak, next up is valgrind.
2013-04-15 21:37:14 +00:00
req->env = new_env; \
req->ref = enif_make_copy(new_env, argv_in[0]); \
enif_self(env, &req->pid); \
req->args = (void*)copy_of_args; \
req->fn_work = (void (*)(ErlNifEnv *, ERL_NIF_TERM, ErlNifPid*, unsigned int, void *))fn_work_ ## decl ; \
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
int h = -1; \
Use the table name in get/put/delete calls to form an "affinity" with a worker queue so that we spread work around and make it more likely that work for a given table goes first to a given set of worker threads.
2013-04-15 22:46:06 +00:00
if (affinity) \
h = async_nif_str_hash_func(affinity) % async_nif->num_queues; \
Clean up
2013-04-16 21:09:34 +00:00
ERL_NIF_TERM reply = async_nif_enqueue_req(async_nif, req, h); \
req->fn_post = (void (*)(void *))fn_post_ ## decl; \
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
if (!reply) { \
enif_free(req); \
enif_free_env(new_env); \
enif_free(copy_of_args); \
return enif_make_tuple2(env, enif_make_atom(env, "error"), \
enif_make_atom(env, "shutdown")); \
} \
Clean up
2013-04-16 21:09:34 +00:00
return reply; \
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
}
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
#define ASYNC_NIF_INIT(name) \
WIP -- 41 tests pass, 3 fail = progress! Right now I have the connection dtor commented out, otherwise it would SEGV on GC. Some of the truncate tests fail (race?) but don't SEGV, so that's not so bad. Fixed numerous issues and also removed a mutex and queue of idle worker threads because it isn't used so why bother with it?
2013-04-12 19:25:56 +00:00
static ErlNifMutex *name##_async_nif_coord = NULL;
#define ASYNC_NIF_LOAD(name, priv) do { \
if (!name##_async_nif_coord) \
name##_async_nif_coord = enif_mutex_create(NULL); \
enif_mutex_lock(name##_async_nif_coord); \
priv = async_nif_load(); \
enif_mutex_unlock(name##_async_nif_coord); \
} while(0);
#define ASYNC_NIF_UNLOAD(name, env) do { \
if (!name##_async_nif_coord) \
name##_async_nif_coord = enif_mutex_create(NULL); \
enif_mutex_lock(name##_async_nif_coord); \
async_nif_unload(env); \
enif_mutex_unlock(name##_async_nif_coord); \
enif_mutex_destroy(name##_async_nif_coord); \
name##_async_nif_coord = NULL; \
} while(0);
#define ASYNC_NIF_UPGRADE(name, env) do { \
if (!name##_async_nif_coord) \
name##_async_nif_coord = enif_mutex_create(NULL); \
enif_mutex_lock(name##_async_nif_coord); \
async_nif_upgrade(env); \
enif_mutex_unlock(name##_async_nif_coord); \
} while(0);
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
#define ASYNC_NIF_RETURN_BADARG() return enif_make_badarg(env);
#define ASYNC_NIF_WORK_ENV new_env
#define ASYNC_NIF_REPLY(msg) enif_send(NULL, pid, env, enif_make_tuple2(env, ref, msg))
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
// TODO: fix, currently NOREPLY() will block cause the recieve in async_nif.hrl wait forever
#define ASYNC_NIF_NOREPLY() enif_free_env(env)
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
/**
Use the table name in get/put/delete calls to form an "affinity" with a worker queue so that we spread work around and make it more likely that work for a given table goes first to a given set of worker threads.
2013-04-15 22:46:06 +00:00
* TODO:
*/
static inline unsigned int async_nif_str_hash_func(const char *s)
{
unsigned int h = (unsigned int)*s;
if (h) for (++s ; *s; ++s) h = (h << 5) - h + (unsigned int)*s;
return h;
}
/**
* TODO:
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
*/
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
static ERL_NIF_TERM
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
async_nif_enqueue_req(struct async_nif_state* async_nif, struct async_nif_req_entry *req, int hint)
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
{
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
/* Identify the most appropriate worker for this request. */
unsigned int qid = (hint != -1) ? hint : async_nif->next_q;
struct async_nif_work_queue *q = NULL;
do {
We don't use the scheduler id from Erlang anymore in async_nif so stop sending it over. Allow the user to set a "type" of storage in their config to either 'table' for btree or 'lsm' for a log structured merge tree. Various other cleanup.
2013-04-15 04:08:01 +00:00
q = &async_nif->queues[qid];
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
enif_mutex_lock(q->reqs_mutex);
/* Now that we hold the lock, check for shutdown. As long as we
hold this lock either a) we're shutting down so exit now or
b) this queue will be valid until we release the lock. */
if (async_nif->shutdown)
return 0;
if (fifo_q_full(reqs, q->reqs)) { // TODO: || (q->avg_latency > median_latency)
enif_mutex_unlock(q->reqs_mutex);
qid = (qid + 1) % async_nif->num_queues;
q = &async_nif->queues[qid];
} else {
break;
}
} while(1);
/* And add the request to their work queue. */
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
fifo_q_put(reqs, q->reqs, req);
Return to alloc'ed requests because there may be many more in flight than those in the various queues. Reenable the (still failing) truncate tests (because they don't SEGV anymore). Still might be a memory leak, next up is valgrind.
2013-04-15 21:37:14 +00:00
WIP -- 41 tests pass, 3 fail = progress! Right now I have the connection dtor commented out, otherwise it would SEGV on GC. Some of the truncate tests fail (race?) but don't SEGV, so that's not so bad. Fixed numerous issues and also removed a mutex and queue of idle worker threads because it isn't used so why bother with it?
2013-04-12 19:25:56 +00:00
/* Build the term before releasing the lock so as not to race on the use of
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
the req pointer (which will soon become invalid in another thread
performing the request). */
WIP -- 41 tests pass, 3 fail = progress! Right now I have the connection dtor commented out, otherwise it would SEGV on GC. Some of the truncate tests fail (race?) but don't SEGV, so that's not so bad. Fixed numerous issues and also removed a mutex and queue of idle worker threads because it isn't used so why bother with it?
2013-04-12 19:25:56 +00:00
ERL_NIF_TERM reply = enif_make_tuple2(req->env, enif_make_atom(req->env, "ok"),
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
enif_make_atom(req->env, "enqueued"));
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
enif_mutex_unlock(q->reqs_mutex);
Change from waking up all threads to waking up one thread.
2013-04-14 17:54:45 +00:00
enif_cond_signal(q->reqs_cnd);
WIP -- 41 tests pass, 3 fail = progress! Right now I have the connection dtor commented out, otherwise it would SEGV on GC. Some of the truncate tests fail (race?) but don't SEGV, so that's not so bad. Fixed numerous issues and also removed a mutex and queue of idle worker threads because it isn't used so why bother with it?
2013-04-12 19:25:56 +00:00
return reply;
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
}
WIP-- Compiling, not yet tested/functional -- WIP Changes required to iron out compiler errors, warnings, etc. Code now compiles with clang or gcc.
2013-04-06 15:05:41 +00:00
static void *
async_nif_worker_fn(void *arg)
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
{
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
struct async_nif_worker_entry *we = (struct async_nif_worker_entry *)arg;
unsigned int worker_id = we->worker_id;
struct async_nif_state *async_nif = we->async_nif;
struct async_nif_work_queue *q = we->q;
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
for(;;) {
WIP-- Compiling, not yet tested/functional -- WIP Changes required to iron out compiler errors, warnings, etc. Code now compiles with clang or gcc.
2013-04-06 15:05:41 +00:00
struct async_nif_req_entry *req = NULL;
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
/* Examine the request queue, are there things to be done? */
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
enif_mutex_lock(q->reqs_mutex);
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
check_again_for_work:
WIP -- 41 tests pass, 3 fail = progress! Right now I have the connection dtor commented out, otherwise it would SEGV on GC. Some of the truncate tests fail (race?) but don't SEGV, so that's not so bad. Fixed numerous issues and also removed a mutex and queue of idle worker threads because it isn't used so why bother with it?
2013-04-12 19:25:56 +00:00
if (async_nif->shutdown) {
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
enif_mutex_unlock(q->reqs_mutex);
WIP -- 41 tests pass, 3 fail = progress! Right now I have the connection dtor commented out, otherwise it would SEGV on GC. Some of the truncate tests fail (race?) but don't SEGV, so that's not so bad. Fixed numerous issues and also removed a mutex and queue of idle worker threads because it isn't used so why bother with it?
2013-04-12 19:25:56 +00:00
break;
}
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
if (fifo_q_empty(reqs, q->reqs)) {
WIP -- 41 tests pass, 3 fail = progress! Right now I have the connection dtor commented out, otherwise it would SEGV on GC. Some of the truncate tests fail (race?) but don't SEGV, so that's not so bad. Fixed numerous issues and also removed a mutex and queue of idle worker threads because it isn't used so why bother with it?
2013-04-12 19:25:56 +00:00
/* Queue is empty, wait for work */
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
enif_cond_wait(q->reqs_cnd, q->reqs_mutex);
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
goto check_again_for_work;
} else {
We don't use the scheduler id from Erlang anymore in async_nif so stop sending it over. Allow the user to set a "type" of storage in their config to either 'table' for btree or 'lsm' for a log structured merge tree. Various other cleanup.
2013-04-15 04:08:01 +00:00
/* At this point the next req is ours to process and we hold the
reqs_mutex lock. */
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
do {
/* Take the request off the queue. */
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
req = fifo_q_get(reqs, q->reqs);
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
enif_mutex_unlock(q->reqs_mutex);
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
We don't use the scheduler id from Erlang anymore in async_nif so stop sending it over. Allow the user to set a "type" of storage in their config to either 'table' for btree or 'lsm' for a log structured merge tree. Various other cleanup.
2013-04-15 04:08:01 +00:00
/* Wake up another thread working on this queue. */
enif_cond_signal(q->reqs_cnd);
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
/* Finally, do the work. */
req->fn_work(req->env, req->ref, &req->pid, worker_id, req->args);
req->fn_post(req->args);
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
/* Note: we don't call enif_free_env(req->env) because it has called
enif_send() which invalidates it (free'ing it for us). If a work
block doesn't call ASYNC_NIF_REPLY() at some point then it must
call ASYNC_NIF_NOREPLY() to free this env. */
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
enif_free(req->args);
Return to alloc'ed requests because there may be many more in flight than those in the various queues. Reenable the (still failing) truncate tests (because they don't SEGV anymore). Still might be a memory leak, next up is valgrind.
2013-04-15 21:37:14 +00:00
enif_free(req);
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
Clean up
2013-04-16 21:09:34 +00:00
/* Continue working if more requests are in the queue, otherwise wait
WIP -- 41 tests pass, 3 fail = progress! Right now I have the connection dtor commented out, otherwise it would SEGV on GC. Some of the truncate tests fail (race?) but don't SEGV, so that's not so bad. Fixed numerous issues and also removed a mutex and queue of idle worker threads because it isn't used so why bother with it?
2013-04-12 19:25:56 +00:00
for new work to arrive. */
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
if (fifo_q_empty(reqs, q->reqs))
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
req = NULL;
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
else
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
enif_mutex_lock(q->reqs_mutex);
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
} while(req);
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
}
}
enif_thread_exit(0);
return 0;
}
WIP -- 41 tests pass, 3 fail = progress! Right now I have the connection dtor commented out, otherwise it would SEGV on GC. Some of the truncate tests fail (race?) but don't SEGV, so that's not so bad. Fixed numerous issues and also removed a mutex and queue of idle worker threads because it isn't used so why bother with it?
2013-04-12 19:25:56 +00:00
static void
async_nif_unload(ErlNifEnv *env)
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
{
unsigned int i;
WIP-- Compiling, not yet tested/functional -- WIP Changes required to iron out compiler errors, warnings, etc. Code now compiles with clang or gcc.
2013-04-06 15:05:41 +00:00
struct async_nif_state *async_nif = (struct async_nif_state*)enif_priv_data(env);
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
/* Signal the worker threads, stop what you're doing and exit. To
ensure that we don't race with the enqueue() process we first
lock all the worker queues, then set shutdown to true, then
unlock. The enqueue function will take the queue mutex, then
test for shutdown condition, then enqueue only if not shutting
down. */
for (i = 0; i < async_nif->num_queues; i++)
enif_mutex_lock(async_nif->queues[i].reqs_mutex);
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
async_nif->shutdown = 1;
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
for (i = 0; i < async_nif->num_queues; i++)
enif_mutex_unlock(async_nif->queues[i].reqs_mutex);
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
/* Wake up any waiting worker threads. */
for (i = 0; i < async_nif->num_queues; i++) {
struct async_nif_work_queue *q = &async_nif->queues[i];
enif_cond_broadcast(q->reqs_cnd);
}
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
/* Join for the now exiting worker threads. */
WIP -- tests failing -- WIP Fixed numerous bugs. Pushed config_to_bin down to just before calling the _nif() function, everywhere else config is a proplist.
2013-04-07 13:21:47 +00:00
for (i = 0; i < async_nif->num_workers; ++i) {
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
void *exit_value = 0; /* We ignore the thread_join's exit value. */
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
enif_thread_join(async_nif->worker_entries[i].tid, &exit_value);
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
}
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
/* Cleanup requests, mutexes and conditions in each work queue. */
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
unsigned int num_queues = async_nif->num_queues;
for (i = 0; i < num_queues; i++) {
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
struct async_nif_work_queue *q = &async_nif->queues[i];
enif_mutex_destroy(q->reqs_mutex);
enif_cond_destroy(q->reqs_cnd);
/* Worker threads are stopped, now toss anything left in the queue. */
struct async_nif_req_entry *req = NULL;
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
fifo_q_foreach(reqs, q->reqs, req, {
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
enif_send(NULL, &req->pid, req->env,
enif_make_tuple2(req->env, enif_make_atom(req->env, "error"),
enif_make_atom(req->env, "shutdown")));
req->fn_post(req->args);
enif_free(req->args);
Return to alloc'ed requests because there may be many more in flight than those in the various queues. Reenable the (still failing) truncate tests (because they don't SEGV anymore). Still might be a memory leak, next up is valgrind.
2013-04-15 21:37:14 +00:00
enif_free_env(req->env);
enif_free(req);
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
});
fifo_q_free(reqs, q->reqs);
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
}
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
memset(async_nif, 0, sizeof(struct async_nif_state) +
sizeof(struct async_nif_work_queue) * num_queues);
WIP -- 41 tests pass, 3 fail = progress! Right now I have the connection dtor commented out, otherwise it would SEGV on GC. Some of the truncate tests fail (race?) but don't SEGV, so that's not so bad. Fixed numerous issues and also removed a mutex and queue of idle worker threads because it isn't used so why bother with it?
2013-04-12 19:25:56 +00:00
enif_free(async_nif);
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
}
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
static void *
async_nif_load(void)
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
{
WIP-- Compiling, not yet tested/functional -- WIP Changes required to iron out compiler errors, warnings, etc. Code now compiles with clang or gcc.
2013-04-06 15:05:41 +00:00
static int has_init = 0;
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
unsigned int i, j;
WIP-- Compiling, not yet tested/functional -- WIP Changes required to iron out compiler errors, warnings, etc. Code now compiles with clang or gcc.
2013-04-06 15:05:41 +00:00
ErlNifSysInfo info;
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
struct async_nif_state *async_nif;
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
/* Don't init more than once. */
WIP-- Compiling, not yet tested/functional -- WIP Changes required to iron out compiler errors, warnings, etc. Code now compiles with clang or gcc.
2013-04-06 15:05:41 +00:00
if (has_init) return 0;
else has_init = 1;
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
/* Find out how many schedulers there are. */
WIP-- Compiling, not yet tested/functional -- WIP Changes required to iron out compiler errors, warnings, etc. Code now compiles with clang or gcc.
2013-04-06 15:05:41 +00:00
enif_system_info(&info, sizeof(ErlNifSysInfo));
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
/* Init our portion of priv_data's module-specific state. */
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
async_nif = enif_alloc(sizeof(struct async_nif_state) +
sizeof(struct async_nif_work_queue) * info.scheduler_threads);
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
if (!async_nif)
return NULL;
Inline the fifo_q functions to speed them up and silence compiler warnings for unused API calls. Add a fifo_q_full call to hide the details of that. Alloc work queues along with the async_nif at the end of that memory block. Fix a few places where things should be free'd and were not. Change enqueue to return 0 when shutting down. Fix a race related to shutdown. When I use gdb eunit calls ?cmd() seem to fail, so I've created rmdir:path() to replace ?cmd("rm -rf path") calls.
2013-04-17 15:17:13 +00:00
memset(async_nif, 0, sizeof(struct async_nif_state) +
sizeof(struct async_nif_work_queue) * info.scheduler_threads);
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
async_nif->num_queues = info.scheduler_threads;
async_nif->next_q = 0;
async_nif->shutdown = 0;
for (i = 0; i < async_nif->num_queues; i++) {
struct async_nif_work_queue *q = &async_nif->queues[i];
Added match/gt/lt atom return for cursor_search_near() call. Changed the request queue over to a simple fifo queue which could (if needed) be made lock-free. Cursor searches can optionally now specifiy that they are mid-scan so as not to have their cursor handles reset every call.
2013-04-15 19:22:12 +00:00
q->reqs = fifo_q_new(reqs, ASYNC_NIF_WORKER_QUEUE_SIZE);
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
q->reqs_mutex = enif_mutex_create(NULL);
q->reqs_cnd = enif_cond_create(NULL);
}
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
/* Setup the thread pool management. */
bzero isn't portable, use memset instead. Include bzip2 and snappy source for use by WT block compression e
2013-04-14 21:23:57 +00:00
memset(async_nif->worker_entries, 0, sizeof(struct async_nif_worker_entry) * ASYNC_NIF_MAX_WORKERS);
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
/* Start the worker threads. */
unsigned int num_workers = async_nif->num_queues;
for (i = 0; i < num_workers; i++) {
struct async_nif_worker_entry *we = &async_nif->worker_entries[i];
we->async_nif = async_nif;
we->worker_id = i;
we->q = &async_nif->queues[i % async_nif->num_queues];
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
if (enif_thread_create(NULL, &async_nif->worker_entries[i].tid,
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
&async_nif_worker_fn, (void*)we, NULL) != 0) {
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
async_nif->shutdown = 1;
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
for (j = 0; j < async_nif->num_queues; j++) {
struct async_nif_work_queue *q = &async_nif->queues[j];
enif_cond_broadcast(q->reqs_cnd);
enif_mutex_destroy(q->reqs_mutex);
enif_cond_destroy(q->reqs_cnd);
}
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
while(i-- > 0) {
void *exit_value = 0; /* Ignore this. */
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
enif_thread_join(async_nif->worker_entries[i].tid, &exit_value);
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
}
This is a different approach from async2, instead of a single queue and many workers this has a queue per scheduler and a few workers per queue.
2013-04-14 12:44:54 +00:00
bzero isn't portable, use memset instead. Include bzip2 and snappy source for use by WT block compression e
2013-04-14 21:23:57 +00:00
memset(async_nif->worker_entries, 0, sizeof(struct async_nif_worker_entry) * ASYNC_NIF_MAX_WORKERS);
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
return NULL;
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
}
}
WIP -- 41 tests pass, 3 fail = progress! Right now I have the connection dtor commented out, otherwise it would SEGV on GC. Some of the truncate tests fail (race?) but don't SEGV, so that's not so bad. Fixed numerous issues and also removed a mutex and queue of idle worker threads because it isn't used so why bother with it?
2013-04-12 19:25:56 +00:00
async_nif->num_workers = i;
WIP-- Not Yet Compiling or Functional -- WIP * No longer expose WT_SESSION into Erlang at all as WT's model is to maintain one WT_SESSION per-thread and we don't know anything about threads in Erlang. * async_nif worker threads don't pull both mutexes on every loop when processing requests, only one * async_nif provides a worker_id (int, 0 - MAX_WORKERS) within the work block scope which we use to find our per-worker WT_SESSIONs * async_nif maintained a number of globals which I'm moving into the NIF's priv_data so that on upgrade/reload we have a fighting chance to "Do the Right Thing(TM)". * NIF Upgrades/Reloads started to plumb this in. * Use a khash to manage the cache of URI->WT_CURSORs per WT_SESSION. * Added start/stop positions into truncate call to allow for truncating sub-ranges data. * Lots of other details I'm sure I've forgotten and more left undone. Search for "TODO:" or try to compile to see what's left, and then there is a need for a lot more tests given all this new complexity.
2013-04-05 22:09:54 +00:00
return async_nif;
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
}
WIP -- 41 tests pass, 3 fail = progress! Right now I have the connection dtor commented out, otherwise it would SEGV on GC. Some of the truncate tests fail (race?) but don't SEGV, so that's not so bad. Fixed numerous issues and also removed a mutex and queue of idle worker threads because it isn't used so why bother with it?
2013-04-12 19:25:56 +00:00
static void
async_nif_upgrade(ErlNifEnv *env)
{
// TODO:
}
Queue and execute work from scheduler threads on other threads to prevent schedulers from sleeping.
2013-03-25 01:00:48 +00:00
#if defined(__cplusplus)
}
#endif
#endif // __ASYNC_NIF_H__
Reference in a new issue Copy permalink