Agent/fix gen5 thread agc compat (#130)

* Fix Gen5 thread and AGC compatibility * Trim compatibility comments * Report selected Vulkan GPU * Clean up CPU title label * Improve emulator frame pacing and performance * Regenerate package locks with pinned SDK --------- Co-authored-by: Spooks4576 <Spooks4576@users.noreply.github.com>
2026-08-01 23:49:44 +08:00 · 2026-07-14 05:41:42 -06:00
parent cf6964710a
commit d43edc865a
24 changed files with 1318 additions and 229 deletions
@@ -80,14 +80,8 @@ public static class KernelAprCompatExports
            return (int)OrbisGen2Result.ORBIS_GEN2_ERROR_NOT_FOUND;
        }

-        var resultAddress = ResolveWaitResultAddress(waitArg1, waitArg2, submission.ResultAddress);
-        if (resultAddress != 0 && !TryWriteAprResult(ctx, resultAddress))
-        {
-            TraceAprWaitFailure(ctx, "wait_result_fault", submissionId, submission.CommandBuffer, waitArg1, waitArg2);
-            return (int)OrbisGen2Result.ORBIS_GEN2_ERROR_MEMORY_FAULT;
-        }
-
-        TraceApr(ctx, "wait", submissionId, submission.CommandBuffer, waitArg1, resultAddress);
+        // Completion output was written when the command was submitted.
+        TraceApr(ctx, "wait", submissionId, submission.CommandBuffer, waitArg1, waitArg2);
        return (int)OrbisGen2Result.ORBIS_GEN2_OK;
    }

@@ -169,27 +163,6 @@ public static class KernelAprCompatExports
        return ctx.Memory.TryWrite(resultAddress, result);
    }

-    private static ulong ResolveWaitResultAddress(ulong waitArg1, ulong waitArg2, ulong submittedResultAddress)
-    {
-        if (waitArg2 == 0)
-        {
-            return submittedResultAddress;
-        }
-
-        if (IsAmprCompletionToken(waitArg1) && waitArg2 <= 0xFFFF)
-        {
-            return submittedResultAddress;
-        }
-
-        return waitArg2;
-    }
-
-    private static bool IsAmprCompletionToken(ulong value)
-    {
-        var tag = value >> 56;
-        return tag is 0x0C or 0x10;
-    }
-
    private static void TraceApr(
        CpuContext ctx,
        string operation,
@@ -11,6 +11,7 @@ public static class KernelEventQueueCompatExports
 {
    private const int KernelEventSize = 0x20;
    public const short KernelEventFilterGraphics = -14;
+    public const short KernelEventFilterUser = -11;
    public const short KernelEventFilterAmpr = -16;
    public const short KernelEventFilterAmprSystem = -17;

@@ -89,8 +90,16 @@ public static class KernelEventQueueCompatExports
        LibraryName = "libKernel")]
    public static int KernelAddUserEventEdge(CpuContext ctx)
    {
-        TraceEventQueue(ctx, "add_user_edge", ctx[CpuRegister.Rdi]);
-        return (int)OrbisGen2Result.ORBIS_GEN2_OK;
+        var handle = ctx[CpuRegister.Rdi];
+        var registered = RegisterEvent(
+            handle,
+            ctx[CpuRegister.Rsi],
+            KernelEventFilterUser,
+            0);
+        TraceEventQueue(ctx, "add_user_edge", handle);
+        return registered
+            ? (int)OrbisGen2Result.ORBIS_GEN2_OK
+            : (int)OrbisGen2Result.ORBIS_GEN2_ERROR_NOT_FOUND;
    }

    [SysAbiExport(
@@ -100,8 +109,16 @@ public static class KernelEventQueueCompatExports
        LibraryName = "libKernel")]
    public static int KernelAddUserEvent(CpuContext ctx)
    {
-        TraceEventQueue(ctx, "add_user", ctx[CpuRegister.Rdi]);
-        return (int)OrbisGen2Result.ORBIS_GEN2_OK;
+        var handle = ctx[CpuRegister.Rdi];
+        var registered = RegisterEvent(
+            handle,
+            ctx[CpuRegister.Rsi],
+            KernelEventFilterUser,
+            0);
+        TraceEventQueue(ctx, "add_user", handle);
+        return registered
+            ? (int)OrbisGen2Result.ORBIS_GEN2_OK
+            : (int)OrbisGen2Result.ORBIS_GEN2_ERROR_NOT_FOUND;
    }

    [SysAbiExport(
@@ -111,8 +128,15 @@ public static class KernelEventQueueCompatExports
        LibraryName = "libKernel")]
    public static int KernelDeleteUserEvent(CpuContext ctx)
    {
-        TraceEventQueue(ctx, "delete_user", ctx[CpuRegister.Rdi]);
-        return (int)OrbisGen2Result.ORBIS_GEN2_OK;
+        var handle = ctx[CpuRegister.Rdi];
+        var deleted = DeleteRegisteredEvent(
+            handle,
+            ctx[CpuRegister.Rsi],
+            KernelEventFilterUser);
+        TraceEventQueue(ctx, "delete_user", handle);
+        return deleted
+            ? (int)OrbisGen2Result.ORBIS_GEN2_OK
+            : (int)OrbisGen2Result.ORBIS_GEN2_ERROR_NOT_FOUND;
    }

    [SysAbiExport(
@@ -122,8 +146,18 @@ public static class KernelEventQueueCompatExports
        LibraryName = "libKernel")]
    public static int KernelTriggerUserEvent(CpuContext ctx)
    {
-        TraceEventQueue(ctx, "trigger_user", ctx[CpuRegister.Rdi]);
-        return (int)OrbisGen2Result.ORBIS_GEN2_OK;
+        var handle = ctx[CpuRegister.Rdi];
+        var triggered = TriggerRegisteredEvent(
+            handle,
+            ctx[CpuRegister.Rsi],
+            KernelEventFilterUser,
+            flags: 0x21,
+            fflags: 0,
+            data: ctx[CpuRegister.Rdx]);
+        TraceEventQueue(ctx, "trigger_user", handle);
+        return triggered
+            ? (int)OrbisGen2Result.ORBIS_GEN2_OK
+            : (int)OrbisGen2Result.ORBIS_GEN2_ERROR_NOT_FOUND;
    }

    [SysAbiExport(
@@ -475,6 +509,43 @@ public static class KernelEventQueueCompatExports
        return triggeredCount;
    }

+    private static bool TriggerRegisteredEvent(
+        ulong handle,
+        ulong ident,
+        short filter,
+        ushort flags,
+        uint fflags,
+        ulong data)
+    {
+        lock (_eventQueueGate)
+        {
+            if (!_registeredEvents.TryGetValue(handle, out var registrations) ||
+                !registrations.TryGetValue((ident, filter), out var registration))
+            {
+                return false;
+            }
+
+            if (!_pendingEvents.TryGetValue(handle, out var queue))
+            {
+                queue = new LinkedList<KernelQueuedEvent>();
+                _pendingEvents[handle] = queue;
+            }
+
+            QueueOrUpdateEvent(
+                queue,
+                new KernelQueuedEvent(
+                    registration.Ident,
+                    registration.Filter,
+                    flags,
+                    fflags,
+                    data,
+                    registration.UserData));
+        }
+
+        WakeEventQueue(handle);
+        return true;
+    }
+
    public static bool TriggerDisplayEvent(
        ulong handle,
        ulong ident,
@@ -656,6 +727,6 @@ public static class KernelEventQueueCompatExports

        _ = ctx.TryReadUInt64(ctx[CpuRegister.Rsp], out ulong returnRip);
        Console.Error.WriteLine(
-            $"[LOADER][TRACE] equeue.{operation}: handle=0x{handle:X16} rsi=0x{ctx[CpuRegister.Rsi]:X16} rdx=0x{ctx[CpuRegister.Rdx]:X16} ret=0x{returnRip:X16}");
+            $"[LOADER][TRACE] equeue.{operation}: thread=0x{KernelPthreadState.GetCurrentThreadHandle():X16} handle=0x{handle:X16} rsi=0x{ctx[CpuRegister.Rsi]:X16} rdx=0x{ctx[CpuRegister.Rdx]:X16} ret=0x{returnRip:X16}");
    }
 }
@@ -3,6 +3,7 @@

 using System.Collections.Concurrent;
 using SharpEmu.HLE;
+using SharpEmu.Libs.Fiber;
 using System.Diagnostics.CodeAnalysis;

 namespace SharpEmu.Libs.Kernel;
@@ -44,6 +45,8 @@ public static class KernelPthreadCompatExports
    // type initializer that first runs on a guest thread and fail-fasts the CLR.
    private static long _nextMutexWakeId;
    private static long _nextCondWakeId;
+    private static readonly ConcurrentDictionary<ulong, long> _posixTimedWaitCounts = new();
+    private static readonly ConcurrentDictionary<ulong, byte> _reportedContendedMutexes = new();

    private sealed class PthreadMutexState
    {
@@ -351,29 +354,95 @@ public static class KernelPthreadCompatExports
        LibraryName = "libKernel")]
    public static int PosixPthreadCondTimedwait(CpuContext ctx)
    {
-        // POSIX passes `const struct timespec *abstime` (absolute deadline), not relative microseconds (#113).
-        var abstimeAddress = ctx[CpuRegister.Rdx];
-        if (abstimeAddress == 0)
+        var absoluteTimeAddress = ctx[CpuRegister.Rdx];
+        if (absoluteTimeAddress == 0 ||
+            !ctx.TryReadUInt64(absoluteTimeAddress, out var secondsRaw) ||
+            !ctx.TryReadUInt64(absoluteTimeAddress + sizeof(ulong), out var nanosecondsRaw))
        {
-            return (int)OrbisGen2Result.ORBIS_GEN2_ERROR_INVALID_ARGUMENT;
+            return ctx.SetReturn(OrbisGen2Result.ORBIS_GEN2_ERROR_INVALID_ARGUMENT);
        }

-        if (!ctx.TryReadUInt64(abstimeAddress, out var deadlineSeconds) ||
-            !ctx.TryReadUInt64(abstimeAddress + 8, out var deadlineNanoseconds))
+        var deadlineSeconds = unchecked((long)secondsRaw);
+        var deadlineNanoseconds = unchecked((long)nanosecondsRaw);
+        if (deadlineSeconds < 0 || deadlineNanoseconds is < 0 or >= 1_000_000_000)
        {
-            return (int)OrbisGen2Result.ORBIS_GEN2_ERROR_MEMORY_FAULT;
+            return ctx.SetReturn(OrbisGen2Result.ORBIS_GEN2_ERROR_INVALID_ARGUMENT);
        }

-        var nowMicroseconds = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() * 1000L;
-        var deadlineMicroseconds =
-            deadlineSeconds >= long.MaxValue / 1_000_000UL
-                ? long.MaxValue
-                : (long)(deadlineSeconds * 1_000_000UL + Math.Min(deadlineNanoseconds, 999_999_999UL) / 1000UL);
-        var remainingMicroseconds = deadlineMicroseconds - nowMicroseconds;
-        var timeoutUsec = remainingMicroseconds <= 0
-            ? 1u
-            : (uint)Math.Min(remainingMicroseconds, uint.MaxValue);
-        return PthreadCondWaitCore(ctx, ctx[CpuRegister.Rdi], ctx[CpuRegister.Rsi], timed: true, timeoutUsec: timeoutUsec);
+        long nowSeconds;
+        long nowNanoseconds;
+        if (deadlineSeconds >= 1_000_000_000)
+        {
+            var now = DateTimeOffset.UtcNow;
+            nowSeconds = now.ToUnixTimeSeconds();
+            nowNanoseconds = (now.Ticks % TimeSpan.TicksPerSecond) * 100;
+        }
+        else
+        {
+            // Engine condition variables use monotonic deadlines.
+            KernelRuntimeCompatExports.GetProcessMonotonicTime(out nowSeconds, out nowNanoseconds);
+        }
+
+        var remainingNanoseconds =
+            ((Int128)deadlineSeconds * 1_000_000_000 + deadlineNanoseconds) -
+            ((Int128)nowSeconds * 1_000_000_000 + nowNanoseconds);
+        var timeoutUsec = remainingNanoseconds <= 0
+            ? 0u
+            : (uint)Int128.Min(uint.MaxValue, (remainingNanoseconds + 999) / 1_000);
+
+        TracePosixTimedWait(
+            ctx,
+            deadlineSeconds,
+            deadlineNanoseconds,
+            nowSeconds,
+            nowNanoseconds,
+            remainingNanoseconds,
+            timeoutUsec);
+
+        return PthreadCondWaitCore(
+            ctx,
+            ctx[CpuRegister.Rdi],
+            ctx[CpuRegister.Rsi],
+            timed: true,
+            timeoutUsec,
+            posixResult: true);
+    }
+
+    private static void TracePosixTimedWait(
+        CpuContext ctx,
+        long deadlineSeconds,
+        long deadlineNanoseconds,
+        long nowSeconds,
+        long nowNanoseconds,
+        Int128 remainingNanoseconds,
+        uint timeoutUsec)
+    {
+        var condAddress = ctx[CpuRegister.Rdi];
+        var count = _posixTimedWaitCounts.AddOrUpdate(condAddress, 1, static (_, current) => current + 1);
+        if (count != 1 && count % 1_000_000 != 0)
+        {
+            return;
+        }
+
+        _ = ctx.TryReadUInt64(ctx[CpuRegister.Rsp], out var returnRip);
+        Console.Error.WriteLine(
+            $"[LOADER][DIAG] pthread_cond_timedwait#{count}: thread=0x{KernelPthreadState.GetCurrentThreadHandle():X16} " +
+            $"cond=0x{condAddress:X16} mutex=0x{ctx[CpuRegister.Rsi]:X16} abstime=0x{ctx[CpuRegister.Rdx]:X16} " +
+            $"deadline={deadlineSeconds}.{deadlineNanoseconds:D9} now={nowSeconds}.{nowNanoseconds:D9} " +
+            $"remaining_ns={remainingNanoseconds} timeout_us={timeoutUsec} ret=0x{returnRip:X16}");
+
+        if (GuestThreadExecution.Scheduler is not { } scheduler)
+        {
+            return;
+        }
+
+        foreach (var snapshot in scheduler.SnapshotThreads())
+        {
+            Console.Error.WriteLine(
+                $"[LOADER][DIAG] guest_thread handle=0x{snapshot.ThreadHandle:X16} name='{snapshot.Name}' " +
+                $"state={snapshot.State} imports={snapshot.ImportCount} nid={snapshot.LastImportNid ?? "none"} " +
+                $"ret=0x{snapshot.LastReturnRip:X16} block={snapshot.BlockReason ?? "none"}");
+        }
    }

    [SysAbiExport(
@@ -654,11 +723,12 @@ public static class KernelPthreadCompatExports
        var acquired = state.Semaphore.Wait(0);
        if (!acquired)
        {
+            TraceContendedMutex(ctx, mutexAddress, resolvedAddress, state, currentThreadId);
            var waiter = new PthreadMutexWaiter { ThreadId = currentThreadId };
-            // Cooperative deschedule on a contended lock corrupts fiber state
-            // (Demon's Souls sceFiberSwitch -> ESRCH). Off by default: fall through to the
-            // synchronous host-thread wait below.
-            if (_enableMutexLockBlocking &&
+            // Fibers retain the synchronous fallback to preserve switch state.
+            var currentFiber = FiberExports.GetCurrentFiberAddressForDiagnostics(ctx);
+            var canCooperativelyBlock = _enableMutexLockBlocking || currentFiber == 0;
+            if (canCooperativelyBlock &&
                !tryOnly &&
                GuestThreadExecution.IsGuestThread &&
                GuestThreadExecution.TryGetCurrentImportCallFrame(out _) &&
@@ -697,6 +767,53 @@ public static class KernelPthreadCompatExports
        return (int)OrbisGen2Result.ORBIS_GEN2_OK;
    }

+    private static void TraceContendedMutex(
+        CpuContext ctx,
+        ulong mutexAddress,
+        ulong resolvedAddress,
+        PthreadMutexState state,
+        ulong currentThreadId)
+    {
+        if (!_reportedContendedMutexes.TryAdd(resolvedAddress, 0))
+        {
+            return;
+        }
+
+        ulong ownerThreadId;
+        int recursionCount;
+        int type;
+        lock (state)
+        {
+            ownerThreadId = state.OwnerThreadId;
+            recursionCount = state.RecursionCount;
+            type = state.Type;
+        }
+
+        _ = ctx.TryReadUInt64(ctx[CpuRegister.Rsp], out var returnRip);
+        Console.Error.WriteLine(
+            $"[LOADER][DIAG] pthread_mutex_contended: waiter=0x{currentThreadId:X16} owner=0x{ownerThreadId:X16} " +
+            $"mutex=0x{mutexAddress:X16} resolved=0x{resolvedAddress:X16} recursion={recursionCount} " +
+            $"type={type} semaphore_count={state.Semaphore.CurrentCount} ret=0x{returnRip:X16}");
+
+        if (GuestThreadExecution.Scheduler is not { } scheduler)
+        {
+            return;
+        }
+
+        foreach (var snapshot in scheduler.SnapshotThreads())
+        {
+            if (snapshot.ThreadHandle != currentThreadId && snapshot.ThreadHandle != ownerThreadId)
+            {
+                continue;
+            }
+
+            Console.Error.WriteLine(
+                $"[LOADER][DIAG] pthread_mutex_party handle=0x{snapshot.ThreadHandle:X16} name='{snapshot.Name}' " +
+                $"state={snapshot.State} imports={snapshot.ImportCount} nid={snapshot.LastImportNid ?? "none"} " +
+                $"ret=0x{snapshot.LastReturnRip:X16} block={snapshot.BlockReason ?? "none"}");
+        }
+    }
+
    private static int PthreadMutexUnlockCore(CpuContext ctx, ulong mutexAddress, bool requireOwner)
    {
        if (mutexAddress == 0)
@@ -1076,6 +1193,13 @@ public static class KernelPthreadCompatExports

        lock (_stateGate)
        {
+            if (_condStates.TryGetValue(condAddress, out var raced))
+            {
+                resolvedAddress = condAddress;
+                state = raced;
+                return true;
+            }
+
            _condStates[condAddress] = createdState;
            _condStates[handle] = createdState;
        }
@@ -1172,7 +1296,13 @@ public static class KernelPthreadCompatExports
        return (int)OrbisGen2Result.ORBIS_GEN2_OK;
    }

-    private static int PthreadCondWaitCore(CpuContext ctx, ulong condAddress, ulong mutexAddress, bool timed, uint timeoutUsec = 0)
+    private static int PthreadCondWaitCore(
+        CpuContext ctx,
+        ulong condAddress,
+        ulong mutexAddress,
+        bool timed,
+        uint timeoutUsec = 0,
+        bool posixResult = false)
    {
        if (condAddress == 0 || mutexAddress == 0)
        {
@@ -1210,9 +1340,10 @@ public static class KernelPthreadCompatExports

            if (consumedPendingSignal)
            {
-                // Leave SyncRoot before relocking the mutex to avoid lock-order inversion with cond-signal (#113).
                state.Waiters = Math.Max(0, state.Waiters - 1);
                TracePthreadCond("wait-wake-pending", condAddress, mutexAddress, state, timed, waitResult);
+
+                // Relock outside SyncRoot to preserve lock ordering.
                Monitor.Exit(state.SyncRoot);
                try
                {
@@ -1221,6 +1352,7 @@ public static class KernelPthreadCompatExports
                }
                finally
                {
+                    // Balance the surrounding lock statement.
                    Monitor.Enter(state.SyncRoot);
                }
            }
@@ -1231,7 +1363,7 @@ public static class KernelPthreadCompatExports
                    ctx,
                    timed ? "pthread_cond_timedwait" : "pthread_cond_wait",
                    state.WakeKey,
-                    () => ResumePthreadCondWait(ctx, condAddress, mutexAddress, state, observedEpoch, timed, releasedRecursion),
+                    () => ResumePthreadCondWait(ctx, condAddress, mutexAddress, state, observedEpoch, timed, releasedRecursion, posixResult),
                    () => state.SignalEpoch != observedEpoch,
                    timed ? GuestThreadExecution.ComputeDeadlineTimestamp(GetCondWaitTimeout(timeoutUsec)) : 0))
            {
@@ -1315,7 +1447,7 @@ public static class KernelPthreadCompatExports
            state,
            timed,
            waitResult);
-        return waitResult;
+        return TranslatePthreadResult(waitResult, posixResult);
    }

    private static int PthreadCondSignalCore(CpuContext ctx, ulong condAddress, bool broadcast)
@@ -1372,7 +1504,8 @@ public static class KernelPthreadCompatExports
        PthreadCondState state,
        ulong observedEpoch,
        bool timed,
-        int releasedRecursion)
+        int releasedRecursion,
+        bool posixResult)
    {
        var waitResult = (int)OrbisGen2Result.ORBIS_GEN2_OK;
        lock (state.SyncRoot)
@@ -1393,7 +1526,32 @@ public static class KernelPthreadCompatExports
        }

        var lockResult = PthreadMutexRelockForCondWait(ctx, mutexAddress, releasedRecursion);
-        return lockResult == (int)OrbisGen2Result.ORBIS_GEN2_OK ? waitResult : lockResult;
+        return TranslatePthreadResult(
+            lockResult == (int)OrbisGen2Result.ORBIS_GEN2_OK ? waitResult : lockResult,
+            posixResult);
+    }
+
+    private static int TranslatePthreadResult(int result, bool posixResult)
+    {
+        if (!posixResult || result == (int)OrbisGen2Result.ORBIS_GEN2_OK)
+        {
+            return result;
+        }
+
+        return result switch
+        {
+            (int)OrbisGen2Result.ORBIS_GEN2_ERROR_PERMISSION_DENIED => 1, // EPERM
+            (int)OrbisGen2Result.ORBIS_GEN2_ERROR_NOT_FOUND => 2,        // ENOENT
+            (int)OrbisGen2Result.ORBIS_GEN2_ERROR_INVALID_ARGUMENT => 22, // EINVAL
+            (int)OrbisGen2Result.ORBIS_GEN2_ERROR_DEADLOCK => 11,        // EDEADLK
+            (int)OrbisGen2Result.ORBIS_GEN2_ERROR_DELETED => 13,         // EACCES
+            (int)OrbisGen2Result.ORBIS_GEN2_ERROR_BUSY => 16,            // EBUSY
+            (int)OrbisGen2Result.ORBIS_GEN2_ERROR_TRY_AGAIN => 35,       // EAGAIN
+            (int)OrbisGen2Result.ORBIS_GEN2_ERROR_TIMED_OUT => 60,       // ETIMEDOUT
+            (int)OrbisGen2Result.ORBIS_GEN2_ERROR_CANCELED => 85,        // ECANCELED
+            (int)OrbisGen2Result.ORBIS_GEN2_ERROR_MEMORY_FAULT => 14,    // EFAULT
+            _ => result
+        };
    }

    private static string GetCondWakeKey(ulong resolvedCondAddress) =>
@@ -1559,7 +1717,10 @@ public static class KernelPthreadCompatExports
            return TimeSpan.Zero;
        }

-        return TimeSpan.FromTicks((long)timeoutUsec * 10L);
+        // Round positive sub-millisecond waits to the host sleep quantum.
+        return timeoutUsec < 1_000
+            ? TimeSpan.FromMilliseconds(1)
+            : TimeSpan.FromTicks((long)timeoutUsec * 10L);
    }

    private static TimeSpan GetCondSpuriousWakeTimeout()
@@ -1701,7 +1862,8 @@ public static class KernelPthreadCompatExports
        }

        Console.Error.WriteLine(
-            $"[LOADER][TRACE] pthread_cond_{operation}: cond=0x{condAddress:X16} mutex=0x{mutexAddress:X16} " +
+            $"[LOADER][TRACE] pthread_cond_{operation}: thread=0x{KernelPthreadState.GetCurrentThreadHandle():X16} " +
+            $"cond=0x{condAddress:X16} key={state?.WakeKey ?? "none"} mutex=0x{mutexAddress:X16} " +
            $"waiters={(state?.Waiters ?? 0)} epoch=0x{(state?.SignalEpoch ?? 0):X} timed={timed} result=0x{unchecked((uint)result):X8}");
    }

@@ -213,6 +213,13 @@ public static class KernelRuntimeCompatExports
        return (int)OrbisGen2Result.ORBIS_GEN2_OK;
    }

+    [SysAbiExport(
+        Nid = "QcteRwbsnV0",
+        ExportName = "usleep",
+        Target = Generation.Gen4 | Generation.Gen5,
+        LibraryName = "libKernel")]
+    public static int PosixUsleep(CpuContext ctx) => KernelUsleep(ctx);
+
    private static void TraceUsleepSpin(CpuContext ctx, ulong micros)
    {
        if (!_traceUsleep)