int thread_select (int n, fd_set *rfds, fd_set *wfds, void *event, TVAL timeout) { thread_t *thr = current_thread; struct timeval *ptv, tv; char dummy; int rc; if (timeout == TV_INFINITE) ptv = NULL; else { tv.tv_sec = timeout / 1000; tv.tv_usec = (timeout % 1000) * 1000; ptv = &tv; } if (event) { thr->thr_event = event; thr->thr_event_pipe = _ev_pipes[1]; if (rfds == NULL) rfds = &thr->thr_rfds; FD_SET (_ev_pipes[0], rfds); if (_ev_pipes[0] >= n) n = _ev_pipes[0] + 1; Q_LOCK (); thread_queue_to (&_waitq, thr); Q_UNLOCK (); } _thread_num_wait++; thr->thr_status = WAITEVENT; for (;;) { if ((rc = select (n, rfds, wfds, NULL, ptv)) == -1) { switch (errno) { case EINTR: continue; default: break; } thr_errno = errno; } else thr_errno = 0; break; } thr->thr_status = RUNNING; _thread_num_wait--; if (event) { thr->thr_event = NULL; thr->thr_event_pipe = -1; if (rc > 0 && FD_ISSET (_ev_pipes[0], rfds)) { read (_ev_pipes[0], &dummy, 1); rc = 0; } Q_LOCK (); thread_queue_remove (&_waitq, thr); Q_UNLOCK (); } return rc; }
thread_t * thread_create ( thread_init_func initial_function, unsigned long stack_size, void *initial_argument) { thread_t *thr; int rc; assert (_main_thread != NULL); if (stack_size == 0) stack_size = THREAD_STACK_SIZE; #if (SIZEOF_VOID_P == 8) stack_size *= 2; #endif #if defined (__x86_64 ) && defined (SOLARIS) /*GK: the LDAP on that platform requires that */ stack_size *= 2; #endif #ifdef HPUX_ITANIUM64 stack_size += 8 * 8192; #endif stack_size = ((stack_size / 8192) + 1) * 8192; #if defined (PTHREAD_STACK_MIN) if (stack_size < PTHREAD_STACK_MIN) { stack_size = PTHREAD_STACK_MIN; } #endif /* Any free threads with the right stack size? */ Q_LOCK (); for (thr = (thread_t *) _deadq.thq_head.thr_next; thr != (thread_t *) &_deadq.thq_head; thr = (thread_t *) thr->thr_hdr.thr_next) { /* if (thr->thr_stack_size >= stack_size) */ break; } Q_UNLOCK (); /* No free threads, create a new one */ if (thr == (thread_t *) &_deadq.thq_head) { #ifndef OLD_PTHREADS size_t os_stack_size = stack_size; #endif thr = thread_alloc (); thr->thr_initial_function = initial_function; thr->thr_initial_argument = initial_argument; thr->thr_stack_size = stack_size; if (thr->thr_cv == NULL) goto failed; #ifdef HPUX_ITANIUM64 if (stack_size > PTHREAD_STACK_MIN) { size_t s, rses; pthread_attr_getstacksize (&_thread_attr, &s); pthread_attr_getrsestacksize_np (&_thread_attr, &rses); log_error ("default rses=%d stack=%d : %m", rses,s); } #endif #ifndef OLD_PTHREADS # if defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE) rc = pthread_attr_setstacksize (&_thread_attr, stack_size); if (rc) { log_error ("Failed setting the OS thread stack size to %d : %m", stack_size); } # endif #if defined(HAVE_PTHREAD_ATTR_GETSTACKSIZE) if (0 == pthread_attr_getstacksize (&_thread_attr, &os_stack_size)) { if (os_stack_size > 4 * 8192) stack_size = thr->thr_stack_size = ((unsigned long) os_stack_size) - 4 * 8192; } #endif #ifdef HPUX_ITANIUM64 if (stack_size > PTHREAD_STACK_MIN) { size_t rsestack_size = stack_size / 2; rc = pthread_attr_setrsestacksize_np (&_thread_attr, rsestack_size); if (rc) { log_error ("Failed setting the OS thread 'rse' stack size to %d (plain stack size set to %d) : %m", rsestack_size, stack_size); } thr->thr_stack_size /= 2; } #endif rc = pthread_create ((pthread_t *) thr->thr_handle, &_thread_attr, _thread_boot, thr); CKRET (rc); /* rc = pthread_detach (*(pthread_t *) thr->thr_handle); */ /* CKRET (rc); */ #else /* OLD_PTHREAD */ rc = pthread_attr_setstacksize (&_thread_attr, stack_size); CKRET (rc); rc = pthread_create ((pthread_t *) thr->thr_handle, _thread_attr, _thread_boot, thr); CKRET (rc); /* rc = pthread_detach ((pthread_t *) thr->thr_handle); */ /* CKRET (rc); */ #endif _thread_num_total++; #if 0 if (DO_LOG(LOG_THR)) log_info ("THRD_0 OS threads create (%i)", _thread_num_total); #endif thread_set_priority (thr, NORMAL_PRIORITY); } else { Q_LOCK (); thread_queue_remove (&_deadq, thr); _thread_num_dead--; Q_UNLOCK (); assert (thr->thr_status == DEAD); /* Set new context for the thread and resume it */ thr->thr_initial_function = initial_function; thr->thr_initial_argument = initial_argument; thr->thr_status = RUNNABLE; rc = pthread_cond_signal ((pthread_cond_t *) thr->thr_cv); CKRET (rc); /* if (DO_LOG(LOG_THR)) log_info ("THRD_3 OS threads reuse. Info threads - total (%ld) wait (%ld) dead (%ld)", _thread_num_total, _thread_num_wait, _thread_num_dead);*/ } return thr; failed: if (thr->thr_status == RUNNABLE) { _thread_free_attributes (thr); dk_free (thr, sizeof (thread_t)); } return NULL; }
void thread_exit (int n) { thread_t *thr = current_thread; volatile int is_attached = thr->thr_attached; if (thr == _main_thread) { call_exit (n); } thr->thr_retcode = n; thr->thr_status = DEAD; if (is_attached) { thr->thr_status = TERMINATE; goto terminate; } Q_LOCK (); thread_queue_to (&_deadq, thr); _thread_num_dead++; do { int rc = pthread_cond_wait ((pthread_cond_t *) thr->thr_cv, (pthread_mutex_t*) &_q_lock->mtx_mtx); CKRET (rc); } while (thr->thr_status == DEAD); Q_UNLOCK (); if (thr->thr_status == TERMINATE) goto terminate; /* Jumps back into _thread_boot */ longjmp (thr->thr_init_context, 1); failed: thread_queue_remove (&_deadq, thr); _thread_num_dead--; Q_UNLOCK (); terminate: if (thr->thr_status == TERMINATE) { #ifndef OLD_PTHREADS pthread_detach (* (pthread_t *)thr->thr_handle); #else pthread_detach ( (pthread_t *)thr->thr_handle); #endif _thread_free_attributes (thr); dk_free ((void *) thr->thr_cv, sizeof (pthread_cond_t)); semaphore_free (thr->thr_sem); semaphore_free (thr->thr_schedule_sem); dk_free (thr->thr_handle, sizeof (pthread_t)); thr_free_alloc_cache (thr); dk_free (thr, sizeof (thread_t)); } if (!is_attached) { _thread_num_total--; pthread_exit ((void *) 1L); } }