void checkEventFlag(int doDispatch) {
SceUID flag = sceKernelCreateEventFlag("eventflag", 0, 0xFFFFFFFF, NULL);
dispatchCheckpoint("sceKernelCreateEventFlag: %08x", flag >= 0 ? 1 : flag);
dispatchCheckpoint("sceKernelClearEventFlag: %08x", sceKernelClearEventFlag(flag, 1));
dispatchCheckpoint("sceKernelWaitEventFlag: %08x", sceKernelWaitEventFlag(flag, 1, PSP_EVENT_WAITAND, NULL, NULL));
dispatchCheckpoint("sceKernelWaitEventFlag invalid: %08x", sceKernelWaitEventFlag(flag, 0, 0, NULL, NULL));
dispatchCheckpoint("sceKernelDeleteEventFlag: %08x", sceKernelDeleteEventFlag(flag));
flag = sceKernelCreateEventFlag("test", 0, 0xFFFFFFFF, NULL);
dispatchCheckpoint("sceKernelCreateEventFlag: %08x", flag >= 0 ? 1 : flag);
startLockThreadEventFlag(flag);
int state;
if (doDispatch) {
++ignoreResched;
state = sceKernelSuspendDispatchThread();
dispatchCheckpoint("sceKernelSuspendDispatchThread: %08x", state);
}
SceUInt timeout = 300;
dispatchCheckpoint("sceKernelWaitEventFlag: %08x", sceKernelWaitEventFlag(flag, 1, PSP_EVENT_WAITAND, NULL, &timeout));
dispatchCheckpoint("sceKernelClearEventFlag: %08x", sceKernelClearEventFlag(flag, 1));
if (doDispatch) {
dispatchCheckpoint("sceKernelResumeDispatchThread: %08x", sceKernelResumeDispatchThread(state));
--ignoreResched;
}
endLockThreadEventFlag(flag);
dispatchCheckpoint("sceKernelPollEventFlag: %08x", sceKernelPollEventFlag(flag, 1, PSP_EVENT_WAITAND, NULL));
dispatchCheckpoint("sceKernelDeleteEventFlag: %08x", sceKernelDeleteEventFlag(flag));
}
int main(int argc, char **argv) {
SceUID flag = sceKernelCreateEventFlag("set", 0, 0, NULL);
PRINT_FLAG(flag);
testClear("Basic 0x2", flag, 0x2);
testClear("Basic 0x1", flag, 0x1);
testClear("Basic 0x1", flag, 0x1);
testClear("Basic 0xF000", flag, 0xF000);
testClear("Zero", flag, 0);
sceKernelDeleteEventFlag(flag);
flag = sceKernelCreateEventFlag("signal", 0, 0xFFFFFFFE, NULL);
PRINT_FLAG(flag);
testClear("All but 0x1 + 0x1", flag, 0x1);
sceKernelDeleteEventFlag(flag);
testClear("NULL", 0, 1);
testClear("Invalid", 0xDEADBEEF, 1);
testClear("Deleted", flag, 1);
BASIC_SCHED_TEST("NULL",
result = sceKernelClearEventFlag(0, 0);
);
int main(int argc, char **argv) {
SceUID flag = sceKernelCreateEventFlag("refer1", 0, 0, NULL);
SceKernelEventFlagInfo flaginfo;
// Crashes.
//REFER_TEST("NULL info", flag, NULL);
REFER_TEST("Normal", flag, &flaginfo);
sceKernelDeleteEventFlag(flag);
REFER_TEST("NULL", 0, &flaginfo);
REFER_TEST("Invalid", 0xDEADBEEF, &flaginfo);
REFER_TEST("Deleted", flag, &flaginfo);
BASIC_SCHED_TEST("NULL",
result = sceKernelReferEventFlagStatus(NULL, &flaginfo);
);
void sceGuTerm(void)
{
sceKernelDeleteEventFlag(gu_settings.kernel_event_flag);
sceGeUnsetCallback(gu_settings.ge_callback_id);
}
int main(int argc, char *argv[])
{
SceCtrlData pad;
int result;
int oldButtons = 0;
pspDebugScreenInit();
if (argc > 0) {
printf("Bootpath: %s\n", argv[0]);
}
printf("Triangle - Exit\n");
printf("Square - Set lower 16-bits\n");
printf("Circle - Clear lower 16-bits\n");
printf("Cross - Delay + refer status\n");
printf("R-Trigger - Cancel event flag\n\n");
printf("L-Trigger - Delete event flag\n\n");
SetupCallbacks();
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
evid = sceKernelCreateEventFlag("test_ef", PSP_EVENT_WAITMULTIPLE, INITIAL_PATTERN, 0);
//evid = sceKernelCreateEventFlag("test_ef", 0, INITIAL_PATTERN, 0);
printf("EVID: %08x pattern %08x\n", evid, INITIAL_PATTERN);
if (evid >= 0)
{
createStartThread("and", and_thread);
createStartThread("or", or_thread);
createStartThread("clear", clear_thread);
#if 0
// testing context switch timing
sceKernelSetEventFlag(evid, 0x0000FFFF);
//int buf[64]; for(;;) sceCtrlReadLatch(buf); // sceCtrlReadLatch does not context switch
for(;;) sceKernelDelayThread(0); // does not wait forever
#else
while(!done)
{
sceCtrlReadBufferPositive(&pad, 1); // context switch in here
int buttonDown = (oldButtons ^ pad.Buttons) & pad.Buttons;
if (buttonDown & PSP_CTRL_SQUARE)
{
result = sceKernelSetEventFlag(evid, 0x0000FFFF);
printf("\nsceKernelSetEventFlag result %08x\n", result);
printSceKernelEventFlagInfo(evid);
}
if (buttonDown & PSP_CTRL_CIRCLE)
{
//result = sceKernelClearEventFlag(evid, 0x0000FFFF); // bits to clear - bad
result = sceKernelClearEventFlag(evid, 0xFFFF0000); // bits to keep - ok
printf("\nsceKernelClearEventFlag result %08x\n", result);
printSceKernelEventFlagInfo(evid);
}
if (buttonDown & PSP_CTRL_CROSS)
{
printf("\nsceKernelDelayThreadCB ...\n");
sceKernelDelayThreadCB(1000);
printSceKernelEventFlagInfo(evid);
}
if (buttonDown & PSP_CTRL_RTRIGGER)
{
//result = sceKernelCancelEventFlag(evid, newPattern, addr);
result = sceKernelCancelEventFlag(evid, INITIAL_PATTERN, 0);
printf("sceKernelCancelEventFlag result %08x\n", result);
printSceKernelEventFlagInfo(evid);
}
if (buttonDown & PSP_CTRL_LTRIGGER)
{
//result = sceKernelCancelEventFlag(evid, newPattern, addr);
result = sceKernelDeleteEventFlag(evid);
printf("sceKernelDeleteEventFlag result %08x\n", result);
evid = 0;
}
if (buttonDown & PSP_CTRL_TRIANGLE)
done = 1;
oldButtons = pad.Buttons;
//sceKernelDelayThread(0); // ok, not infinite :)
}
#endif
}
else
{
printf("sceKernelCreateEventFlag failed %08x\n", evid);
sceKernelSleepThreadCB();
}
sceKernelExitGame();
return 0;
}
int main(int argc, char **argv) {
SceUID flag = sceKernelCreateEventFlag("wait1", 0, 0xFFFFFFFF, NULL);
SceKernelEventFlagInfo flaginfo;
// Something weird is happening: first time status is garbled?
sceKernelReferEventFlagStatus(flag, &flaginfo);
WAIT_TEST_SIMPLE("And 0x00000000", flag, 0, PSP_EVENT_WAITAND, 1);
WAIT_TEST_SIMPLE("Or 0x00000000", flag, 0, PSP_EVENT_WAITOR, 1);
WAIT_TEST_SIMPLE("Clear 0x00000000", flag, 0, PSP_EVENT_WAITCLEAR, 1);
WAIT_TEST_SIMPLE("Wrong (0x04) 0x00000000", flag, 0, 0x04, 1);
WAIT_TEST_SIMPLE("Wrong (0xFF) 0x00000000", flag, 0, 0xFF, 1);
WAIT_TEST_SIMPLE("And 0x00000001", flag, 1, PSP_EVENT_WAITAND, 1);
WAIT_TEST_SIMPLE("Or 0x00000001", flag, 1, PSP_EVENT_WAITOR, 1);
WAIT_TEST_SIMPLE("Clear 0x00000001", flag, 1, PSP_EVENT_WAITCLEAR, 1);
WAIT_TEST_SIMPLE("Wrong (0x02) 0x00000001", flag, 1, 0x02, 1);
WAIT_TEST_SIMPLE("Wrong (0x04) 0x00000001", flag, 1, 0x04, 1);
WAIT_TEST_SIMPLE("Wrong (0x08) 0x00000001", flag, 1, 0x08, 1);
WAIT_TEST_SIMPLE("Wrong (0x40) 0x00000001", flag, 1, 0x40, 1);
WAIT_TEST_SIMPLE("Wrong (0x80) 0x00000001", flag, 1, 0x80, 1);
WAIT_TEST_SIMPLE("Wrong (0xFF) 0x00000001", flag, 1, 0xFF, 1);
sceKernelSetEventFlag(flag, 0xFFFFFFFF);
WAIT_TEST_SIMPLE("Clear/Or 0x00000000", flag, 0, PSP_EVENT_WAITCLEAR | PSP_EVENT_WAITOR, 1);
sceKernelSetEventFlag(flag, 0xFFFFFFFF);
WAIT_TEST_SIMPLE("Clear/Or 0x00000001", flag, 1, PSP_EVENT_WAITCLEAR | PSP_EVENT_WAITOR, 1);
sceKernelSetEventFlag(flag, 0xFFFFFFFF);
WAIT_TEST_SIMPLE("Clear/Or 0x00000001 (no out bits)", flag, 1, PSP_EVENT_WAITCLEAR | PSP_EVENT_WAITOR, 0);
sceKernelSetEventFlag(flag, 0xFFFFFFFF);
WAIT_TEST_SIMPLE_TIMEOUT("0xFFFFFFFF & 0x00000000", flag, 0x00000000, PSP_EVENT_WAITAND, 500);
WAIT_TEST_SIMPLE_TIMEOUT("0xFFFFFFFF & 0xFFFFFFFF", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND, 500);
WAIT_TEST_SIMPLE_TIMEOUT("0xFFFFFFFF | 0xFFFFFFFF", flag, 0xFFFFFFFF, PSP_EVENT_WAITOR, 500);
sceKernelClearEventFlag(flag, 0x0000FFFF);
WAIT_TEST_SIMPLE_TIMEOUT("0x0000FFFF & 0xFFFFFFFF", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND, 500);
WAIT_TEST_SIMPLE_TIMEOUT("0x0000FFFF | 0xFFFFFFFF", flag, 0xFFFFFFFF, PSP_EVENT_WAITOR, 500);
WAIT_TEST_SIMPLE_TIMEOUT("0x0000FFFF & 0xFFFFFFFF with clear", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND | PSP_EVENT_WAITCLEAR, 500);
WAIT_TEST_SIMPLE_TIMEOUT("0x0000FFFF | 0xFFFFFFFF with clear", flag, 0xFFFFFFFF, PSP_EVENT_WAITOR | PSP_EVENT_WAITCLEAR, 500);
sceKernelClearEventFlag(flag, 0x0000FFFF);
WAIT_TEST_SIMPLE_TIMEOUT("0x0000FFFF & 0xFFFFFFFF with clear all", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND | PSP_EVENT_WAITCLEARALL, 500);
WAIT_TEST_SIMPLE_TIMEOUT("0x0000FFFF | 0xFFFFFFFF with clear all", flag, 0xFFFFFFFF, PSP_EVENT_WAITOR | PSP_EVENT_WAITCLEARALL, 500);
sceKernelClearEventFlag(flag, 0x00000000);
WAIT_TEST_SIMPLE_TIMEOUT("0x00000000 & 0xFFFFFFFF", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND, 500);
WAIT_TEST_SIMPLE_TIMEOUT("Zero timeout", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND, 0);
WAIT_TEST_SIMPLE_TIMEOUT("5ms timeout", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND, 5);
// Set off thread.
schedulingLogPos = 0;
schedulingPlacement = 1;
SCHED_LOG(A, 1);
SceUInt timeout = 5000;
SceUID thread = sceKernelCreateThread("waitTest", (void *)&waitTestFunc, 0x12, 0x10000, 0, NULL);
sceKernelStartThread(thread, sizeof(flag), &flag);
SCHED_LOG(B, 1);
int result = sceKernelWaitEventFlag(flag, 0xFFFFFFFF, PSP_EVENT_WAITAND, NULL, &timeout);
SCHED_LOG(E, 1);
printf("Wait timeout: %s (thread=%08X, main=%08X, remaining=%d)\n", schedulingLog, schedulingResult, result, (timeout + 5) / 1000);
sceKernelDeleteEventFlag(flag);
SceUID deleteThread = CREATE_SIMPLE_THREAD(deleteMeFunc);
flag = sceKernelCreateEventFlag("wait1", 0, 0x00000000, NULL);
sceKernelStartThread(deleteThread, sizeof(int), &flag);
sceKernelDelayThread(500);
sceKernelDeleteEventFlag(flag);
WAIT_TEST_SIMPLE("NULL", 0, 0, PSP_EVENT_WAITAND, 0);
WAIT_TEST_SIMPLE("Invalid", 0xDEADBEEF, 0, PSP_EVENT_WAITAND, 0);
WAIT_TEST_SIMPLE("Deleted", flag, 0, PSP_EVENT_WAITAND, 0);
BASIC_SCHED_TEST("NULL",
result = sceKernelWaitEventFlag(0, 0xFFFFFFFF, PSP_EVENT_WAITAND, NULL, NULL);
);
