int main(int argc, const char *argv[])
{
pool_t pool;
thread_pool_init(&pool, 4);
thread_pool_start(&pool);
srand(100);
while(1)
{
sleep(1);
task_t tsk;
tsk.thread_callback = task_func;
tsk.arg = (void *)(rand() % 100);
thread_pool_add_task_to_queue(&pool, tsk);
}
thread_pool_stop(&pool);
thread_pool_destroy(&pool);
return 0;
}
int main(int argc,char **argv)
{
if(argc < 4)
{
fprintf(stderr,"No enough parameter.\n");
exit(EXIT_FAILURE);
}
thread_pool_t *pool = thread_pool_create(atoi(argv[1]));
thread_pool_start(pool);
int i;
int end = atoi(argv[2]);
for(i = 0; i < end; ++i)
{
thread_pool_execute(pool,callback,&value);
}
printf("\n");
sleep(5);
for(i = 0; i < end; ++i)
{
thread_pool_execute(pool,callback_function,(void*)i);
}
sleep(atoi(argv[3]));
thread_pool_destroy(pool);
printf("\n");
return 0;
}
static void
dnscache_run(dnscache_t *dnscache)
{
thread_pool_start(dnscache->tp_);
thread_start(dnscache);
struct timeval tv;
struct event timeout;
event_assign(&timeout, dnscache->base_event_, -1, EV_PERSIST, timeout_cb, NULL);
evutil_timerclear(&tv);
tv.tv_sec = TIMEOUT;
event_add(&timeout, &tv);
event_base_dispatch(dnscache->base_event_);
}
int thread_pool_init(struct thread_pool * pool, unsigned int thread_num){
pool->thread_num = thread_num < THREAD_POOL_MAX_THREADNUM ? thread_num : THREAD_POOL_MAX_THREADNUM;
pool->task_list = (struct task*) malloc(sizeof(struct task));
if(!pool->task_list){
fprintf(stderr, "Creating thread pool error.\n");
return -1;
}
pool->task_list_tail = pool->task_list;
memset(pool->task_list, 0, sizeof(struct task));
pool->running = 1;
pool->task_num = 0;
thread_pool_start(pool);
return 0;
}
/**
* \brief Entry point of the program.
* \param argc number of arguments.
* \param argv array of arguments.
* \return EXIT_SUCCESS or EXIT_FAILURE.
*/
int main(int argc, char** argv)
{
const size_t tasks_size = 20;
thread_pool th = NULL;
struct thread_pool_task tasks[tasks_size];
(void)argc;
(void)argv;
fprintf(stdout, "Begin\n");
th = thread_pool_new(10);
fprintf(stdout, "Thread pool: %p\n", (void*)th);
if(!th)
{
fprintf(stderr, "Failed to create pool errno=%d\n",
errno);
exit(EXIT_FAILURE);
}
for(unsigned int i = 0 ; i < tasks_size ; i++)
{
tasks[i].data = (void*)(uintptr_t)i;
tasks[i].run = fcn_run;
tasks[i].cleanup = fcn_cleanup;
if(thread_pool_push(th, &tasks[i]) != 0)
{
fprintf(stderr, "Failed to add task %u\n", i);
}
}
thread_pool_start(th);
sleep(1);
fprintf(stdout, "Stop stuff\n");
thread_pool_stop(th);
fprintf(stdout, "Free stuff\n");
thread_pool_free(&th);
fprintf(stdout, "OK\n");
fprintf(stdout, "End\n");
return EXIT_SUCCESS;
}
int main()
{
pool_t pool;
thread_pool_init(&pool, 5);
thread_pool_start(&pool);
srand(10086);
while(1) {
task_t task;
task.thread_callback = task_func;
task.arg = (void *)(rand() % 100);
thread_pool_add_task(&pool, task);
printf("ThreadPool size: %d, TaskQueue size: %d\n", (int)pool.size_, (int)pool.queue_.size_);
}
thread_pool_stop(&pool);
thread_pool_destroy(&pool);
return 0;
}
int main(int argc, char **argv)
{
/* declare variables we'll be using */
thread_pool_attr_t pool_attr;
resmgr_attr_t resmgr_attr;
dispatch_t *dpp;
thread_pool_t *tpp;
dispatch_context_t *ctp;
int id;
/* initialize dispatch interface */
if((dpp = dispatch_create()) == NULL) {
fprintf(stderr,
"%s: Unable to allocate dispatch handle.\n",
argv[0]);
return EXIT_FAILURE;
}
/* initialize resource manager attributes */
memset(&resmgr_attr, 0, sizeof resmgr_attr);
resmgr_attr.nparts_max = 1;
resmgr_attr.msg_max_size = 2048;
/* initialize functions for handling messages */
iofunc_func_init(_RESMGR_CONNECT_NFUNCS, &connect_funcs,
_RESMGR_IO_NFUNCS, &io_funcs);
io_funcs.read = io_read;
io_funcs.write = io_write;
io_funcs.devctl = io_devctl;
/* initialize attribute structure used by the device */
iofunc_attr_init(&attr, S_IFNAM | 0666, 0, 0);
attr.nbytes = strlen (buffer)+1;
/* attach our device name */
id = resmgr_attach(
dpp, /* dispatch handle */
&resmgr_attr, /* resource manager attrs */
"/dev/sample", /* device name */
_FTYPE_ANY, /* open type */
0, /* flags */
&connect_funcs, /* connect routines */
&io_funcs, /* I/O routines */
&attr); /* handle */
if(id == -1) {
fprintf(stderr, "%s: Unable to attach name.\n", argv[0]);
return EXIT_FAILURE;
}
/* initialize thread pool attributes */
memset(&pool_attr, 0, sizeof pool_attr);
pool_attr.handle = dpp;
pool_attr.context_alloc = dispatch_context_alloc;
pool_attr.block_func = dispatch_block;
pool_attr.unblock_func = dispatch_unblock;
pool_attr.handler_func = dispatch_handler;
pool_attr.context_free = dispatch_context_free;
pool_attr.lo_water = 4;
pool_attr.hi_water = 8;
pool_attr.increment = 2;
pool_attr.maximum = 50;
/* allocate a thread pool handle */
if((tpp = thread_pool_create(&pool_attr,
POOL_FLAG_EXIT_SELF)) == NULL) {
fprintf(stderr, "%s: Unable to initialize thread pool.\n",
argv[0]);
return EXIT_FAILURE;
}
/* start the threads, will not return */
thread_pool_start(tpp);
return EXIT_SUCCESS;
}
int _aio_init(thread_pool_attr_t *pool_attr)
{
static thread_pool_attr_t default_pool_attr = {
NULL,
_aio_block,
_aio_unblock,
_aio_handler,
_aio_context_alloc,
_aio_context_free,
NULL,
3,
1,
8,
10
};
struct _aio_control_block *cb;
struct _aio_context *ctp;
struct _aio_prio_list *plist;
sigset_t set, oset;
int i;
_mutex_lock(&_aio_init_mutex);
if (_aio_cb) {
_mutex_unlock(&_aio_init_mutex);
return 0;
}
if ((cb = malloc(sizeof(*_aio_cb))) == NULL) {
_mutex_unlock(&_aio_init_mutex);
return -1;
}
memset(cb, 0, sizeof(*cb));
pthread_mutex_init(&cb->cb_mutex, 0);
(void)pthread_cond_init(&cb->cb_cond, 0);
if (pool_attr == NULL) {
pool_attr = &default_pool_attr;
} else {
pool_attr->block_func = _aio_block;
pool_attr->context_alloc = _aio_context_alloc;
pool_attr->unblock_func = _aio_unblock;
pool_attr->handler_func = _aio_handler;
pool_attr->context_free = _aio_context_free;
}
pool_attr->handle = (void *)cb;
/* prepare some priority list entries */
for (i = 0; i < _AIO_PRIO_LIST_LOW; i++) {
plist = (struct _aio_prio_list *)malloc(sizeof(*plist));
if (!plist) {
goto err_ret;
}
plist->next = cb->cb_plist_free;
cb->cb_plist_free = plist;
}
cb->cb_nfree = _AIO_PRIO_LIST_LOW;
/* prepare the context */
cb->ct_free = NULL;
for (i = 0; i < pool_attr->maximum; i++) {
if ((ctp = malloc(sizeof(*ctp))) == NULL) {
goto err_ret;
}
ctp->next = cb->ct_free;
cb->ct_free = ctp;
}
cb->tp = thread_pool_create(pool_attr, 0);
if (cb->tp == NULL) {
goto err_ret;
}
/* we can hook _aio_cb now */
_aio_cb = cb;
/* start the pool with all sigal blocked */
if (sigfillset(&set) != 0 || (errno = pthread_sigmask(SIG_BLOCK, &set, &oset)) != EOK) {
goto err_ret;
}
if (thread_pool_start(cb->tp) != EOK) {
pthread_sigmask(SIG_SETMASK, &oset, NULL);
goto err_ret;
}
pthread_sigmask(SIG_SETMASK, &oset, NULL);
_mutex_unlock(&_aio_init_mutex);
return 0;
err_ret:
_mutex_lock(&cb->cb_mutex);
if (cb->tp) {
(void)thread_pool_destroy(cb->tp);
}
while ((plist = cb->cb_plist_free)) {
cb->cb_plist_free = plist->next;
free(plist);
}
while ((ctp = cb->ct_free)) {
cb->ct_free = ctp->next;
free(ctp);
}
pthread_cond_destroy(&cb->cb_cond);
pthread_mutex_destroy(&cb->cb_mutex);
free(cb);
_mutex_unlock(&_aio_init_mutex);
return -1;
}
int
begin(int argc, char *argv[])
{
int i, j;
uint32_t ph_flags = 0;
thread_pool_attr_t tp_attr;
static void *tpp;
dispatch_t *dpp;
dpp = dispatch_create();
if (dpp == NULL) {
char * pMsgTxt = "Error: cannot create dispatch interface\n";
fprintf(stderr, pMsgTxt);
slogf(_SLOG_SETCODE(_SLOGC_INPUT, 0), _SLOG_ERROR, pMsgTxt);
return (EXIT_FAILURE);
}
devi_set_dispatch_handle(dpp);
/* set up the module table */
if (modules != NULL) {
for (i = 0; i < MODULE_TABLE_SIZE && ModuleTable[i] != NULL;
i++)
;
/* add extra modules to end of ModuleTable */
for (j = 0; j < (MODULE_TABLE_SIZE - i) && modules[j] != NULL;
j++, i++)
ModuleTable[i] = modules[j];
}
if(ThreadCtl(_NTO_TCTL_IO, 0) == -1) {
errno_print("ThreadCtl");
return (EXIT_FAILURE);
}
// Call global callback if it was specified
if(commonCallbacks.pre_init && commonCallbacks.pre_init())
return (EXIT_FAILURE);
if (options(argc, argv, &ph_flags, &OptFlags) < 0)
return (EXIT_FAILURE);
// Call global callback if it was specified
if(commonCallbacks.post_init && commonCallbacks.post_init())
return (EXIT_FAILURE);
sig_install(signal_table, termination_hndlr);
if (procmgr_daemon(0, PROCMGR_DAEMON_NODEVNULL |
PROCMGR_DAEMON_NOCLOSE) < 0) {
errno_print("procmgr_daemon");
return (EXIT_FAILURE);
}
if (!(OptFlags & OPT_NO_PHOTON)) {
if (start_photon_interface(ph_flags) < 0) {
errno_print("unable to start photon interface");
return (EXIT_FAILURE);
}
}
memset(&tp_attr, 0, sizeof(tp_attr));
tp_attr.handle = devi_get_dispatch_handle();
tp_attr.context_alloc = dispatch_context_alloc;
tp_attr.block_func = dispatch_block;
tp_attr.handler_func = dispatch_handler;
tp_attr.context_free = dispatch_context_free;
/* We'd rather not to use thread pool for device driver - it could
cause desynchronizing and data losing */
tp_attr.lo_water = 1; /* min amount threads waiting blocked */
tp_attr.hi_water = 1; /* max amount threads waiting blocked */
tp_attr.increment = 1;
tp_attr.maximum = 1;
tpp = thread_pool_create(&tp_attr, POOL_FLAG_USE_SELF);
if (tpp == NULL) {
errno_print("thread_pool_create");
return (EXIT_FAILURE);
}
thread_pool_start(tpp);
return (EOK);
}