void thr_join(){ Pthread_mutex_lock(&m); while (done==0) Pthread_cond_wait(&c,&m); Pthread_mutex_unlock(&m); }
int threadpool_task_over(threadpool_t *pool, int block, int timeout) { int ret; Pthread_mutex_lock(&pool->mutex); if (pool->task_queue.len != 0) { if (!block) { Pthread_mutex_unlock(&pool->mutex); return -1; } else { struct timespec ts; struct timeval tv; gettimeofday(&tv, NULL); ts.tv_sec = tv.tv_sec + timeout; ts.tv_nsec = tv.tv_usec * 1000; while (pool->task_queue.len != 0) { if (timeout == 0) { Pthread_cond_wait(&pool->task_over_cond, &pool->mutex); } else { ret = Pthread_cond_timedwait(&pool->task_over_cond, &pool->mutex, &ts); if (ret == 0) { Pthread_mutex_unlock(&pool->mutex); return 0; } else if (ret == ETIMEDOUT) { Pthread_mutex_unlock(&pool->mutex); return -1; } } } } } Pthread_mutex_unlock(&pool->mutex); return 0; }
void * consume(void *arg) { for ( ; ; ) { Pthread_mutex_lock(&nready.mutex); if (nready.nconsumer > 0) { Pthread_mutex_unlock(&nready.mutex); continue; } else if (nready.nget >= nitems) { Pthread_mutex_unlock(&nready.mutex); return(NULL); } else { nready.nconsumer++; while (nready.nready == 0) Pthread_cond_wait(&nready.cond, &nready.mutex); nready.nready--; nready.nget++; nready.nconsumer--; Pthread_mutex_unlock(&nready.mutex); // if (buff[i] != i) // printf("buff[%d] = %d\n", i, buff[i]); *((int *) arg) += 1; } } return(NULL); }
void * Consumer(void *v) { struct thread_data *data = (struct thread_data *)v; unsigned sum = 0; int n, item; int waits = 0; int l = maxbuflen - 1; for (n = 0; ; ++n) { Pthread_mutex_lock(&buf_mutex); while (buflen == 0) { if (eof) { Pthread_mutex_unlock(&buf_mutex); goto done; } ++waits; Pthread_cond_wait(&empty_cond, &buf_mutex); } item = buf[--buflen]; if (buflen == l) Pthread_cond_broadcast(&full_cond); Pthread_mutex_unlock(&buf_mutex); ConsumeItem(item, &sum); } done: data->sum = sum; printf("Consumer %d exit, %d items received, %d waits\n", data->no, n, waits); return data; }
void * Producer(void *v) { struct thread_data *data = (struct thread_data *)v; unsigned seed = data->seed; int n; unsigned item, sum; int waits = 0; data->sum = 0; for (n = 0; n < num_items; ++n) { pthread_testcancel(); sum = 0; item = ProduceItem(&seed, &sum); pthread_cleanup_push(pthread_mutex_unlock, &buf_mutex); Pthread_mutex_lock(&buf_mutex); while (buflen == maxbuflen) { ++waits; Pthread_cond_wait(&full_cond, &buf_mutex); } buf[buflen++] = item; data->sum += sum; if (buflen == 1) Pthread_cond_broadcast(&empty_cond); pthread_cleanup_pop(1); } printf("Producer %d exit, %d waits\n", data->no, waits); return data; }
int crew_start(crew_p crew,char* path,char* string){ Pthread_mutex_lock(&crew->mutex); while(crew->work_cnt>0){ Pthread_cond_wait(&crew->done,&crew->mutex); } work_p work = (work_p)malloc(sizeof(work)); errno =0; name_max = pathconf(path,_PC_NAME_MAX); if((int)name_max==-1){ if(errno==0) name_max = 2560; else{ printf("%s\n",strerror(errno)); exit(-1); } } path_max = pathconf(path,_PC_PATH_MAX); if((int)path_max==-1){ if(errno==0) path_max=102400; else{ printf("%s\n",strerror(errno)); exit(-1); } } path_max++; name_max++; work->string =string; work->path = (char*)malloc(path_max); strcpy(work->path,path); work->next = NULL; if(crew->first_work==NULL){ crew->first_work = work; crew->last_work = work; }else{ crew->last_work->next = work; crew->last_work = work; } crew->work_cnt ++; Pthread_cond_signal(&crew->go); while(crew->work_cnt>0){ Pthread_cond_wait(&crew->done,&crew->mutex); } return 0; }
void * Producer(void *v) { struct producer *p = (struct producer *)v; struct consumer *c; struct packet *pa, *old; unsigned seed = p->seed; int n, k, cons; unsigned sum = 0; int waits = 0; int more = 1; int item_cnt = 0; cons = seed % num_consumers; for (n = 0; more; ++n) { /* Hole Packet aus lokaler emptyPacketQueue */ Pthread_mutex_lock(&p->queue_mutex); while (!p->emptyPacketQueue) { ++waits; Pthread_cond_wait(&p->empty_cond, &p->queue_mutex); } pa = p->emptyPacketQueue; p->emptyPacketQueue = pa->next; Pthread_mutex_unlock(&p->queue_mutex); /* Fuelle Packet */ for (k = 0; k < buflen; ++k) { pa->buf[k] = ProduceItem(&seed, &sum); if (++item_cnt == num_items) { more = 0; ++k; break; } } pa->len = k; /* Versende Packet an Consumer cons */ c = consumers + cons; Pthread_mutex_lock(&c->queue_mutex); old = pa->next = c->fullPacketQueue; c->fullPacketQueue = pa; Pthread_mutex_unlock(&c->queue_mutex); if (!old) Pthread_cond_broadcast(&c->empty_cond); if (++cons == num_consumers) cons = 0; } p->sum = sum; printf("Producer %d exit, %d waits, %d packets\n", p->no, waits, n); return NULL; }
void * thread_main_dns(void *arg) { int dnsrequest(const char *name, uint32 *ipaddr); int connfd, *number, count, total; char *domain ; uint32 *ipptr; pthread_mutex_t *mutex; printf("dns thread %d starting \n", (int)arg ); for(;;){ Pthread_mutex_lock(&dns_array_mutex); while(iget == iput) Pthread_cond_wait(&dns_array_cond, &dns_array_mutex); printf("thread %d working \n", pthread_self()); connfd = dns_array[iget].sockfd; domain = dns_array[iget].domain; number = dns_array[iget].number; count = dns_array[iget].count; total = dns_array[iget].total; ipptr = dns_array[iget].ipptr; mutex = dns_array[iget].mutex; if(++iget == ARRAYSIZE) iget = 0; Pthread_mutex_unlock(&dns_array_mutex); //do our job if(dnsrequest(domain, ipptr + count) != 0) inet_pton(AF_INET, "127.0.0.1", ipptr+count); dc_free(domain); //dc_free the memory of domain Pthread_mutex_lock(mutex); (*number)--; Pthread_mutex_unlock(mutex); if((*number) == 0){ write(connfd, ipptr, total*sizeof(uint32)); printf("sended\n"); // close(connfd); //todo dc_free(ipptr); dc_free(number); dc_free(mutex); } } }
int threadpool_destroy(threadpool_t *pool, int block, int timeout) { int ret; assert(pool); Pthread_mutex_lock(&pool->mutex); if (!pool->exit) { /* you should call `threadpool_exit' first */ Pthread_mutex_unlock(&pool->mutex); return -1; } if (pool->threads_num != 0) { if (!block) { Pthread_mutex_unlock(&pool->mutex); return -1; } else { struct timespec ts; struct timeval tv; gettimeofday(&tv, NULL); ts.tv_sec = tv.tv_sec + timeout; ts.tv_nsec = tv.tv_usec * 1000; while (pool->threads_num != 0) { if (timeout == 0) { Pthread_cond_wait(&pool->exit_cond, &pool->mutex); goto CONT; } else { ret = Pthread_cond_timedwait(&pool->exit_cond, &pool->mutex, &ts); if (ret == 0) { goto CONT; } else if (ret == ETIMEDOUT) { Pthread_mutex_unlock(&pool->mutex); return -1; } } } } } CONT: Pthread_mutex_unlock(&pool->mutex); heap_destroy(&pool->task_queue); Pthread_mutex_destroy(&pool->mutex); Pthread_cond_destroy(&pool->cond); Pthread_cond_destroy(&pool->exit_cond); Pthread_cond_destroy(&pool->task_over_cond); free(pool); return 0; }
void *consume(void *arg) { int i; for(i = 0; i < nitems; i++){ Pthread_mutex_lock(&nready.mutex); while(nready.nready == 0) Pthread_cond_wait(&nready.cond, &nready.mutex);/* wait for producer */ nready.nready--; Pthread_mutex_unlock(&nready.mutex); if(buff[i] != i) printf("buff[%d] = %d\n", i, buff[i]); } return (NULL); }
void * Consumer(void *v) { struct consumer *c = (struct consumer *)v; struct producer *p; struct packet *pa, *old; unsigned sum = 0; int n, k; int waits = 0; int item_cnt = 0; for (n = 0; ; ++n) { /* Hole Packet aus lokaler fullPacketQueue */ Pthread_mutex_lock(&c->queue_mutex); while (!c->fullPacketQueue) { if (c->eof) { Pthread_mutex_unlock(&c->queue_mutex); goto done; } ++waits; Pthread_cond_wait(&c->empty_cond, &c->queue_mutex); } pa = c->fullPacketQueue; c->fullPacketQueue = pa->next; Pthread_mutex_unlock(&c->queue_mutex); /* Verarbeite Packet */ for (k = 0; k < pa->len; ++k) ConsumeItem(pa->buf[k], &sum); item_cnt += pa->len; /* Stelle Packet zurueck in emptyPacketQueue des Owners */ p = producers + pa->owner; Pthread_mutex_lock(&p->queue_mutex); old = pa->next = p->emptyPacketQueue; p->emptyPacketQueue = pa; Pthread_mutex_unlock(&p->queue_mutex); if (!old) Pthread_cond_broadcast(&p->empty_cond); } done: c->sum = sum; printf("Consumer %d exit, %d items in %d packets received, %d waits\n", c->no, item_cnt, n, waits); return NULL; }
void produce(struct buf_t* bptr, int val) { Pthread_mutex_lock(&bptr->b_mutex); /* Wait if buffer is full */ while (bptr->b_nitems >= BUFFSIZE) Pthread_cond_wait(&bptr->b_cond_producer, &bptr->b_mutex); /* There is room, store the new value */ printf("produce %d\n", val); bptr->b_buf[bptr->b_nextput] = val; if (++bptr->b_nextput >= BUFFSIZE) bptr->b_nextput = 0; bptr->b_nitems++; /* Signal consumer */ Pthread_cond_signal(&bptr->b_cond_consumer); Pthread_mutex_unlock(&bptr->b_mutex); }
void *comsume(void *arg) { int i; for(i = 0; i < nitems; ++i){ /*消费者等待变为非0*/ Pthread_mutex_lock(&nready.mutex); while(nready.nready == 0)/*如果计数器=0*/ Pthread_cond_wait(&nready.cond, &nready.mutex);/*消费者线程等待*/ nready.nready--; Pthread_mutex_unlock(&nready.mutex); if(buff[i] != i) printf("buff[%d] = %d\n", i, buff[i]); } return(NULL); }
void* thread_main(void* arg) { int connfd; void web_child(int); printf("thread %d starting\n", (int)arg); for (;;) { Pthread_mutex_lock(&clifd_mutex); while (iget == iput) Pthread_cond_wait(&clifd_cond, &clifd_mutex); connfd = clifd[iget]; /* connected socket to service */ if (++iget == MAXNCLI) iget = 0; Pthread_mutex_unlock(&clifd_mutex); tptr[(int)arg].thread_count++; web_child(connfd); /* process request */ Close(connfd); } }
int consume(struct buf_t* bptr) { int val; Pthread_mutex_lock(&bptr->b_mutex); /* Wait if buffer is empty */ while (bptr->b_nitems <= 0) Pthread_cond_wait(&bptr->b_cond_consumer, &bptr->b_mutex); /* There is data, fetch the value */ val = bptr->b_buf[bptr->b_nextget]; printf("consume %d\n", val); if (++bptr->b_nextget >= BUFFSIZE) bptr->b_nextget = 0; bptr->b_nitems--; /* Signal producer; it might be waiting for space to store */ Pthread_cond_signal(&bptr->b_cond_producer); Pthread_mutex_unlock(&bptr->b_mutex); return (val); }
int main(int argc, char **argv) { int i, maxnconn; pthread_t tid; struct file *fptr; if (argc < 5) err_quit("usage: web <#conns> <IPaddr> <homepage> file1 ..."); maxnconn = atoi(argv[1]); nfiles = min(argc - 4, MAXFILES); for (i = 0; i < nfiles; i++) { file[i].f_name = argv[i + 4]; file[i].f_host = argv[2]; file[i].f_flags = 0; } printf("nfiles = %d\n", nfiles); home_page(argv[2], argv[3]); nlefttoread = nlefttoconn = nfiles; nconn = 0; /* include web2 */ while (nlefttoread > 0) { while (nconn < maxnconn && nlefttoconn > 0) { /* 4find a file to read */ for (i = 0 ; i < nfiles; i++) if (file[i].f_flags == 0) break; if (i == nfiles) err_quit("nlefttoconn = %d but nothing found", nlefttoconn); file[i].f_flags = F_CONNECTING; Pthread_create(&tid, NULL, &do_get_read, &file[i]); file[i].f_tid = tid; nconn++; nlefttoconn--; } /* 4Wait for thread to terminate */ Pthread_mutex_lock(&ndone_mutex); while (ndone == 0) Pthread_cond_wait(&ndone_cond, &ndone_mutex); for (i = 0; i < nfiles; i++) { if (file[i].f_flags & F_DONE) { Pthread_join(file[i].f_tid, (void **) &fptr); if (&file[i] != fptr) err_quit("file[i] != fptr"); fptr->f_flags = F_JOINED; /* clears F_DONE */ ndone--; nconn--; nlefttoread--; printf("thread %d for %s done\n", fptr->f_tid, fptr->f_name); } } Pthread_mutex_unlock(&ndone_mutex); } exit(0); }
int main(int argc, char *argv[]) { int i, maxconn, nfiles, nlefttoread, nlefttoconn, nconn; char *pchServaddr, *pchWeb, *pchHomepage; struct file *pf; pthread_t tid; if (argc < 5) err_quit("Usage: %s <#conns> <webName> <homepage> file1 ...", basename(argv[0])); maxconn = atoi(argv[1]); pchWeb = argv[2]; pchHomepage = argv[3]; nfiles = nlefttoread = nlefttoconn = argc-4; nconn = 0; thread_home_page(pchWeb, pchHomepage, &pchServaddr); /* don't forget free(pchServaddr); */ #ifdef _TEST char buff[MAXLINE]; if (inet_ntop(AF_INET, pchServaddr, buff, sizeof(buff)) == NULL) err_sys("inet_ntop error"); printf("web address is %s\n", buff); printf("\nnfiles = %d\n", nfiles); for (i = 0; i < nfiles; i++) { file[i].f_pchName = argv[i+4]; file[i].f_pchHost = pchServaddr; file[i].f_iFlags = 0; Pthread_create(&tid, NULL, thread_do_get_read, &file[i]); } /* wait for the thread exit */ printf("sleeping for wait thread\n"); sleep(10); #else printf("\nnfiles = %d\n", nfiles); for (i = 0; i < nfiles; i++) { file[i].f_pchName = argv[i+4]; file[i].f_pchHost = pchServaddr; file[i].f_iFlags = 0; } while (nlefttoread > 0) { while (nconn < maxconn && nlefttoconn > 0) { /* find a file to read */ for (i = 0; i < nfiles; i++) if (file[i].f_iFlags == 0) break; assert(i < nfiles); file[i].f_iFlags = F_CONNECTING; Pthread_create(&tid, NULL, thread_do_get_read, &file[i]); nconn++; nlefttoconn--; } /* wait for any thread exit */ Pthread_mutex_lock(&ndone_mutex); while (ndone == 0) Pthread_cond_wait(&ndone_cond, &ndone_mutex); for (i = 0; i < nfiles; i++) { if (file[i].f_iFlags == F_DONE) { Pthread_join(file[i].f_thrId, (void **)&pf); assert(&file[i] == pf); pf->f_iFlags = F_JOINED; ndone--; nconn--; nlefttoread--; printf("thread %u for %s done\n", pf->f_thrId, pf->f_pchName); } } Pthread_mutex_unlock(&ndone_mutex); } #endif free(pchServaddr); return 0; }
void* work_loop(void* args){ worker_p mine = (worker_p)args; crew_p crew = mine->crew; struct stat file_stat; struct dirent *entry; work_p work; entry = (struct dirent*)malloc(sizeof(struct dirent)+name_max); Pthread_mutex_lock(&crew->mutex); while(crew->work_cnt==0){ Pthread_cond_wait(&crew->go,&crew->mutex); } Pthread_mutex_unlock(&crew->mutex); while(1){ Pthread_mutex_lock(&crew->mutex); while(crew->first_work==NULL) Pthread_cond_wait(&crew->go,&crew->mutex); printf("woker %d works on :#%lx ,conunt is %d\n", mine->index,crew->first_work,crew->work_cnt); work = crew->first_work; crew->first_work = work->next; if(crew->first_work==NULL) crew->last_work = NULL; printf("woker %d took #%lx ,leaave first is #%lx last is #%lx\n", mine->index,work,crew->first_work,crew->last_work); Pthread_mutex_unlock(&crew->mutex); if(lstat(work->path,&file_stat)<0){ printf("%s error: %s\n",work->path,strerror(errno)); } if(S_ISLNK(file_stat.st_mode)){ printf("%s is a link\n", work->path); } else if (S_ISDIR(file_stat.st_mode)){ DIR* directory = opendir(work->path); struct dirent* result; if(directory==NULL){ fprintf(stderr, "open %s errro:%s\n", work->path,strerror(errno)); continue; } while(1){ int status = readdir_r(directory,entry,&result); if(status!=0){ fprintf(stderr, "unable to open %s,error:%s\n", work->path,strerror(status)); break; } if(result==NULL) break; if(strcmp(entry->d_name,".")==0||strcmp(entry->d_name,"..")==0) continue; work_p new_work= (work_p)malloc(sizeof(work_t)); new_work->string = work->string; new_work->path = (char*) malloc(path_max); strcpy(new_work->path,work->path); strcat(new_work->path,"/"); strcat(new_work->path,entry->d_name); new_work->next= NULL; Pthread_mutex_lock(&crew->mutex); if(crew->first_work==NULL){ crew->first_work=new_work; crew->last_work = new_work; }else{ crew->last_work->next = new_work; crew->last_work = new_work; } crew->work_cnt++; Pthread_cond_signal(&crew->go); Pthread_mutex_unlock(&crew->mutex); } closedir(directory); } else if (S_ISREG(file_stat.st_mode)){ FILE* file; char buf[MAXLINE],*fbuf; if((file = fopen(work->path,"r"))==NULL){ fprintf(stderr, "can not open %s:%s\n", work->path,strerror(errno)); continue; } else{ while(1){ if((fbuf= fgets(buf,MAXLINE,file))==NULL){ if(feof(file)) break; else if(ferror(file)){ fprintf(stderr, "read %s error:%s\n", work->path,strerror(errno)); break; } } if(strstr(buf,work->string)!=NULL){ printf("found %s in %s\n",work->string,work->path); break; } } fclose(file); } } else{ fprintf(stderr, "%s's type is %s\n", work->path,S_ISFIFO(file_stat.st_mode)?"FIFO": S_ISCHR(file_stat.st_mode)?"CHAR": S_ISBLK(file_stat.st_mode)?"BLK": S_ISSOCK(file_stat.st_mode)?"SOCK":"unknown"); } free(work->path); free(work); Pthread_mutex_lock(&crew->mutex); crew->work_cnt--; if(crew->work_cnt<=0){ Pthread_cond_broadcast(&crew->done); Pthread_mutex_unlock(&crew->mutex); break; } Pthread_mutex_unlock(&crew->mutex); } free(entry); return NULL; }
void * cerebrod_event_queue_monitor(void *arg) { List temp_event_queue; _event_queue_monitor_initialize(); /* Don't bother if there isn't an event queue (i.e. no event modules) */ if (!event_queue) return NULL; temp_event_queue = List_create((ListDelF)cerebrod_event_to_send_destroy); /* * achu: The listener and thus event update initialization is * started after this thread is started. So the and event_index may * not be set up the first time this loop is reached. * * However, it must be set after the condition is signaled, b/c the * listener (and thus event update code) and event node timeout * thread begin after the listener is setup. * * Thus, we put the event_queue assert inside the loop. */ for (;;) { struct cerebrod_event_to_send *ets; ListIterator eitr; ListIterator titr; Pthread_mutex_lock(&event_queue_lock); assert(event_queue); while (list_count(event_queue) == 0) Pthread_cond_wait(&event_queue_cond, &event_queue_lock); /* Debug dumping in the below loop can race with the debug * dumping from the listener, b/c of racing on the * event_queue_lock. To avoid this race, we copy the data off * the event_queue, so the event_queue_lock can be freed up. */ eitr = List_iterator_create(event_queue); while ((ets = list_next(eitr))) { List_append(temp_event_queue, ets); List_remove(eitr); } List_iterator_destroy(eitr); Pthread_mutex_unlock(&event_queue_lock); titr = List_iterator_create(temp_event_queue); while ((ets = list_next(titr))) { List connections; _event_dump(ets->event); Pthread_mutex_lock(&event_connections_lock); if ((connections = Hash_find(event_connections_index, ets->event_name))) { char buf[CEREBRO_MAX_PACKET_LEN]; int elen; if ((elen = _event_marshall(ets->event, buf, CEREBRO_MAX_PACKET_LEN)) > 0) { ListIterator citr; int *fd; citr = List_iterator_create(connections); while ((fd = list_next(citr))) { if (fd_write_n(*fd, buf, elen) < 0) { CEREBROD_DBG(("fd_write_n: %s", strerror(errno))); if (errno == EPIPE || errno == EINVAL || errno == EBADF || errno == ENODEV || errno == ENETDOWN || errno == ENETUNREACH) { if (conf.event_server_debug) { Pthread_mutex_lock(&debug_output_mutex); fprintf(stderr, "**************************************\n"); fprintf(stderr, "* Event Connection Died: errno = %d\n", errno); fprintf(stderr, "**************************************\n"); Pthread_mutex_unlock(&debug_output_mutex); } List_delete(citr); } continue; } } List_iterator_destroy(citr); } } Pthread_mutex_unlock(&event_connections_lock); List_delete(titr); } List_iterator_destroy(titr); } List_destroy(temp_event_queue); return NULL; /* NOT REACHED */ }
int main(int argc, char **argv) { cerebro_err_init(argv[0]); cerebro_err_set_flags(CEREBRO_ERROR_STDERR | CEREBRO_ERROR_SYSLOG); cerebrod_config_setup(argc, argv); #if CEREBRO_DEBUG if (!conf.debug) { cerebrod_daemon_init(); cerebro_err_set_flags(CEREBRO_ERROR_SYSLOG); } else cerebro_err_set_flags(CEREBRO_ERROR_STDERR); #else /* !CEREBRO_DEBUG */ cerebrod_daemon_init(); cerebro_err_set_flags(CEREBRO_ERROR_SYSLOG); #endif /* !CEREBRO_DEBUG */ /* Call after daemonization, since daemonization closes currently * open fds */ openlog(argv[0], LOG_ODELAY | LOG_PID, LOG_DAEMON); #if !WITH_CEREBROD_SPEAKER_ONLY /* Start metric server before the listener begins receiving data. */ if (conf.metric_server) { pthread_t thread; pthread_attr_t attr; Pthread_attr_init(&attr); Pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); Pthread_attr_setstacksize(&attr, CEREBROD_THREAD_STACKSIZE); Pthread_create(&thread, &attr, cerebrod_metric_server, NULL); Pthread_attr_destroy(&attr); /* Wait for initialization to complete */ Pthread_mutex_lock(&metric_server_init_lock); while (!metric_server_init) Pthread_cond_wait(&metric_server_init_cond, &metric_server_init_lock); Pthread_mutex_unlock(&metric_server_init_lock); } /* Start listening server before speaker so that listener * can receive packets from a later created speaker */ if (conf.listen) { int i; for (i = 0; i < conf.listen_threads; i++) { pthread_t thread; pthread_attr_t attr; Pthread_attr_init(&attr); Pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); Pthread_attr_setstacksize(&attr, CEREBROD_THREAD_STACKSIZE); Pthread_create(&thread, &attr, cerebrod_listener, NULL); Pthread_attr_destroy(&attr); } /* Wait for initialization to complete */ Pthread_mutex_lock(&listener_init_lock); while (!listener_init) Pthread_cond_wait(&listener_init_cond, &listener_init_lock); Pthread_mutex_unlock(&listener_init_lock); } /* Start all the event server, queue monitor, and node timeout * threads after the listener thread, since they use data created by * the listener thread. */ if (conf.event_server) { pthread_t thread; pthread_attr_t attr; Pthread_attr_init(&attr); Pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); Pthread_attr_setstacksize(&attr, CEREBROD_THREAD_STACKSIZE); Pthread_create(&thread, &attr, cerebrod_event_queue_monitor, NULL); Pthread_attr_destroy(&attr); /* Wait for initialization to complete */ Pthread_mutex_lock(&event_queue_monitor_init_lock); while (!event_queue_monitor_init) Pthread_cond_wait(&event_queue_monitor_init_cond, &event_queue_monitor_init_lock); Pthread_mutex_unlock(&event_queue_monitor_init_lock); Pthread_attr_init(&attr); Pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); Pthread_attr_setstacksize(&attr, CEREBROD_THREAD_STACKSIZE); Pthread_create(&thread, &attr, cerebrod_event_server, NULL); Pthread_attr_destroy(&attr); /* Wait for initialization to complete */ Pthread_mutex_lock(&event_server_init_lock); while (!event_server_init) Pthread_cond_wait(&event_server_init_cond, &event_server_init_lock); Pthread_mutex_unlock(&event_server_init_lock); Pthread_attr_init(&attr); Pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); Pthread_attr_setstacksize(&attr, CEREBROD_THREAD_STACKSIZE); Pthread_create(&thread, &attr, cerebrod_event_node_timeout_monitor, NULL); Pthread_attr_destroy(&attr); /* Wait for initialization to complete */ Pthread_mutex_lock(&event_node_timeout_monitor_init_lock); while (!event_node_timeout_monitor_init) Pthread_cond_wait(&event_node_timeout_monitor_init_cond, &event_node_timeout_monitor_init_lock); Pthread_mutex_unlock(&event_node_timeout_monitor_init_lock); } /* Start metric controller - see comments at speaker below */ if (conf.metric_controller) { pthread_t thread; pthread_attr_t attr; Pthread_attr_init(&attr); Pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); Pthread_attr_setstacksize(&attr, CEREBROD_THREAD_STACKSIZE); Pthread_create(&thread, &attr, cerebrod_metric_controller, NULL); Pthread_attr_destroy(&attr); /* Wait for initialization to complete */ Pthread_mutex_lock(&metric_controller_init_lock); while (!metric_controller_init) Pthread_cond_wait(&metric_controller_init_cond, &metric_controller_init_lock); Pthread_mutex_unlock(&metric_controller_init_lock); } #endif /* !WITH_CEREBROD_SPEAKER_ONLY */ /* Start speaker * * It may make more logical sense to start the metric controller * after the speaker since metric data cannot be propogated until * after the speaker has finished being setup. We run the speaker * last b/c it is the common case. Most machines (particularly * compute nodes in a cluster) will only speak, and do nothing else. * By having the speaker last, it does not need to run in a thread. * We run it out of "main" instead to minimize memory usage by * not needing to start the speaker in a thread. */ if (conf.speak) cerebrod_speaker(NULL); /* If speak is set, we do not reach this point */ for (;;) sleep(INT_MAX); return 0; /* NOT REACHED */ }
void wait(pthread_mutex_t *mutex) { Pthread_cond_wait(&c, mutex); }