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;
}
int main(int argc, char **argv) {
int s;
int nthread = -1;
int ssize = -1;
char *ip, *port;
char c;
ip = port = NULL;
while ((c = getopt(argc, argv, "p:i:n:s:h")) != -1) {
switch(c) {
case 'p':
port = optarg;
break;
case 'i':
ip = optarg;
break;
case 'n':
nthread = atoi(optarg);
break;
case 's':
ssize = atoi(optarg);
if (!STACKSIZE(ssize))
ssize = 10;
break;
case 'h':
usage();
exit(0);
default:
usage();
exit(1);
}
}
if (port == NULL) {
usage();
return 1;
}
s = tcp_listen(ip, port);
if (s == -1)
return 1;
struct thread_pool *pool;
int r = thread_pool_create(&pool, nthread, process_msg, s, ssize);
printf("thread pool create = %d\n", r);
thread_pool_destroy(pool);
close(s);
return 0;
}
static thread_pool_t sys_init()
{
thread_pool_t pool;
size_t num = system_getcpucount();
pool = thread_pool_create(num*2, num, num*128);
// init timer
systimer_init(pool);
// init socket
socket_init();
return pool;
}
void thread_pool_test(void)
{
int i, r;
thread_pool_t pool;
pool = thread_pool_create(4, 2, 8);
for(i=0; i<20; i++)
{
r = thread_pool_push(pool, worker, &i);
assert(0 == r);
}
thread_pool_destroy(pool);
}
void test_empty_thread_pool() {
dna_log(INFO, "<-------------------- test_empty_thread_pool ---------------------");
int i = 0;
for (i = 0; i < 10 ; i++ ) {
dna_log(INFO, ">> --- cycle %i --- <<", i+1);
// global here, for all threads to share
fifo = fifo_create("values", 0);
dna_log(DEBUG, "starting thread pool");
thread_pool_t *pool = thread_pool_create("main pool", 1);
dna_log(DEBUG, "destroying thread pool");
thread_pool_exit_all(pool);
thread_pool_destroy(pool);
fifo_check();
fifo_destroy(fifo);
}
}
int scanner_init(char *addr, int _scan_method, char *_nic)
{
unsigned long inaddr;
struct hostent *host;
/*设置默认的扫函数*/
default_scanner_info->scan_func = half_scanner;
default_scanner_info->type = SCAN_HALF;
/*初始化扫描结果*/
scan_reslut = NULL;
/*初始化扫描函数表*/
scanner_table = hash_new(10, key_equal, copy_value, free_value);
if(!scanner_table)
return -1;
/*解析地址*/
memset((void*)&global_sockaddr, 0, sizeof(global_sockaddr));
inaddr = inet_addr(addr);
if(inaddr == INADDR_NONE)
{
host = gethostbyname(addr);
if(!host)
{
printf("gethostbyname");
return -1;
}
memcpy((char*)&global_sockaddr.sin_addr, host->h_addr, host->h_length);
}
else
{
memcpy((char*)&global_sockaddr.sin_addr, (char*)&inaddr, sizeof(inaddr));
}
global_sockaddr.sin_family = AF_INET;
/*初始化线程池*/
scan_thread_pool = thread_pool_create(200);
if(!scan_thread_pool)
{
perror("thread_pool_create");
return -1;
}
/*扫描方式*/
scan_method = _scan_method;
/*设置网卡*/
strcpy(nic, _nic);
/*将半开扫描设为全局扫描器*/
return add_global_scanner(half_scanner, SCAN_HALF);
}
int main(void)
{
int i;
thread_pool_t *p = NULL;
p = thread_pool_create(2);
printf("%p\n", p);
thread_pool_init(p, 0, 0);
for(i = 0; i < 20; i++)
{
task_t *t = task_create();
task_init(t, task_callback, NULL);
task_add(p, t);
}
sleep(60);
return 0;
}
dnscache_t *
dnscache_create(char *server_addr,
uint16_t port,
uint32_t thread_num)
{
dnscache_t *dnscache = malloc(sizeof(dnscache_t));
if (!dnscache)
return NULL;
dnscache->thread_count_ = thread_num;
dnscache->base_event_ = event_base_new();
dnscache_init_sig(dnscache);
dnscache->tp_ = thread_pool_create(thread_num);
ASSERT(dnscache->tp_, "thread pool create failed");
addr_t addr;
addr_init(&addr, server_addr, port);
dnscache->listen_socket = (socket_t *)malloc(sizeof(socket_t));
int socket_type = addr_get_type(&addr) == ADDR_IPV4 ? AF_INET : AF_INET6;
socket_open(dnscache->listen_socket, socket_type, SOCK_DGRAM, 0);
socket_set_unblock(dnscache->listen_socket, true);
socket_set_addr_reusable(dnscache->listen_socket);
int ret = socket_bind(dnscache->listen_socket, &addr);
ASSERT(ret == 0, "udp server bind failed\n");
int threads_len = thread_num * sizeof(thread_local_param_t *);
dnscache->thread_params_ = (thread_local_param_t **)malloc(threads_len);
ASSERT(dnscache->thread_params_ != NULL, "udp server bind failed\n");
int i = 0;
for (; i < thread_num; ++i)
{
dnscache->thread_params_[i] =
(thread_local_param_t *)malloc(sizeof(thread_local_param_t));
thread_local_param_t *tlp = dnscache->thread_params_[i];
tlp->thread_id_ = i;
tlp->base_ = event_base_new();
tlp->dns_server_ =
dns_server_create(tlp->base_, UDP_SERVER, dnscache->listen_socket, queue_size);
thread_pool_set_thread_data(dnscache->tp_, i, tlp);
}
return dnscache;
}
void test_busy_thread_pool() {
dna_log(INFO, "<-------------------- test_busy_thread_pool ---------------------");
fifo = fifo_create("<(busy_thread_pool) value fifo>", 0);
thread_pool_t *pool = thread_pool_create("<busy thread pool>", 8); // should auto-determine thread count maybe?
dna_log(DEBUG, "adding %i tasks to the queue...", ELEMS);
int i = 0;
for( i = 0; i < ELEMS; i++ ) {
thread_pool_enqueue(pool, &fifo_fill, NULL);
}
dna_log(DEBUG, "waiting for threads to complete on their own...");
thread_pool_exit_all(pool);
thread_pool_join_all( pool );
dna_log(DEBUG, "destroying thread pool...");
thread_pool_destroy( pool );
fifo_check();
dna_log(DEBUG, "destroying global value fifo.");
fifo_destroy( fifo );
}
int main(int argc, char* argv[])
{
char c;
int cpu = system_getcpucount();
socket_t server;
aio_socket_t aioserver;
memset(s_buffer, 'A', sizeof(s_buffer)-1);
aio_socket_init(cpu);
s_thpool = thread_pool_create(cpu, cpu, cpu*2);
while(cpu > 0)
{
thread_pool_push(s_thpool, AIOWorker, NULL);
--cpu;
}
server = Listen(50000);
aioserver = aio_socket_create(server, 1);
aio_socket_accept(aioserver, OnAccept, aioserver);
printf("server listen at: %d\n", 50000);
for(c = getchar(); 'q' != c; c = getchar())
{
switch(c)
{
case 'c': // close socket
aio_socket_destroy(aioserver);
break;
default:
printf("unknown command.\nc : close socket\n");
}
}
aio_socket_destroy(aioserver);
thread_pool_destroy(s_thpool);
aio_socket_clean();
return 0;
}
int main(int argc, char* argv[])
{
tcpserver_t tcpserver;
tcpserver_handler_t tcphandler;
tcphandler.onerror = OnTcpError;
tcphandler.onconnected = OnTcpConnected;
socket_init();
g_thdpool = thread_pool_create(2, 1, 64);
tcpserver = tcpserver_start(NULL, 10000, &tcphandler, NULL);
http_proxy_find(OnFindProxy, NULL);
while('q' != getchar())
{
}
tcpserver_stop(tcpserver);
thread_pool_destroy(g_thdpool);
socket_cleanup();
return 0;
}
int main(int argc, char* argv[])
{
#if defined(OS_LINUX)
/* ignore pipe signal */
struct sigaction sa;
sa.sa_handler = SIG_IGN;
sigaction(SIGCHLD, &sa, 0);
sigaction(SIGPIPE, &sa, 0);
#endif
int port = 554;
for(int i=1; i<argc; i++)
{
if(streq(argv[i], "--port") && i+1<argc)
{
port = atoi(argv[++i]);
}
}
size_t cpu = system_getcpucount();
g_thpool = thread_pool_create(cpu, cpu, cpu*4);
aio_socket_init(cpu * 2);
for(size_t i=0; i<cpu * 2; i++)
thread_pool_push(g_thpool, AioWorker, NULL); // start worker
// start server
StartTcpServer(NULL, port);
StartUdpServer(NULL, port);
for(int c = getchar(); 'q' != c ; c = getchar())
{
}
aio_socket_destroy(s_tcp);
aio_socket_clean();
thread_pool_destroy(g_thpool);
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);
}
