From 5af5eef908d88e11025decaf2adab9e1f9594a39 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 27 Jan 2013 16:55:43 -0800 Subject: [PATCH 1/4] Refactor thread deletion so it can be consistent. --- Core/HLE/sceKernelThread.cpp | 56 +++++++++++++++++------------------- 1 file changed, 27 insertions(+), 29 deletions(-) diff --git a/Core/HLE/sceKernelThread.cpp b/Core/HLE/sceKernelThread.cpp index 367ad727fe..12ed515395 100644 --- a/Core/HLE/sceKernelThread.cpp +++ b/Core/HLE/sceKernelThread.cpp @@ -647,10 +647,9 @@ void __KernelListenThreadEnd(ThreadCallback callback) threadEndListeners.push_back(callback); } -void __KernelFireThreadEnd(Thread *thread) +void __KernelFireThreadEnd(SceUID threadID) { - SceUID threadID = thread->GetUID(); - for (std::vector::iterator iter = threadEndListeners.begin(), end = threadEndListeners.end(); iter != end; ++iter) + for (auto iter = threadEndListeners.begin(), end = threadEndListeners.end(); iter != end; ++iter) { ThreadCallback cb = *iter; cb(threadID); @@ -1066,19 +1065,31 @@ void __KernelCancelThreadEndTimeout(SceUID threadID) CoreTiming::UnscheduleEvent(eventThreadEndTimeout, threadID); } -void __KernelRemoveFromThreadQueue(Thread *t) +void __KernelRemoveFromThreadQueue(SceUID threadID) { for (size_t i = 0; i < threadqueue.size(); i++) { - if (threadqueue[i] == t->GetUID()) + if (threadqueue[i] == threadID) { - DEBUG_LOG(HLE, "Deleted thread %p (%i) from thread queue", t, t->GetUID()); + DEBUG_LOG(HLE, "Deleted thread %08x (%i) from thread queue", threadID, threadID); threadqueue.erase(threadqueue.begin() + i); return; } } } +u32 __KernelDeleteThread(SceUID threadID, int exitStatus, const char *reason, bool dontSwitch) +{ + __KernelFireThreadEnd(threadID); + __KernelRemoveFromThreadQueue(threadID); + __KernelTriggerWait(WAITTYPE_THREADEND, threadID, exitStatus, reason, dontSwitch); + + if (currentThread == threadID) + currentThread = 0; + + return kernelObjects.Destroy(threadID); +} + Thread *__KernelNextThread() { // round-robin scheduler // seems to work ? @@ -1446,7 +1457,7 @@ void __KernelReturnFromThread() thread->nt.exitStatus = currentMIPS->r[2]; thread->nt.status = THREADSTATUS_DORMANT; - __KernelFireThreadEnd(thread); + __KernelFireThreadEnd(thread->GetUID()); // TODO: Need to remove the thread from any ready queues. @@ -1464,7 +1475,7 @@ void sceKernelExitThread() ERROR_LOG(HLE,"sceKernelExitThread FAKED"); thread->nt.status = THREADSTATUS_DORMANT; thread->nt.exitStatus = PARAM(0); - __KernelFireThreadEnd(thread); + __KernelFireThreadEnd(thread->GetUID()); __KernelTriggerWait(WAITTYPE_THREADEND, __KernelGetCurThread(), thread->nt.exitStatus, "thread exited", true); hleReSchedule("thread exited"); @@ -1480,7 +1491,7 @@ void _sceKernelExitThread() ERROR_LOG(HLE,"_sceKernelExitThread FAKED"); thread->nt.status = THREADSTATUS_DORMANT; thread->nt.exitStatus = PARAM(0); - __KernelFireThreadEnd(thread); + __KernelFireThreadEnd(thread->GetUID()); __KernelTriggerWait(WAITTYPE_THREADEND, __KernelGetCurThread(), thread->nt.exitStatus, "thread _exited", true); hleReSchedule("thread _exited"); @@ -1498,15 +1509,10 @@ void sceKernelExitDeleteThread() INFO_LOG(HLE,"sceKernelExitDeleteThread()"); t->nt.status = THREADSTATUS_DORMANT; t->nt.exitStatus = PARAM(0); - __KernelFireThreadEnd(t); + error = __KernelDeleteThread(threadHandle, PARAM(0), "thread exited with delete", true); - __KernelRemoveFromThreadQueue(t); - currentThread = 0; - - __KernelTriggerWait(WAITTYPE_THREADEND, threadHandle, t->nt.exitStatus, "thead exited with delete", true); - hleReSchedule("thead exited with delete"); - - RETURN(kernelObjects.Destroy(threadHandle)); + hleReSchedule("thread exited with delete"); + RETURN(error); } else { @@ -1548,13 +1554,8 @@ int sceKernelDeleteThread(int threadHandle) Thread *t = kernelObjects.Get(threadHandle, error); if (t) { - __KernelRemoveFromThreadQueue(t); - __KernelFireThreadEnd(t); - // TODO: Should this reschedule ever? Probably no? - __KernelTriggerWait(WAITTYPE_THREADEND, threadHandle, SCE_KERNEL_ERROR_THREAD_TERMINATED, "thread deleted", true); - - return kernelObjects.Destroy(threadHandle); + return __KernelDeleteThread(threadHandle, SCE_KERNEL_ERROR_THREAD_TERMINATED, "thread deleted", true); } // TODO: Error when doesn't exist? @@ -1578,14 +1579,11 @@ int sceKernelTerminateDeleteThread(int threadno) Thread *t = kernelObjects.Get(threadno, error); if (t) { - __KernelRemoveFromThreadQueue(t); - __KernelFireThreadEnd(t); - //TODO: should we really reschedule here? - __KernelTriggerWait(WAITTYPE_THREADEND, threadno, SCE_KERNEL_ERROR_THREAD_TERMINATED, "thread terminated with delete", false); + error = __KernelDeleteThread(threadno, SCE_KERNEL_ERROR_THREAD_TERMINATED, "thread terminated with delete", false); hleReSchedule("thread terminated with delete"); - return kernelObjects.Destroy(threadno); + return error; } // TODO: Error when doesn't exist? @@ -1610,7 +1608,7 @@ int sceKernelTerminateThread(u32 threadID) { t->nt.exitStatus = SCE_KERNEL_ERROR_THREAD_TERMINATED; t->nt.status = THREADSTATUS_DORMANT; - __KernelFireThreadEnd(t); + __KernelFireThreadEnd(threadID); // TODO: Should this really reschedule? __KernelTriggerWait(WAITTYPE_THREADEND, threadID, t->nt.exitStatus, "thread terminated", true); } From 54e6a39e74d79103d556b1e714108139b134220e Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 27 Jan 2013 17:01:17 -0800 Subject: [PATCH 2/4] Optimize callback checking. Since it's checked every resched, it happens a lot. This could save as much as 1.6% of time. --- Core/HLE/sceKernelThread.cpp | 30 ++++++++++++++++++++++++++++-- 1 file changed, 28 insertions(+), 2 deletions(-) diff --git a/Core/HLE/sceKernelThread.cpp b/Core/HLE/sceKernelThread.cpp index 12ed515395..62b33d5ff3 100644 --- a/Core/HLE/sceKernelThread.cpp +++ b/Core/HLE/sceKernelThread.cpp @@ -456,6 +456,7 @@ bool __KernelCheckThreadCallbacks(Thread *thread, bool force); //STATE BEGIN ////////////////////////////////////////////////////////////////////////// int g_inCbCount = 0; +int readyCallbacksCount = 0; SceUID currentThread; u32 idleThreadHackAddr; u32 threadReturnHackAddr; @@ -562,6 +563,7 @@ void __KernelThreadingInit() dispatchEnabled = true; g_inCbCount = 0; + readyCallbacksCount = 0; idleThreadHackAddr = kernelMemory.Alloc(blockSize, false, "threadrethack"); // Make sure it got allocated where we expect it... at the very start of kernel RAM //CHECK_EQ(idleThreadHackAddr & 0x3FFFFFFF, 0x08000000); @@ -601,6 +603,7 @@ void __KernelThreadingInit() void __KernelThreadingDoState(PointerWrap &p) { p.Do(g_inCbCount); + p.Do(readyCallbacksCount); p.Do(idleThreadHackAddr); p.Do(threadReturnHackAddr); p.Do(cbReturnHackAddr); @@ -1087,6 +1090,15 @@ u32 __KernelDeleteThread(SceUID threadID, int exitStatus, const char *reason, bo if (currentThread == threadID) currentThread = 0; + u32 error; + Thread *t = kernelObjects.Get(threadID, error); + if (t) + { + // TODO: Unless they should be run before deletion? + for (int i = 0; i < THREAD_CALLBACK_NUM_TYPES; i++) + readyCallbacksCount -= t->readyCallbacks[i].size(); + } + return kernelObjects.Destroy(threadID); } @@ -2450,6 +2462,7 @@ bool __KernelCheckThreadCallbacks(Thread *thread, bool force) if (thread->readyCallbacks[i].size()) { SceUID readyCallback = thread->readyCallbacks[i].front(); thread->readyCallbacks[i].pop_front(); + readyCallbacksCount--; // If the callback was deleted, we're good. Just skip it. if (kernelObjects.IsValid(readyCallback)) @@ -2468,6 +2481,14 @@ bool __KernelCheckThreadCallbacks(Thread *thread, bool force) // Checks for callbacks on all threads bool __KernelCheckCallbacks() { + // Let's not check every thread all the time, callbacks are fairly uncommon. + if (readyCallbacksCount == 0) { + return false; + } + if (readyCallbacksCount < 0) { + ERROR_LOG(HLE, "readyCallbacksCount became negative: %i", readyCallbacksCount); + } + // SceUID currentThread = __KernelGetCurThread(); // __GetCurrentThread()->isProcessingCallbacks = true; // do { @@ -2554,8 +2575,13 @@ void __KernelNotifyCallback(RegisteredCallbackType type, SceUID cbId, int notify cb->nc.notifyArg = notifyArg; Thread *t = kernelObjects.Get(cb->nc.threadId, error); - t->readyCallbacks[type].remove(cbId); - t->readyCallbacks[type].push_back(cbId); + std::list &readyCallbacks = t->readyCallbacks[type]; + auto iter = std::find(readyCallbacks.begin(), readyCallbacks.end(), cbId); + if (iter == readyCallbacks.end()) + { + t->readyCallbacks[type].push_back(cbId); + readyCallbacksCount++; + } } // TODO: If cbId == -1, notify the callback ID on all threads that have it. From dcc9f1ae5f2740eb8d0e9d7f738f565c82358b21 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 27 Jan 2013 18:43:12 -0800 Subject: [PATCH 3/4] Always check for more callbacks after running one. --- Core/HLE/sceKernelThread.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/Core/HLE/sceKernelThread.cpp b/Core/HLE/sceKernelThread.cpp index 62b33d5ff3..6b7a4a9e42 100644 --- a/Core/HLE/sceKernelThread.cpp +++ b/Core/HLE/sceKernelThread.cpp @@ -2369,7 +2369,6 @@ void __KernelReturnFromMipsCall() g_inCbCount--; // yeah! back in the real world, let's keep going. Should we process more callbacks? - __KernelCheckThreadCallbacks(cur, !call->reschedAfter); if (!__KernelExecutePendingMipsCalls(call->reschedAfter)) { // Sometimes, we want to stay on the thread. @@ -2440,6 +2439,13 @@ void ActionAfterCallback::run(MipsCall &call) { Callback *cb = kernelObjects.Get(cbId, error); if (cb) { + Thread *t = kernelObjects.Get(cb->nc.threadId, error); + if (t) + { + // Check for other callbacks to run (including ones this callback scheduled.) + __KernelCheckThreadCallbacks(t, true); + } + DEBUG_LOG(HLE, "Left callback %i - %s", cbId, cb->nc.name); // Callbacks that don't return 0 are deleted. But should this be done here? if (currentMIPS->r[MIPS_REG_V0] != 0 || cb->forceDelete) From aeadc80045d55e46fcb8c88ef5be727500ce5f68 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 27 Jan 2013 18:43:38 -0800 Subject: [PATCH 4/4] Recover from an interrupt during a callback. --- Core/HLE/sceKernelThread.cpp | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/Core/HLE/sceKernelThread.cpp b/Core/HLE/sceKernelThread.cpp index 6b7a4a9e42..8193d0f93d 100644 --- a/Core/HLE/sceKernelThread.cpp +++ b/Core/HLE/sceKernelThread.cpp @@ -456,6 +456,8 @@ bool __KernelCheckThreadCallbacks(Thread *thread, bool force); //STATE BEGIN ////////////////////////////////////////////////////////////////////////// int g_inCbCount = 0; +// Normally, the same as currentThread. In an interrupt, remembers the callback's thread id. +SceUID currentCallbackThreadID = 0; int readyCallbacksCount = 0; SceUID currentThread; u32 idleThreadHackAddr; @@ -563,6 +565,7 @@ void __KernelThreadingInit() dispatchEnabled = true; g_inCbCount = 0; + currentCallbackThreadID = 0; readyCallbacksCount = 0; idleThreadHackAddr = kernelMemory.Alloc(blockSize, false, "threadrethack"); // Make sure it got allocated where we expect it... at the very start of kernel RAM @@ -603,6 +606,7 @@ void __KernelThreadingInit() void __KernelThreadingDoState(PointerWrap &p) { p.Do(g_inCbCount); + p.Do(currentCallbackThreadID); p.Do(readyCallbacksCount); p.Do(idleThreadHackAddr); p.Do(threadReturnHackAddr); @@ -703,6 +707,21 @@ void __KernelIdle() // that was triggered at the end of the Idle period must get a chance to be scheduled. CoreTiming::Advance(); + // We must've exited a callback? + if (__KernelInCallback()) + { + u32 error; + Thread *t = kernelObjects.Get(currentCallbackThreadID, error); + if (t) + __KernelSwitchContext(t, "idle"); + else + { + WARN_LOG(HLE, "UNTESTED - Callback thread deleted during interrupt?"); + g_inCbCount = 0; + currentCallbackThreadID = 0; + } + } + // In Advance, we might trigger an interrupt such as vblank. // If we end up in an interrupt, we don't want to reschedule. // However, we have to reschedule... damn. @@ -1089,6 +1108,11 @@ u32 __KernelDeleteThread(SceUID threadID, int exitStatus, const char *reason, bo if (currentThread == threadID) currentThread = 0; + if (currentCallbackThreadID == threadID) + { + currentCallbackThreadID = 0; + g_inCbCount = 0; + } u32 error; Thread *t = kernelObjects.Get(threadID, error); @@ -2331,6 +2355,7 @@ void __KernelExecuteMipsCallOnCurrentThread(int callId, bool reschedAfter) } g_inCbCount++; + currentCallbackThreadID = currentThread; } void __KernelReturnFromMipsCall() @@ -2367,6 +2392,7 @@ void __KernelReturnFromMipsCall() cur->currentCallbackId = call->savedId; g_inCbCount--; + currentCallbackThreadID = 0; // yeah! back in the real world, let's keep going. Should we process more callbacks? if (!__KernelExecutePendingMipsCalls(call->reschedAfter))