2
1
Fork 0
mirror of https://github.com/yuzu-emu/yuzu.git synced 2024-07-04 23:31:19 +01:00

kernel: changed main thread priority to default, updated Kernel::Reschedule to use PrepareReschedule

This commit is contained in:
bunnei 2014-06-01 21:42:50 -04:00
parent e8a17ee6fd
commit 10447d1f48
6 changed files with 17 additions and 9 deletions

View file

@ -7,6 +7,7 @@
#include "core/mem_map.h" #include "core/mem_map.h"
#include "core/hle/hle.h" #include "core/hle/hle.h"
#include "core/hle/svc.h" #include "core/hle/svc.h"
#include "core/hle/kernel/thread.h"
#include "core/hle/service/service.h" #include "core/hle/service/service.h"
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
@ -41,11 +42,11 @@ void EatCycles(u32 cycles) {
// TODO: ImplementMe // TODO: ImplementMe
} }
void ReSchedule(const char *reason) { void Reschedule(const char *reason) {
#ifdef _DEBUG #ifdef _DEBUG
_dbg_assert_msg_(HLE, reason != 0 && strlen(reason) < 256, "Reschedule: Invalid or too long reason."); _dbg_assert_msg_(HLE, reason != 0 && strlen(reason) < 256, "Reschedule: Invalid or too long reason.");
#endif #endif
// TODO: ImplementMe Core::g_app_core->PrepareReschedule();
} }
void RegisterModule(std::string name, int num_functions, const FunctionDef* func_table) { void RegisterModule(std::string name, int num_functions, const FunctionDef* func_table) {

View file

@ -37,7 +37,7 @@ void CallSVC(u32 opcode);
void EatCycles(u32 cycles); void EatCycles(u32 cycles);
void ReSchedule(const char *reason); void Reschedule(const char *reason);
void Init(); void Init();

View file

@ -14,6 +14,7 @@
namespace Kernel { namespace Kernel {
Handle g_main_thread = 0;
ObjectPool g_object_pool; ObjectPool g_object_pool;
ObjectPool::ObjectPool() { ObjectPool::ObjectPool() {
@ -150,7 +151,7 @@ bool LoadExec(u32 entry_point) {
Core::g_app_core->SetPC(entry_point); Core::g_app_core->SetPC(entry_point);
// 0x30 is the typical main thread priority I've seen used so far // 0x30 is the typical main thread priority I've seen used so far
Handle thread = Kernel::SetupMainThread(0x30); g_main_thread = Kernel::SetupMainThread(THREADPRIO_DEFAULT);
return true; return true;
} }

View file

@ -163,6 +163,7 @@ private:
}; };
extern ObjectPool g_object_pool; extern ObjectPool g_object_pool;
extern Handle g_main_thread;
/** /**
* Loads executable stored at specified address * Loads executable stored at specified address

View file

@ -285,11 +285,11 @@ Handle CreateThread(const char* name, u32 entry_point, s32 priority, u32 arg, s3
HLE::EatCycles(32000); HLE::EatCycles(32000);
CallThread(t);
// This won't schedule to the new thread, but it may to one woken from eating cycles. // This won't schedule to the new thread, but it may to one woken from eating cycles.
// Technically, this should not eat all at once, and reschedule in the middle, but that's hard. // Technically, this should not eat all at once, and reschedule in the middle, but that's hard.
HLE::ReSchedule("thread created"); //HLE::Reschedule("thread created");
CallThread(t);
return handle; return handle;
} }

View file

@ -125,8 +125,11 @@ Result WaitSynchronization1(Handle handle, s64 nano_seconds) {
Result res = object->WaitSynchronization(&wait); Result res = object->WaitSynchronization(&wait);
if (wait) { if (wait) {
// Set current thread to wait state if handle was not unlocked
Kernel::WaitCurrentThread(WAITTYPE_SYNCH); // TODO(bunnei): Is this correct? Kernel::WaitCurrentThread(WAITTYPE_SYNCH); // TODO(bunnei): Is this correct?
Kernel::Reschedule();
// Check for next thread to schedule
HLE::Reschedule(__func__);
// Context switch - Function blocked, is not actually returning (will be "called" again) // Context switch - Function blocked, is not actually returning (will be "called" again)
@ -178,7 +181,9 @@ Result WaitSynchronizationN(void* _out, void* _handles, u32 handle_count, u32 wa
// Set current thread to wait state if not all handles were unlocked // Set current thread to wait state if not all handles were unlocked
Kernel::WaitCurrentThread(WAITTYPE_SYNCH); // TODO(bunnei): Is this correct? Kernel::WaitCurrentThread(WAITTYPE_SYNCH); // TODO(bunnei): Is this correct?
Kernel::Reschedule();
// Check for next thread to schedule
HLE::Reschedule(__func__);
// Context switch - Function blocked, is not actually returning (will be "called" again) // Context switch - Function blocked, is not actually returning (will be "called" again)