mirrors/Ryujinx
mirrors/Ryujinx
1
0
Fork 0
mirror of https://github.com/Ryujinx/Ryujinx.git synced 2024-10-01 12:30:00 +02:00
Code Wiki Activity

Add SvcSetThreadActivity, tweak SignalProcessWideKey, add fmul32i shader instructions and other small fixes

Browse source
This commit is contained in:
gdkchan 2018-04-19 16:18:30 -03:00
parent 33ae6e544b
commit 03002f6537
9 changed files with 139 additions and 24 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
ChocolArm64/AThread.cs
View file

@ -54,6 +54,14 @@ namespace ChocolArm64
return true;
}
public void StopExecution() => ThreadState.Running = false;
public void StopExecution()
{
ThreadState.Running = false;
}
public bool IsCurrentThread()
{
return Thread.CurrentThread == Work;
}
}
}

85
Ryujinx.Core/OsHle/Handles/KProcessScheduler.cs
View file

@ -15,11 +15,15 @@ namespace Ryujinx.Core.OsHle.Handles
public AutoResetEvent WaitEvent { get; private set; }
public bool Active { get; set; }
public SchedulerThread(KThread Thread)
{
this.Thread = Thread;
WaitEvent = new AutoResetEvent(false);
Active = true;
}
public void Dispose()
@ -98,7 +102,10 @@ namespace Ryujinx.Core.OsHle.Handles
public bool Remove(SchedulerThread SchedThread)
{
return Threads.Remove(SchedThread);
lock (Threads)
{
return Threads.Remove(SchedThread);
}
}
}
@ -180,6 +187,55 @@ namespace Ryujinx.Core.OsHle.Handles
}
}
public void SetThreadActivity(KThread Thread, bool Active)
{
if (!AllThreads.TryGetValue(Thread, out SchedulerThread SchedThread))
{
throw new InvalidOperationException();
}
lock (SchedLock)
{
bool OldState = SchedThread.Active;
SchedThread.Active = Active;
if (!OldState && Active)
{
if (ActiveProcessors.Add(Thread.ProcessorId))
{
RunThread(SchedThread);
}
else
{
WaitingToRun[Thread.ProcessorId].Push(SchedThread);
PrintDbgThreadInfo(Thread, "entering wait state...");
}
}
else if (OldState && !Active)
{
if (Thread.Thread.IsCurrentThread())
{
Suspend(Thread.ProcessorId);
PrintDbgThreadInfo(Thread, "entering inactive wait state...");
}
else
{
WaitingToRun[Thread.ProcessorId].Remove(SchedThread);
}
}
}
if (!Active && Thread.Thread.IsCurrentThread())
{
SchedThread.WaitEvent.WaitOne();
PrintDbgThreadInfo(Thread, "resuming execution...");
}
}
public void Suspend(int ProcessorId)
{
lock (SchedLock)
@ -222,9 +278,7 @@ namespace Ryujinx.Core.OsHle.Handles
public void Resume(KThread Thread)
{
SchedulerThread SchedThread;
if (!AllThreads.TryGetValue(Thread, out SchedThread))
if (!AllThreads.TryGetValue(Thread, out SchedulerThread SchedThread))
{
throw new InvalidOperationException();
}
@ -236,18 +290,25 @@ namespace Ryujinx.Core.OsHle.Handles
{
KThread Thread = SchedThread.Thread;
lock (SchedLock)
if (SchedThread.Active)
{
if (ActiveProcessors.Add(Thread.ProcessorId))
lock (SchedLock)
{
PrintDbgThreadInfo(Thread, "resuming execution...");
if (ActiveProcessors.Add(Thread.ProcessorId))
{
PrintDbgThreadInfo(Thread, "resuming execution...");
return;
return;
}
WaitingToRun[Thread.ProcessorId].Push(SchedThread);
PrintDbgThreadInfo(Thread, "entering wait state...");
}
PrintDbgThreadInfo(Thread, "entering wait state...");
WaitingToRun[Thread.ProcessorId].Push(SchedThread);
}
else
{
PrintDbgThreadInfo(Thread, "entering inactive wait state...");
}
SchedThread.WaitEvent.WaitOne();

21
Ryujinx.Core/OsHle/Kernel/ConditionVariable.cs
View file

@ -57,7 +57,7 @@ namespace Ryujinx.Core.OsHle.Kernel
Count = Process.Memory.ReadInt32(CondVarAddress);
if (Count > 0)
if (Result && Count > 0)
{
Process.Memory.WriteInt32(CondVarAddress, Count - 1);
}
@ -73,10 +73,10 @@ namespace Ryujinx.Core.OsHle.Kernel
{
if (Count < 0)
{
Process.Memory.WriteInt32(CondVarAddress, WaitingThreads.Count);
foreach ((_, AutoResetEvent WaitEvent) in WaitingThreads)
{
IncrementCondVarValue();
WaitEvent.Set();
}
@ -84,8 +84,6 @@ namespace Ryujinx.Core.OsHle.Kernel
}
else
{
Process.Memory.WriteInt32(CondVarAddress, Count);
while (WaitingThreads.Count > 0 && Count-- > 0)
{
int HighestPriority = WaitingThreads[0].Thread.Priority;
@ -101,6 +99,8 @@ namespace Ryujinx.Core.OsHle.Kernel
}
}
IncrementCondVarValue();
WaitingThreads[HighestPrioIndex].WaitEvent.Set();
WaitingThreads.RemoveAt(HighestPrioIndex);
@ -111,6 +111,17 @@ namespace Ryujinx.Core.OsHle.Kernel
Process.Scheduler.Yield(Thread);
}
private void IncrementCondVarValue()
{
AcquireCondVarValue();
int Count = Process.Memory.ReadInt32(CondVarAddress);
Process.Memory.WriteInt32(CondVarAddress, Count + 1);
ReleaseCondVarValue();
}
private void AcquireCondVarValue()
{
if (!OwnsCondVarValue)

3
Ryujinx.Core/OsHle/Kernel/SvcHandler.cs
View file

@ -63,7 +63,8 @@ namespace Ryujinx.Core.OsHle.Kernel
{ 0x25, SvcGetThreadId },
{ 0x26, SvcBreak },
{ 0x27, SvcOutputDebugString },
{ 0x29, SvcGetInfo }
{ 0x29, SvcGetInfo },
{ 0x32, SvcSetThreadActivity }
};
this.Ns = Ns;

23
Ryujinx.Core/OsHle/Kernel/SvcThread.cs
View file

@ -147,7 +147,28 @@ namespace Ryujinx.Core.OsHle.Kernel
}
else
{
Logging.Warn(LogClass.KernelSvc, $"Tried to GetThreadId on invalid thread handle 0x{Handle:x8}!");
Logging.Warn(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!");
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
}
}
private void SvcSetThreadActivity(AThreadState ThreadState)
{
int Handle = (int)ThreadState.X0;
bool Active = (int)ThreadState.X1 != 0;
KThread CurrThread = Process.HandleTable.GetData<KThread>(Handle);
if (CurrThread != null)
{
Process.Scheduler.SetThreadActivity(CurrThread, Active);
ThreadState.X0 = 0;
}
else
{
Logging.Warn(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!");
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
}

2
Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs
View file

@ -193,7 +193,7 @@ namespace Ryujinx.Graphics.Gal.Shader
}
else if (DeclInfo.Name == GlslDecl.FragmentOutputName)
{
Name = "layout (location = 0) out " + GetDecl(DeclInfo) + ";";
Name = "layout (location = 0) out " + GetDecl(DeclInfo) + ";" + Environment.NewLine;
}
else
{

13
Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs
View file

@ -41,6 +41,16 @@ namespace Ryujinx.Graphics.Gal.Shader
EmitAluFfma(Block, OpCode, ShaderOper.RR);
}
public static void Fmul32i(ShaderIrBlock Block, long OpCode)
{
ShaderIrNode OperA = GetOperGpr8 (OpCode);
ShaderIrNode OperB = GetOperImmf32_20(OpCode);
ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Fmul, OperA, OperB);
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode));
}
public static void Fmul_C(ShaderIrBlock Block, long OpCode)
{
EmitAluBinaryF(Block, OpCode, ShaderOper.CR, ShaderIrInst.Fmul);
@ -212,7 +222,6 @@ namespace Ryujinx.Graphics.Gal.Shader
bool Aa = ((OpCode >> 46) & 1) != 0;
bool Na = ((OpCode >> 48) & 1) != 0;
bool Ab = ((OpCode >> 49) & 1) != 0;
bool Ad = ((OpCode >> 50) & 1) != 0;
ShaderIrNode OperA = GetOperGpr8(OpCode), OperB;
@ -234,8 +243,6 @@ namespace Ryujinx.Graphics.Gal.Shader
ShaderIrNode Op = new ShaderIrOp(Inst, OperA, OperB);
Op = GetAluAbs(Op, Ad);
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode));
}

5
Ryujinx.Graphics/Gal/Shader/ShaderDecodeHelper.cs
View file

@ -70,6 +70,11 @@ namespace Ryujinx.Graphics.Gal.Shader
return new ShaderIrOperImm((int)(OpCode >> 20));
}
public static ShaderIrOperImmf GetOperImmf32_20(long OpCode)
{
return new ShaderIrOperImmf(BitConverter.Int32BitsToSingle((int)(OpCode >> 20)));
}
public static ShaderIrOperImm GetOperImm19_20(long OpCode)
{
int Value = (int)(OpCode >> 20) & 0x7ffff;

1
Ryujinx.Graphics/Gal/Shader/ShaderOpCodeTable.cs
View file

@ -27,6 +27,7 @@ namespace Ryujinx.Graphics.Gal.Shader
Set("001100101xxxxx", ShaderDecode.Ffma_I);
Set("010100011xxxxx", ShaderDecode.Ffma_RC);
Set("010110011xxxxx", ShaderDecode.Ffma_RR);
Set("00011110xxxxxx", ShaderDecode.Fmul32i);
Set("0100110001101x", ShaderDecode.Fmul_C);
Set("0011100x01101x", ShaderDecode.Fmul_I);
Set("0101110001101x", ShaderDecode.Fmul_R);