int
Ns_SetEvent(Ns_Event *event)
{
Ns_CondSignal((Ns_Cond *) event);
return NS_OK;
}
void
NsQueueConn(Conn *connPtr)
{
Pool *poolPtr = NsGetConnPool(connPtr);
int create = 0;
/*
* Queue connection.
*/
connPtr->flags |= NS_CONN_RUNNING;
Ns_MutexLock(&poolPtr->lock);
++poolPtr->threads.queued;
if (poolPtr->queue.wait.firstPtr == NULL) {
poolPtr->queue.wait.firstPtr = connPtr;
} else {
poolPtr->queue.wait.lastPtr->nextPtr = connPtr;
}
poolPtr->queue.wait.lastPtr = connPtr;
connPtr->nextPtr = NULL;
if (poolPtr->threads.waiting == 0
&& poolPtr->threads.current < poolPtr->threads.max) {
/*
Create a new thread if no thread is waiting and the number
of currently starting or running threads is below max.
*/
create = 1;
}
poolPtr->queue.wait.num ++;
if (create) {
poolPtr->threads.current ++;
Ns_MutexUnlock(&poolPtr->lock);
NsCreateConnThread(poolPtr, 1);
} else if (poolPtr->threads.waiting > 0) {
/*
There are threads waiting. Signal to process
the request.
*/
Ns_CondSignal(&poolPtr->cond);
Ns_MutexUnlock(&poolPtr->lock);
} else {
/*
We might have missed signaling, since we are already using
max resources, and no thread is available. In such a case
the autorecovery at thread exist has to care to process
the outstanding requests
*/
Ns_MutexUnlock(&poolPtr->lock);
}
}
void
Ns_SemaPost(Ns_Sema *semaPtr, int count)
{
Sema *sPtr = (Sema *) *semaPtr;
Ns_MutexLock(&sPtr->lock);
sPtr->count += count;
if (count == 1) {
Ns_CondSignal(&sPtr->cond);
} else {
Ns_CondBroadcast(&sPtr->cond);
}
Ns_MutexUnlock(&sPtr->lock);
}
int main(int argc, char *argv[])
{
int i, code;
Ns_Thread threads[10];
Ns_Thread self, dumper;
void *arg;
char *p;
#if PTHREAD_TEST
pthread_t tids[10];
#endif
NsThreads_LibInit();
Ns_ThreadSetName("-main-");
/*
* Jump directly to memory test if requested.
*/
for (i = 1; i < argc; ++i) {
p = argv[i];
switch (*p) {
case 'n':
break;
case 'm':
nthreads = atoi(p + 1);
goto mem;
break;
}
}
Ns_ThreadCreate(DetachedThread, NULL, 0, NULL);
Ns_ThreadCreate(DumperThread, NULL, 0, &dumper);
Ns_MutexSetName(&lock, "startlock");
Ns_MutexSetName(&dlock, "dumplock");
Ns_MutexSetName(&mlock, "msglock");
Ns_MutexSetName(&block, "busylock");
Ns_ThreadStackSize(81920);
Ns_SemaInit(&sema, 3);
Msg("sema initialized to 3");
atexit(AtExit);
Msg("pid = %d", getpid());
Ns_TlsAlloc(&key, TlsLogArg);
for (i = 0; i < 10; ++i) {
Msg("starting work thread %d", i);
Ns_ThreadCreate(WorkThread, (void *) i, 0, &threads[i]);
}
sleep(1);
/* Ns_CondSignal(&cond); */
Ns_SemaPost(&sema, 10);
Msg("sema post 10");
Ns_RWLockWrLock(&rwlock);
Msg("rwlock write locked (main thread)");
sleep(1);
Ns_RWLockUnlock(&rwlock);
Msg("rwlock write unlocked (main thread)");
for (i = 0; i < 10; ++i) {
Msg("waiting for thread %d to exit", i);
Ns_ThreadJoin(&threads[i], (void **) &code);
Msg("thread %d exited - code: %d", i, code);
}
#if PTHREAD_TEST
for (i = 0; i < 10; ++i) {
pthread_create(&tids[i], NULL, Pthread, (void *) i);
printf("pthread: create %d = %d\n", i, (int) tids[i]);
Ns_ThreadYield();
}
Ns_MutexLock(&plock);
pgo = 1;
Ns_MutexUnlock(&plock);
Ns_CondBroadcast(&pcond);
for (i = 0; i < 10; ++i) {
pthread_join(tids[i], &arg);
printf("pthread: join %d = %d\n", i, (int) arg);
}
#endif
Ns_ThreadSelf(&self);
Ns_MutexLock(&dlock);
dstop = 1;
Ns_CondSignal(&dcond);
Ns_MutexUnlock(&dlock);
Ns_ThreadJoin(&dumper, NULL);
Msg("threads joined");
for (i = 0; i < 10; ++i) {
Ns_ThreadCreate(CheckStackThread, NULL, 8192*(i+1), &threads[i]);
}
for (i = 0; i < 10; ++i) {
Ns_ThreadJoin(&threads[i], &arg);
printf("check stack %d = %d\n", i, (int) arg);
}
/*Ns_ThreadEnum(DumpThreads, NULL);*/
/*Ns_MutexEnum(DumpLocks, NULL);*/
mem:
MemTime(0);
MemTime(1);
return 0;
}
void
NsConnThread(void *arg)
{
ConnData *dataPtr = arg;
Pool *poolPtr = dataPtr->poolPtr;
Conn *connPtr;
Ns_Time wait, *timePtr;
char name[100];
int status, ncons;
char *msg;
double spread;
/*
* Set the conn thread name.
*/
Ns_TlsSet(&ctdtls, dataPtr);
Ns_MutexLock(&poolPtr->lock);
sprintf(name, "-%s:%d-", poolPtr->name, poolPtr->threads.nextid++);
Ns_MutexUnlock(&poolPtr->lock);
Ns_ThreadSetName(name);
/* spread is a value of 1.0 +- specified percentage,
i.e. between 0.0 and 2.0 when the configured percentage is 100 */
spread = 1.0 + (2 * poolPtr->threads.spread * Ns_DRand() - poolPtr->threads.spread) / 100.0;
ncons = round(poolPtr->threads.maxconns * spread);
msg = "exceeded max connections per thread";
/*
* Start handling connections.
*/
Ns_MutexLock(&poolPtr->lock);
poolPtr->threads.starting--;
poolPtr->threads.idle++;
while (poolPtr->threads.maxconns <= 0 || ncons-- > 0) {
/*
* Wait for a connection to arrive, exiting if one doesn't
* arrive in the configured timeout period.
*/
if (poolPtr->threads.current <= poolPtr->threads.min) {
timePtr = NULL;
} else {
Ns_GetTime(&wait);
Ns_IncrTime(&wait, round(poolPtr->threads.timeout * spread), 0);
timePtr = &wait;
}
status = NS_OK;
while (!poolPtr->shutdown
&& status == NS_OK
&& poolPtr->queue.wait.firstPtr == NULL) {
/*
nothing is queued, we wait for a queue entry
*/
poolPtr->threads.waiting++;
status = Ns_CondTimedWait(&poolPtr->cond, &poolPtr->lock, timePtr);
poolPtr->threads.waiting--;
}
if (poolPtr->queue.wait.firstPtr == NULL) {
msg = "timeout waiting for connection";
break;
}
/*
* Pull the first connection off the waiting list.
*/
connPtr = poolPtr->queue.wait.firstPtr;
poolPtr->queue.wait.firstPtr = connPtr->nextPtr;
if (poolPtr->queue.wait.lastPtr == connPtr) {
poolPtr->queue.wait.lastPtr = NULL;
}
connPtr->nextPtr = NULL;
connPtr->prevPtr = poolPtr->queue.active.lastPtr;
if (poolPtr->queue.active.lastPtr != NULL) {
poolPtr->queue.active.lastPtr->nextPtr = connPtr;
}
poolPtr->queue.active.lastPtr = connPtr;
if (poolPtr->queue.active.firstPtr == NULL) {
poolPtr->queue.active.firstPtr = connPtr;
}
poolPtr->threads.idle--;
poolPtr->queue.wait.num--;
Ns_MutexUnlock(&poolPtr->lock);
/*
* Run the connection.
*/
Ns_MutexLock(&connlock);
dataPtr->connPtr = connPtr;
Ns_MutexUnlock(&connlock);
Ns_GetTime(&connPtr->times.run);
ConnRun(connPtr);
Ns_MutexLock(&connlock);
dataPtr->connPtr = NULL;
Ns_MutexUnlock(&connlock);
/*
* Remove from the active list and push on the free list.
*/
Ns_MutexLock(&poolPtr->lock);
if (connPtr->prevPtr != NULL) {
connPtr->prevPtr->nextPtr = connPtr->nextPtr;
} else {
poolPtr->queue.active.firstPtr = connPtr->nextPtr;
}
if (connPtr->nextPtr != NULL) {
connPtr->nextPtr->prevPtr = connPtr->prevPtr;
} else {
poolPtr->queue.active.lastPtr = connPtr->prevPtr;
}
poolPtr->threads.idle++;
Ns_MutexUnlock(&poolPtr->lock);
NsFreeConn(connPtr);
Ns_MutexLock(&poolPtr->lock);
}
/*
* Append this thread to list of threads to reap.
*/
Ns_MutexLock(&joinlock);
dataPtr->nextPtr = joinPtr;
joinPtr = dataPtr;
Ns_MutexUnlock(&joinlock);
/*
* Mark this thread as no longer active.
*/
if (poolPtr->shutdown) {
msg = "shutdown pending";
}
poolPtr->threads.current--;
poolPtr->threads.idle--;
if (((poolPtr->queue.wait.num > 0
&& poolPtr->threads.idle == 0
&& poolPtr->threads.starting == 0
)
|| (poolPtr->threads.current < poolPtr->threads.min)
) && !poolPtr->shutdown) {
/*
Recreate a thread when on of the condings hold
- there are more queue entries are still waiting,
but no thread is either starting or idle, or
- there are less than minthreads connection threads alive.
*/
poolPtr->threads.current ++;
Ns_MutexUnlock(&poolPtr->lock);
NsCreateConnThread(poolPtr, 0); /* joinThreads == 0 to avoid deadlock */
} else if (poolPtr->queue.wait.num > 0 && poolPtr->threads.waiting > 0) {
/*
Wake up a waiting thread
*/
Ns_CondSignal(&poolPtr->cond);
Ns_MutexUnlock(&poolPtr->lock);
} else {
Ns_MutexUnlock(&poolPtr->lock);
}
Ns_Log(Notice, "exiting: %s", msg);
Ns_ThreadExit(dataPtr);
}
