int main() {
threadpool_t *tpool;
int rc = threadpool_init(&tpool);
task_t t1 = { test1, (void *) 0};
task_t t2 = { test2, (void *) 0};
assert(rc == 0);
threadpool_add_task(tpool, &t1);
threadpool_add_task(tpool, &t2);
threadpool_run(tpool);
threadpool_exit(tpool);
pthread_exit(NULL);
}
void worker_thread_process(void *data)
{
packet_t *packet;
packet_t *next;
assert(data);
packet = (packet_t *)data;
packet->meta_hd = meta_hd_pp[sys_thread_id_get()];
assert(packet->meta_hd != NULL);
//meta_buffer_sys_clear(packet->meta_hd);
packet->flag &= ~PKT_HANDLE_MASK;/*清理上次的结果*/
module_list_process(module_hd_p, pktag_hd_p, packet->pktag, packet);
if (packet->flag & PKT_LOOP_NEXT) {
threadpool_add_task(tp, worker_thread_process, packet, 0);
} else if (packet->flag & PKT_DONT_FREE) {
meta_buffer_sys_clear(packet->meta_hd);
} else {
do {
next = packet->next_packet;
meta_buffer_sys_clear(packet->meta_hd);
zone_free(packet_zone, packet);
packet = next;
} while (packet != NULL);
}
}
int main()
{
my_count1 = 0;
my_count2 = 0;
pthread_mutex_init(&lock1, NULL);
pthread_mutex_init(&lock2, NULL);
threadpool_t *pool = threadpool_create(2);
threadpool_add_task(pool, mk_task(f1, NULL));
threadpool_add_task(pool, mk_task(f2, NULL));
threadpool_add_task(pool, mk_task(f1, NULL));
threadpool_destroy(pool, immediate_shutdown);
threadpool_add_task(pool, mk_task(f2, NULL));
pthread_mutex_destroy(&lock1);
pthread_mutex_destroy(&lock2);
printf("my_count1 : %d\n", my_count1);
printf("my_count2 : %d\n", my_count2);
}
void process_loop(module_hd_t *module_head)
{
int32_t status, tag_id;
uint64_t pkt_num = 0;
extern int system_exit;
module_info_t *recv;
packet_t *packet;
if (g_conf.mode == MODE_LIVE || g_conf.mode == MODE_FILE) {
/*收包，线程中加入处理*/
status = 0;
packet_zone = zone_init("pcap_read", sizeof(packet_t) + MAX_PACKET_LEN, MAX_PACKET_HANDLE);
assert(packet_zone);
recv = module_info_get_from_name(module_head, "recv");
assert(recv && recv->ops->process);
do {
do {
packet = (void *)zone_alloc(packet_zone, 0);
} while(packet == NULL);
tag_id = recv->ops->process(recv, packet);
if (tag_id > 0) {
assert(packet->data);
pkt_num++;
status = threadpool_add_task(tp, worker_thread_process, packet, 0);
if (status != 0) {
log_error(syslog_p, "Threadpool add task, status %d\n", status);
status = 0;
}
if (g_conf.pkt_num != 0 && pkt_num >= g_conf.pkt_num) {
system_exit = 1;
}
} else {
status = tag_id;
zone_free(packet_zone, packet);
}
} while( status >= 0 && !system_exit);
if (g_conf.mode == MODE_FILE) {
sleep(1);/*等待最后加入的work处理完成*/
}
} else if (g_conf.mode == MODE_SE) {
do {
status = module_list_process(module_head, pktag_hd_p, -1, NULL);
pkt_num++;
if (g_conf.pkt_num != 0 && pkt_num >= g_conf.pkt_num) {
system_exit = 1;
}
} while (status >= 0 && !system_exit);
}
}
int main(int argc, char *argv[]) {
long i = 10000;
threadpool_t *pool = threadpool_create(10, 100, 0);
assert(pool);
while (i > 0) {
if (i % 3 == 0) {
assert(threadpool_add_task(pool, task3,
(void*)(long)(pool->threads_num), 1000) == 0);
} else if (i % 3 == 1) {
assert(threadpool_add_task(pool, task2,
(void*)(long)(pool->threads_num), 500) == 0);
} else {
assert(threadpool_add_task(pool, task1,
(void*)(long)(pool->threads_num), 0) == 0);
}
i--;
}
while (threadpool_task_over(pool, 1, 3) != 0) {};
threadpool_exit(pool);
assert(threadpool_destroy(pool, 1, 3) == 0);
exit(0);
}
void demo3_thread_pool_test()
{
struct threadpool *pool;
int arr[ARR_SIZE], i, ret, failed_count = 0;
for (i = 0; i < ARR_SIZE; i++) {
arr[i] = i;
}
if ((pool = threadpool_init(10)) == NULL) {
printf("Error! Failed to create a thread pool struct.\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < ARR_SIZE; i++) {
if (i % 10000 == 0) {
/* blocking. */
ret = threadpool_add_task(pool,slow_task,arr + i,1);
}
else {
/* non blocking. */
ret = threadpool_add_task(pool,fast_task,arr + i,0);
}
if (ret == -1) {
printf("An error had occurred while adding a task.");
exit(EXIT_FAILURE);
}
if (ret == -2) {
failed_count++;
}
}
threadpool_free(pool,1);
}
int main(void)
{
threadpool_t pool;
threadpool_init(&pool,3);
int i=0;
for(i=0; i<10; i++)
{
int *arg = (int *)malloc(sizeof(int));
*arg=i;
threadpool_add_task(&pool,mytask,arg);//往线程池中添加10个任务
}
//sleep(10);
threadpool_destroy(&pool);
return 0;
}
int main()
{
threadpool_t pool;
threadpool_init(&pool,3);
int i ;
for(i = 0; i < 10; i++)
{
int *arg = (int *)malloc(sizeof(int));
*arg = i;
threadpool_add_task(&pool,mytask,arg);
}
sleep(15);
threadpool_destory(&pool);
return 0;
}
int main( void )
{
threadpool_t pool ; // 定义一个线程池变量
threadpool_init( &pool, MAX_POOL_SIZE ) ; // 初始化线程池
// 向线程池中添加 10 个任务，每个任务的处理函数都是 mytask
for ( int i = 0; i < 10; ++ i )
{
int* arg = (int*)malloc( sizeof( int ) ) ;
*arg = i ;
threadpool_add_task( &pool, mytask, arg ) ;
}
threadpool_destroy( &pool ) ; // 销毁线程池
return 0 ;
}
void _create_async_local(struct Msg* msg) {
if(!USE_THREAD_POOL){
pthread_t t;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
int32_t rc = pthread_create(&t, &attr, _thread_start_local, msg);
if (rc) {
printf("ERROR: return code from pthread_create() is %d\n", rc);
exit(-1);
}
pthread_attr_destroy(&attr);
}else{
//add a blocking task
threadpool_add_task(pool,_thread_start_local,msg,1);
}
}
int main(int argc, const char* argv[]) {
if (argc <= 1) {
printf("PLEASE ENTER THREAD NUMBER!\n");
return 0;
}
int nthreads=atoi(argv[1]);
printf("Number of threads: %d\n", nthreads);
init_pos();
double total = 0;
int N = 3;
int count;
for (count = 1; count <= N; count ++) {
struct timeval begin, end;
double time_spent;
gettimeofday(&begin, NULL);
int n;
for (n=0; n<NUM_TOPICS; n++) {
// printf("Processing topic %d...\n", topics2011[n][0]);
heap h_array[nthreads];
memset(h_array,0,sizeof(h_array));
struct threadpool *pool;
pool = threadpool_init(nthreads);
int i = 0;
for (i=0; i<nthreads; i++) {
struct arg_struct *args = malloc(sizeof *args);
args->topic = n;
args->startidx = i*(int)(ceil((double)NUM_DOCS / nthreads));
if ((i+1)*(int)(ceil((double)NUM_DOCS / nthreads)) > NUM_DOCS) {
args->endidx = NUM_DOCS;
} else {
args->endidx = (i+1)*(int)(ceil((double)NUM_DOCS / nthreads));
}
args->base = termindexes[nthreads-1][i];
heap h;
h_array[i] = h;
args->h = &h_array[i];
threadpool_add_task(pool,search,args,0);
}
threadpool_free(pool,1);
heap h_merge;
heap_create(&h_merge,0,NULL);
float* min_key_merge;
int* min_val_merge;
for (i=0; i<nthreads; i++) {
float* min_key;
int* min_val;
while(heap_delmin(&h_array[i], (void**)&min_key, (void**)&min_val)) {
int size = heap_size(&h_merge);
if ( size < TOP_K ) {
heap_insert(&h_merge, min_key, min_val);
} else {
heap_min(&h_merge, (void**)&min_key_merge, (void**)&min_val_merge);
if (*min_key_merge < *min_key) {
heap_delmin(&h_merge, (void**)&min_key_merge, (void**)&min_val_merge);
heap_insert(&h_merge, min_key, min_val);
}
}
}
heap_destroy(&h_array[i]);
}
int rank = TOP_K;
while (heap_delmin(&h_merge, (void**)&min_key_merge, (void**)&min_val_merge)) {
printf("MB%02d Q0 %ld %d %f Scan1_pos_multithread_intraquery\n", (n+1), tweetids[*min_val_merge], rank, *min_key_merge);
rank--;
}
heap_destroy(&h_merge);
}
gettimeofday(&end, NULL);
time_spent = (double)((end.tv_sec * 1000000 + end.tv_usec) - (begin.tv_sec * 1000000 + begin.tv_usec));
total = total + time_spent / 1000.0;
}
printf("Total time = %f ms\n", total/N);
printf("Time per query = %f ms\n", (total/N)/NUM_TOPICS);
}
//#define DEBUG
int main() {
pthread_t schedulerThread;
epfd = epollCreate(100);
struct threadpool *pool;
if ((pool = threadpool_init(100)) == NULL ) {
printf("Error! Failed to create a thread pool struct.\n");
exit(EXIT_FAILURE);
}
int sockfd;
int newsockfd, newschedule;
sockfd = Create();
int schedulerfd = Create();
if (Bind(35000, sockfd) < 0) {
printf("error in bind");
exit(0);
}
if (Bind(35001, schedulerfd) < 0) {
printf("error in bind");
exit(0);
}
Listen(sockfd, 10);
Listen(schedulerfd, 10);
pthread_create(&schedulerThread, 0, (void*) &schedule, NULL);
int i = 0;
while (i < 100) {
incClient();
newsockfd = Accept(sockfd);
if (numClient() <= 100) {
Send(newsockfd, "ACCEPT", strlen("ACCEPT") + 1);
newschedule = Accept(schedulerfd);
fprintf(stderr, "Connection established with scheduler");
sockets newsock;
newsock.active = 1;
newsock.priority = 1;
newsock.schedulerSocket = newschedule;
newsock.workerSocket = newsockfd;
socketList = addToList(socketList, newsock);
#ifdef DEBUG
if(socketList==NULL) {
fprintf(stderr,"socketlist is null");
exit(0);
}
#endif
epollAdd(epfd, newschedule);
int ret = threadpool_add_task(pool, negotiator, (void*) &newsockfd,
1);
} else {
Send(newsockfd, "REJECT", strlen("REJECT") + 1);
close(newsockfd);
}
i++;
}
sleep(10);
Close(sockfd);
printf("shutting down");
return 0;
}
void *DataReceiver::epollReadData(void *arg) {
struct epoll_event ev_read[10];
int nfds = 0; //return the events count
ThreadPool *tp = threadpool_create(5, 10240);
int recBufferLen = 1024;
char *recData = (char*) (malloc(recBufferLen));
int start = 0, end = 0, totleLen = 0;
int index = 0;
int dataLen;
int readLen = 0;
SocketPool *sp = NULL;
std::map<int, SocketPool*>::iterator it;
while (1) {
nfds = epoll_wait(*(int*) (arg), ev_read, 10, 300);
for (int i = 0; i < nfds; ++i) {
start = 0;
end = 0;
totleLen = 0;
readData: readLen = CSocket::anetRead(ev_read[i].data.fd, recData + end, recBufferLen - end);
if (readLen <= 0) {
pthread_mutex_lock(&mutex);
it = socketMap->find(ev_read[i].data.fd);
if (it != socketMap->end()) {
sp = it->second;
}
pthread_mutex_unlock(&mutex);
if (sp) {
sp->closeSocket(ev_read[i].data.fd);
sp = NULL;
}
gaeaLog(GAEA_WARNING, "DataReceiver::anetRead,happened socket error%d,%d\n", end, recBufferLen);
continue;
}
totleLen += readLen;
while (end < totleLen) {
if (recData[end] == P_END_TAG[index]) {
++index;
if (index == sizeof(P_END_TAG)) {
dataLen = end - start - sizeof(P_START_TAG);
char *retData = (char*) (malloc(dataLen));
memcpy(retData, recData + start + sizeof(P_START_TAG), dataLen);
readDataStruct *rds = new readDataStruct;
rds->fd = ev_read[i].data.fd;
rds->len = dataLen;
rds->data = retData;
threadpool_add_task(tp, socketReadData, rds);
index = 0;
++end;
start = end;
}
} else if (recData[end] == P_END_TAG[0]) {
index = 1;
} else {
index = 0;
}
++end;
}
if (end == totleLen) {
if (start == 0 && end >= recBufferLen) {
recData = (char*) (realloc(recData, recBufferLen * 2));
recBufferLen = recBufferLen * 2;
goto readData;
} else if (start < end - 1) {
memcpy(recData, recData + start, end - start);
end -= start;
start = 0;
totleLen = end;
goto readData;
}
}
}
}
return NULL;
}
