public void ContextSwitch() { lock (CoreContexts) { if (MultiCoreScheduling) { int SelectedCount = 0; for (int Core = 0; Core < KScheduler.CpuCoresCount; Core++) { KCoreContext CoreContext = CoreContexts[Core]; if (CoreContext.ContextSwitchNeeded && (CoreContext.CurrentThread?.Thread.IsCurrentThread() ?? false)) { CoreContext.ContextSwitch(); } if (CoreContext.CurrentThread?.Thread.IsCurrentThread() ?? false) { SelectedCount++; } } if (SelectedCount == 0) { CoreManager.GetThread(Thread.CurrentThread).Pause(); } else if (SelectedCount == 1) { CoreManager.GetThread(Thread.CurrentThread).Unpause(); } else { throw new InvalidOperationException("Thread scheduled in more than one core!"); } } else { KThread CurrentThread = CoreContexts[CurrentCore].CurrentThread; bool HasThreadExecuting = CurrentThread != null; if (HasThreadExecuting) { //This is not the thread that is currently executing, we need //to request an interrupt to allow safely starting another thread. if (!CurrentThread.Thread.IsCurrentThread()) { CurrentThread.Thread.RequestInterrupt(); return; } CoreManager.GetThread(CurrentThread.Thread.Work).Pause(); } //Advance current core and try picking a thread, //keep advancing if it is null. for (int Core = 0; Core < 4; Core++) { CurrentCore = (CurrentCore + 1) % CpuCoresCount; KCoreContext CoreContext = CoreContexts[CurrentCore]; CoreContext.UpdateCurrentThread(); if (CoreContext.CurrentThread != null) { CoreContext.CurrentThread.ClearExclusive(); CoreManager.GetThread(CoreContext.CurrentThread.Thread.Work).Unpause(); CoreContext.CurrentThread.Thread.Execute(); break; } } //If nothing was running before, then we are on a "external" //HLE thread, we don't need to wait. if (!HasThreadExecuting) { return; } } } CoreManager.GetThread(Thread.CurrentThread).Wait(); }
public void Unlock() { if (RecursionCount == 0) { return; } bool DoContextSwitch = false; if (--RecursionCount == 0) { if (System.Scheduler.ThreadReselectionRequested) { System.Scheduler.SelectThreads(); } Monitor.Exit(LockObj); if (System.Scheduler.MultiCoreScheduling) { lock (System.Scheduler.CoreContexts) { for (int Core = 0; Core < KScheduler.CpuCoresCount; Core++) { KCoreContext CoreContext = System.Scheduler.CoreContexts[Core]; if (CoreContext.ContextSwitchNeeded) { AThread CurrentHleThread = CoreContext.CurrentThread?.Context; if (CurrentHleThread == null) { //Nothing is running, we can perform the context switch immediately. CoreContext.ContextSwitch(); } else if (CurrentHleThread.IsCurrentThread()) { //Thread running on the current core, context switch will block. DoContextSwitch = true; } else { //Thread running on another core, request a interrupt. CurrentHleThread.RequestInterrupt(); } } } } } else { DoContextSwitch = true; } } else { Monitor.Exit(LockObj); } if (DoContextSwitch) { System.Scheduler.ContextSwitch(); } }
public void Leave() { if (_recursionCount == 0) { return; } bool doContextSwitch = false; if (--_recursionCount == 0) { if (_system.Scheduler.ThreadReselectionRequested) { _system.Scheduler.SelectThreads(); } Monitor.Exit(LockObj); if (_system.Scheduler.MultiCoreScheduling) { lock (_system.Scheduler.CoreContexts) { for (int core = 0; core < KScheduler.CpuCoresCount; core++) { KCoreContext coreContext = _system.Scheduler.CoreContexts[core]; if (coreContext.ContextSwitchNeeded) { CpuThread currentHleThread = coreContext.CurrentThread?.Context; if (currentHleThread == null) { //Nothing is running, we can perform the context switch immediately. coreContext.ContextSwitch(); } else if (currentHleThread.IsCurrentThread()) { //Thread running on the current core, context switch will block. doContextSwitch = true; } else { //Thread running on another core, request a interrupt. currentHleThread.RequestInterrupt(); } } } } } else { doContextSwitch = true; } } else { Monitor.Exit(LockObj); } if (doContextSwitch) { _system.Scheduler.ContextSwitch(); } }
public void ContextSwitch() { lock (CoreContexts) { if (MultiCoreScheduling) { int selectedCount = 0; for (int core = 0; core < CpuCoresCount; core++) { KCoreContext coreContext = CoreContexts[core]; if (coreContext.ContextSwitchNeeded && (coreContext.CurrentThread?.Context.IsCurrentThread() ?? false)) { coreContext.ContextSwitch(); } if (coreContext.CurrentThread?.Context.IsCurrentThread() ?? false) { selectedCount++; } } if (selectedCount == 0) { CoreManager.Reset(Thread.CurrentThread); } else if (selectedCount == 1) { CoreManager.Set(Thread.CurrentThread); } else { throw new InvalidOperationException("Thread scheduled in more than one core!"); } } else { KThread currentThread = CoreContexts[_currentCore].CurrentThread; bool hasThreadExecuting = currentThread != null; if (hasThreadExecuting) { //If this is not the thread that is currently executing, we need //to request an interrupt to allow safely starting another thread. if (!currentThread.Context.IsCurrentThread()) { currentThread.Context.RequestInterrupt(); return; } CoreManager.Reset(currentThread.Context.Work); } //Advance current core and try picking a thread, //keep advancing if it is null. for (int core = 0; core < 4; core++) { _currentCore = (_currentCore + 1) % CpuCoresCount; KCoreContext coreContext = CoreContexts[_currentCore]; coreContext.UpdateCurrentThread(); if (coreContext.CurrentThread != null) { coreContext.CurrentThread.ClearExclusive(); CoreManager.Set(coreContext.CurrentThread.Context.Work); coreContext.CurrentThread.Context.Execute(); break; } } //If nothing was running before, then we are on a "external" //HLE thread, we don't need to wait. if (!hasThreadExecuting) { return; } } } CoreManager.Wait(Thread.CurrentThread); }