static int join(Ejs *ejs, EjsVar *workers, int timeout)
{
MprTime mark, remaining;
int result, count, total;
mark = mprGetTime(ejs);
ejs->joining = 1;
do {
/*
* Must process all pending messages
*/
total = 0;
while ((count = mprServiceEvents(ejs->dispatcher, 0, MPR_SERVICE_EVENTS)) > 0) {
total += count;
}
ejs->joining = !reapJoins(ejs, workers);
if (total == 0 && ejs->joining) {
mprWaitForCond(ejs->dispatcher->cond, timeout);
}
remaining = mprGetRemainingTime(ejs, mark, timeout);
} while (ejs->joining && remaining > 0 && !ejs->exception);
if (ejs->exception) {
return 0;
}
result = (ejs->joining) ? MPR_ERR_TIMEOUT: 0;
ejs->joining = 0;
return result;
}
/*
Wait for an event to occur on the dispatcher and service the event. This is not called by mprServiceEvents.
The dispatcher may be "started" and owned by the thread, or it may be unowned.
WARNING: the event may have already happened by the time this API is invoked.
WARNING: this will enable GC while sleeping.
*/
PUBLIC int mprWaitForEvent(MprDispatcher *dispatcher, MprTicks timeout, int64 mark)
{
MprEventService *es;
MprTicks expires, delay;
int runEvents, changed;
if (dispatcher == NULL) {
dispatcher = MPR->dispatcher;
}
if (dispatcher->flags & MPR_DISPATCHER_DESTROYED) {
return 0;
}
if ((runEvents = (dispatcher->owner == mprGetCurrentOsThread())) != 0) {
/* Called from an event on a running dispatcher */
assert(isRunning(dispatcher) || (dispatcher->flags & MPR_DISPATCHER_DESTROYED));
if (dispatchEvents(dispatcher)) {
return 0;
}
}
es = MPR->eventService;
es->now = mprGetTicks();
expires = timeout < 0 ? MPR_MAX_TIMEOUT : (es->now + timeout);
if (expires < 0) {
expires = MPR_MAX_TIMEOUT;
}
delay = expires - es->now;
lock(es);
delay = getDispatcherIdleTicks(dispatcher, delay);
dispatcher->flags |= MPR_DISPATCHER_WAITING;
changed = dispatcher->mark != mark && mark != -1;
unlock(es);
if (changed) {
return 0;
}
mprYield(MPR_YIELD_STICKY);
mprWaitForCond(dispatcher->cond, delay);
mprResetYield();
es->now = mprGetTicks();
lock(es);
dispatcher->flags &= ~MPR_DISPATCHER_WAITING;
unlock(es);
if (runEvents) {
dispatchEvents(dispatcher);
assert(isRunning(dispatcher) || (dispatcher->flags & MPR_DISPATCHER_DESTROYED));
}
return 0;
}
/*
Do a performance benchmark
*/
static void doBenchmark(void *thread)
{
MprTime start;
MprList *list;
int count, i;
MprMutex *lock;
MprSpin *spin;
mprPrintf("Group\t%-30s\t%13s\t%12s\n", "Benchmark", "Microsec", "Elapsed-sec");
testMalloc();
if (!app->testAllocOnly) {
/*
Locking primitives
*/
mprPrintf("Lock Benchmarks\n");
lock = mprCreateLock();
count = 5000000 * app->iterations;
start = startMark();
for (i = 0; i < count; i++) {
mprLock(lock);
mprUnlock(lock);
}
endMark(start, count, "Mutex lock|unlock");
/*
Locking primitives
*/
mprPrintf("Lock Benchmarks\n");
spin = mprCreateSpinLock();
count = 5000000 * app->iterations;
start = startMark();
for (i = 0; i < count; i++) {
mprSpinLock(spin);
mprSpinUnlock(spin);
}
endMark(start, count, "Spin lock|unlock");
/*
Condition signal / wait
*/
mprPrintf("Cond Benchmarks\n");
count = 1000000 * app->iterations;
start = startMark();
mprResetCond(app->complete);
for (i = 0; i < count; i++) {
mprSignalCond(app->complete);
mprWaitForCond(app->complete, -1);
}
endMark(start, count, "Cond signal|wait");
/*
List
*/
mprPrintf("List Benchmarks\n");
count = 2000000 * app->iterations;
list = mprCreateList(count, 0);
start = startMark();
for (i = 0; i < count; i++) {
mprAddItem(list, (void*) (long) i);
mprRemoveItem(list, (void*) (long) i);
}
endMark(start, count, "Link insert|remove");
/*
Events
*/
mprPrintf("Event Benchmarks\n");
mprResetCond(app->complete);
count = 30000 * app->iterations;
app->markCount = count;
start = startMark();
for (i = 0; i < count; i++) {
mprCreateEvent(NULL, "eventBenchmark", 0, eventCallback, ITOP(i), MPR_EVENT_QUICK);
}
mprWaitForCond(app->complete, -1);
endMark(start, count, "Event (create|run|delete)");
/*
Test timer creation, run and remove
These create a new dispatcher and run a worker thread.
*/
mprPrintf("Timer\n");
mprResetCond(app->complete);
count = 20000 * app->iterations;
app->markCount = count;
start = startMark();
for (i = 0; i < count; i++) {
mprCreateTimerEvent(NULL, "timerBenchmark", 0, timerCallback, (void*) (long) i, 0);
}
mprWaitForCond(app->complete, -1);
endMark(start, count, "Timer (create|delete)");
/*
Alloc (1K)
*/
mprPrintf("Alloc 1K Benchmarks\n");
count = 2000000 * app->iterations;
start = startMark();
for (i = 0; i < count; i++) {
mprAlloc(1024);
if ((i % 128) == 0) {
mprGC(0);
}
}
endMark(start, count, "Alloc mprAlloc(1K)");
}
testComplete = 1;
}
/*
* Do a performance benchmark
*/
static void doBenchmark(Mpr *mpr, void *thread)
{
MprTime start;
MprList *list;
void *mp;
int count, i;
#if BLD_FEATURE_MULTITHREAD
MprMutex *lock;
#endif
complete = mprCreateCond(mpr);
mprPrintf(mpr, "Group\t%-30s\t%13s\t%12s\n", "Benchmark", "Microsec", "Elapsed-sec");
/*
* Alloc (1K)
*/
mprPrintf(mpr, "Alloc Benchmarks\n");
count = 2000000 * iterations;
start = startMark(mpr);
for (i = 0; i < count; i++) {
mp = mprAlloc(mpr, 1024);
memset(mp, 0, 1024);
mprFree(mp);
}
endMark(mpr, start, count, "Alloc mprAlloc(1K)|mprFree");
start = startMark(mpr);
#if BLD_FEATURE_MULTITHREAD
/*
* Locking primitives
*/
mprPrintf(mpr, "Lock Benchmarks\n");
lock = mprCreateLock(mpr);
count = 5000000 * iterations;
start = startMark(mpr);
for (i = 0; i < count; i++) {
mprLock(lock);
mprUnlock(lock);
}
endMark(mpr, start, count, "Mutex lock|unlock");
mprFree(lock);
/*
* Condition signal / wait
*/
mprPrintf(mpr, "Cond Benchmarks\n");
count = 1000000 * iterations;
start = startMark(mpr);
mprResetCond(complete);
for (i = 0; i < count; i++) {
mprSignalCond(complete);
mprWaitForCond(complete, -1);
}
endMark(mpr, start, count, "Cond signal|wait");
#endif
/*
* List
*/
mprPrintf(mpr, "List Benchmarks\n");
count = 500000 * iterations;
list = mprCreateList(mpr);
start = startMark(mpr);
for (i = 0; i < count; i++) {
mprAddItem(list, (void*) (long) i);
mprRemoveItem(list, (void*) (long) i);
}
endMark(mpr, start, count, "Link insert|remove");
mprFree(list);;
/*
* Events
*/
mprPrintf(mpr, "Event Benchmarks\n");
mprResetCond(complete);
count = 200000 * iterations;
markCount = count;
start = startMark(mpr);
for (i = 0; i < count; i++) {
mprCreateEvent(mprGetDispatcher(mpr), eventCallback, 0, 0, (void*) (long) i, 0);
}
endMark(mpr, start, count, "Event (create)");
mprWaitForCondWithService(complete, -1);
endMark(mpr, start, count, "Event (run|delete)");
/*
* Test timer creation, run and delete (make a million timers!)
*/
mprPrintf(mpr, "Timer\n");
mprResetCond(complete);
count = 50000 * iterations;
markCount = count;
start = startMark(mpr);
for (i = 0; i < count; i++) {
mprCreateTimerEvent(mprGetDispatcher(mpr), timerCallback, 0, 0, (void*) (long) i, 0);
}
endMark(mpr, start, count, "Timer (create)");
mprWaitForCondWithService(complete, -1);
endMark(mpr, start, count, "Timer (delete)");
testComplete = 1;
}
