MprCmd *mprCreateCmd(MprCtx ctx)
{
MprCmdService *cs;
MprCmd *cmd;
MprCmdFile *files;
int i;
cmd = mprAllocObjWithDestructorZeroed(ctx, MprCmd, cmdDestructor);
if (cmd == 0) {
return 0;
}
cmd->completeCond = mprCreateCond(cmd);
cmd->timeoutPeriod = MPR_TIMEOUT_CMD;
cmd->timestamp = mprGetTime(cmd);
cmd->forkCallback = (MprForkCallback) closeFiles;
#if VXWORKS
cmd->startCond = semCCreate(SEM_Q_PRIORITY, SEM_EMPTY);
cmd->exitCond = semCCreate(SEM_Q_PRIORITY, SEM_EMPTY);
#endif
files = cmd->files;
for (i = 0; i < MPR_CMD_MAX_PIPE; i++) {
files[i].clientFd = -1;
files[i].fd = -1;
}
#if BLD_FEATURE_MULTITHREAD
cmd->mutex = mprCreateLock(cmd);
#endif
cs = mprGetMpr(ctx)->cmdService;
mprLock(cs->mutex);
mprAddItem(cs->cmds, cmd);
mprUnlock(cs->mutex);
return cmd;
}
MAIN(benchMpr, int argc, char **argv, char **envp)
{
MprThread *thread;
Mpr *mpr;
char *argp;
int err, nextArg;
if ((mpr = mprCreate(argc, argv, MPR_USER_EVENTS_THREAD)) == 0) {
return MPR_ERR_MEMORY;
}
if ((app = mprAllocObj(App, manageApp)) == 0) {
return MPR_ERR_MEMORY;
}
mprAddRoot(app);
app->mutex = mprCreateLock(mpr);
app->complete = mprCreateCond();
app->iterations = 5;
err = 0;
for (nextArg = 1; nextArg < argc; nextArg++) {
argp = argv[nextArg];
if (*argp != '-') {
break;
}
if (strcmp(argp, "--iterations") == 0 || strcmp(argp, "-i") == 0) {
if (nextArg >= argc) {
err++;
} else {
app->iterations = atoi(argv[++nextArg]);
}
} else if (strcmp(argp, "--alloc") == 0 || strcmp(argp, "-a") == 0) {
app->testAllocOnly++;
} else {
err++;
}
}
if (err) {
mprEprintf("usage: bench [-a] [-i iterations]\n");
mprEprintf("usage: %s [options]\n"
" -a # Alloc test only\n"
" --iterations count # Number of iterations to run the test\n",
mprGetAppName(mpr));
exit(2);
}
mprStart(mpr);
thread = mprCreateThread("bench", (MprThreadProc) doBenchmark, (void*) MPR, 0);
mprStartThread(thread);
while (!testComplete) {
mprServiceEvents(250, 0);
}
mprPrintMem("Memory Report", 0);
mprDestroy();
return 0;
}
/*
Create the overall dispatch service. There may be many event dispatchers.
*/
PUBLIC MprEventService *mprCreateEventService()
{
MprEventService *es;
if ((es = mprAllocObj(MprEventService, manageEventService)) == 0) {
return 0;
}
MPR->eventService = es;
es->now = mprGetTicks();
es->mutex = mprCreateLock();
es->waitCond = mprCreateCond();
es->runQ = createQhead("running");
es->readyQ = createQhead("ready");
es->idleQ = createQhead("idle");
es->pendingQ = createQhead("pending");
es->waitQ = createQhead("waiting");
return es;
}
PUBLIC MprDispatcher *mprCreateDispatcher(cchar *name, int flags)
{
MprEventService *es;
MprDispatcher *dispatcher;
es = MPR->eventService;
if ((dispatcher = mprAllocObj(MprDispatcher, manageDispatcher)) == 0) {
return 0;
}
dispatcher->flags = flags;
dispatcher->service = es;
dispatcher->name = name;
dispatcher->cond = mprCreateCond();
dispatcher->eventQ = mprCreateEventQueue();
dispatcher->currentQ = mprCreateEventQueue();
queueDispatcher(es->idleQ, dispatcher);
return dispatcher;
}
static void testCriticalSection(MprTestGroup *gp)
{
MprCond *cond;
MprEvent *event;
int rc;
cond = mprCreateCond(gp);
assert(cond != 0);
mprAssert(cond->triggered == 0);
/*
* Create an event to signal the condition var in 10 msec
*/
event = mprCreateEvent(mprGetDispatcher(gp), callback, 0, 0, (void*) cond, 0);
assert(event != 0);
rc = mprWaitForCondWithService(cond, MPR_TEST_TIMEOUT);
assert(rc == 0);
mprFree(cond);
mprFree(event);
}
/*
* 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;
}
