nx2: get title 4 past the difficulty confirm

- MME: implement MME_DMA_READ / MME_DMA_READ_FIFOED (Turing macros read query
  results into their load FIFO; the conditional-render macro at 0x142 needs it).
- vi2 present waits up to 4 s for the frame fence (was 250 ms) so shader
  compile stalls don't let the game lap its equal-value gate semaphores.
- Native QMD: fire the third release slot at word 52, which NVN2 patches for
  queue-to-queue syncs (compute queue releasing a gate the 3D queue waits on).
- Compute class SET_REPORT_SEMAPHORE (0x6c0-0x6c3) releases.
- Ampere lowering: AOFFI, any LOP3 truth table, STG RZ, LDG 0x981, IABS,
  I2FP rounding, IMAD negated addend, SHFL 0x989 (all 77 title-4 shaders lower).
- Debug: EDEN_NX2_SEM_WATCH=<addr> traces acquires, releases, method
  arguments and compute macro emits for one semaphore block;
  EDEN_NX2_KEY_SCRIPT scripted key presses; per-submit logs moved to TRACE.
This commit is contained in:
Takoroka 2026-10-28 00:24:14 -04:00
commit f6cf565bbb
15 changed files with 334 additions and 64 deletions

View file

@ -421,7 +421,7 @@ NvResult nvhost_gpu::SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, Tegra::CommandL
if (g_nx2_driver) {
for (const auto& entry : entries.command_lists) {
LOG_DEBUG(Service_NVDRV, "nx2 GPFIFO entry raw={:#018x} addr={:#x} size={:#x}", entry.raw,
LOG_TRACE(Service_NVDRV, "nx2 GPFIFO entry raw={:#018x} addr={:#x} size={:#x}", entry.raw,
entry.addr.Value(), entry.size.Value());
}
static const bool check = std::getenv("EDEN_NX2_PB_CHECK") != nullptr;
@ -471,7 +471,7 @@ NvResult nvhost_gpu::SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, Tegra::CommandL
}
if (g_nx2_driver) {
LOG_DEBUG(Service_NVDRV,
LOG_TRACE(Service_NVDRV,
"nx2 SubmitGPFIFO entries={} flags={:#x} fence_out=({}, {}) guest_value={}",
params.num_entries, flags.raw, params.fence.id, params.fence.value,
system.Host1x().GetSyncpointManager().GetGuestSyncpointValue(params.fence.id));

View file

@ -580,17 +580,25 @@ private:
// free, so pace the game here instead: wait (bounded, in case the GPU waits on the CPU) until
// Eden's GPU thread has processed the frame. Otherwise the game laps the GPU thread and
// rewrites command memory it hasn't read yet.
u32 m_wait_timeouts{};
void WaitForFrame(u32 fence_id, u32 fence_value) {
if (fence_id >= 192) {
return;
}
auto& syncpoints = system.Host1x().GetSyncpointManager();
const auto start = std::chrono::steady_clock::now();
const auto deadline = start + std::chrono::milliseconds{250};
// Long enough to cover shader/pipeline compile stalls: a game that gets more than a few
// command buffers ahead misses the equal-value gates its other channels acquire.
const auto deadline = start + std::chrono::milliseconds{4000};
while (!syncpoints.IsReadyGuest(fence_id, fence_value) &&
std::chrono::steady_clock::now() < deadline && system.IsPoweredOn()) {
std::this_thread::sleep_for(std::chrono::microseconds{200});
}
if (!syncpoints.IsReadyGuest(fence_id, fence_value) && m_wait_timeouts++ < 64) {
LOG_WARNING(Service, "nx2:vi2 present #{} fence ({}, {}) not reached in 4 s (now {})",
m_presents, fence_id, fence_value, syncpoints.GetGuestSyncpointValue(fence_id));
}
if (m_presents <= 8 || (m_presents % 600) == 0) {
LOG_INFO(Service, "nx2:vi2 present #{} fence ({}, {}) now {}, waited {} us",
m_presents, fence_id, fence_value, syncpoints.GetGuestSyncpointValue(fence_id),

View file

@ -53,7 +53,7 @@ inline LoweredProgram LowerToMaxwell(std::span<const Instruction> code) {
for (const auto& instruction : code) {
const u32 op = instruction.Bits(0, 12);
uses_uniform_bank |= op == 0x3c4 || op == 0x2bd || op == 0xc0c || op == 0x986 || op == 0x9a8 || op == 0xc12 || op == 0xc17 || op == 0xe24 || op == 0xc24 || op == 0xd00 || op == 0xd09 || op == 0x9c3 || op == 0xc45 || op == 0x2a4 || op == 0x891 || op == 0x890 || op == 0x290 || op == 0x28c || op == 0x88c || op == 0x287 || op == 0x887 || op == 0x958 || op == 0xab9 || op == 0xabb || op == 0x899 || op == 0xc20 || op == 0xe21 || op == 0xe23 || op == 0xc02 ||
op == 0x886 || op == 0x3c2 || op == 0xc82 || op == 0x882 || op == 0x292 || op == 0x892 || op == 0x291 || op == 0xc10 || op == 0xc23 || op == 0x526 || op == 0x2be || (op == 0x81c && instruction.Bits(67, 1));
op == 0x886 || op == 0x3c2 || op == 0xc82 || op == 0x882 || op == 0x292 || op == 0x892 || op == 0x291 || op == 0x981 || op == 0xc13 || op == 0xc10 || op == 0xc23 || op == 0x526 || op == 0x2be || (op == 0x81c && instruction.Bits(67, 1));
}
const auto address_of = [](u32 index) { return 0x50U + index * 8 + ((index + 1) / 3) * 8; };
const auto fail = [&](u32 index, std::string_view reason) {
@ -454,16 +454,23 @@ inline LoweredProgram LowerToMaxwell(std::span<const Instruction> code) {
}
break;
}
case 0x824: { // Captured low-word IMAD forms
if (insn.words[1] == 1 && (insn.words[2] & 0xffffff00U) == 0x078e0200) {
case 0x824: { // Captured low-word IMAD forms; bit 75 negates the addend.
const bool negate_c = insn.Bits(75, 1) != 0;
if (insn.words[1] == 1 && (insn.words[2] & 0xfffff700U) == 0x078e0200) {
emit(base(0x5c10000000000000ULL) | (u64{insn.Bits(24, 8)} << 8) |
(u64{insn.Bits(64, 8)} << 20));
(u64{insn.Bits(64, 8)} << 20) | (u64{negate_c} << 48));
break;
}
if (insn.words[1] != 48 || insn.words[2] != 0x078e02ff) {
if ((insn.words[2] & ~0x2ffU) != 0x078e0000)
if ((insn.words[2] & ~0xaffU) != 0x078e0000)
return fail(index, "native integer multiply mode");
multiply_low(insn.Bits(24, 8), insn.words[1], insn.Bits(64, 8), true);
u32 c = insn.Bits(64, 8);
if (negate_c && c != 255) {
emit(0x5c10000000000000ULL | predicate | 252 | (u64{255} << 8) | (u64{c} << 20) |
(u64{1} << 48));
c = 252;
}
multiply_low(insn.Bits(24, 8), insn.words[1], c, true);
break;
}
const u64 source = insn.Bits(24, 8);
@ -631,6 +638,14 @@ inline LoweredProgram LowerToMaxwell(std::span<const Instruction> code) {
(u64{offset} << 36) | (u64{insn.Bits(90, 1)} << 49) | (u64{7} << 51));
break;
}
case 0x989: { // SHFL, immediate lane and register clamp/segmentation mask, any mode.
if ((insn.words[1] & 0xf01fffffU) || (insn.words[2] & ~0x000e00ffU))
return fail(index, "native register-mask shuffle mode");
emit(base(0xef10000000000000ULL) | (u64{insn.Bits(24, 8)} << 8) |
(u64{insn.Bits(53, 5)} << 20) | (u64{1} << 28) | (u64{insn.Bits(58, 2)} << 30) |
(u64{insn.Bits(64, 8)} << 39) | (u64{insn.Bits(81, 3)} << 48));
break;
}
case 0x589: { // SHFL.IDX, register lane and immediate segmentation mask.
if ((insn.words[2] & ~0x000e0000U) || insn.Bits(53, 11))
return fail(index, "native shuffle mode");
@ -882,22 +897,50 @@ inline LoweredProgram LowerToMaxwell(std::span<const Instruction> code) {
emit(0x38f0000000070000ULL | (u64{253} << 8) | (u64{mask} << 20));
break;
}
case 0x381: { // LDG.E of 32/64/128 bits through a 64-bit register address.
case 0x381: case 0x981: { // LDG.E of 32/64/128 bits, register or uniform 64-bit address.
const u32 size = insn.Bits(73, 3);
if ((insn.words[2] & ~0xe00U) != 0x001e8100 || size < 4 || size > 6 ||
insn.Bits(32, 8) || (insn.Bits(24, 8) & 1) || insn.Bits(24, 8) >= 246 ||
u32 address = insn.Bits(24, 8);
if (size < 4 || size > 6 || (opcode == 0x381 && insn.Bits(32, 8)) ||
(size == 5 && (dest & 1)) || (size == 6 && (dest & 3)))
return fail(index, "native global load mode");
emit(base(0xeed0000000000000ULL) | (u64{insn.Bits(24, 8)} << 8) |
if (opcode == 0x381) {
if ((insn.words[2] & ~0xe00U) != 0x001e8100 || (address & 1) || address >= 246)
return fail(index, "native global load mode");
} else {
// The uniform base sits where a register source would (bits 32-37).
const u32 uniform_address =
insn.Bits(38, 2) ? ~0U : uniform_register(insn.Bits(32, 6));
if ((insn.words[2] & ~(0x04000000U | 0x3fU | 0xe00U | 0x2000U)) != 0x081e8100 ||
uniform_address == ~0U || (uniform_address & 1))
return fail(index, "native global load uniform addressing mode");
if (address == 255) {
address = uniform_address;
} else {
if (insn.Bits(90, 1) && ((address & 1) || address >= 246))
return fail(index, "native global load register address pair");
emit(0x5c10000000000000ULL | predicate | 250 | (u64{uniform_address} << 8) |
(u64{address} << 20) | (u64{1} << 47));
emit(0x5c10000000000000ULL | predicate | 251 | (u64{uniform_address + 1} << 8) |
(u64{insn.Bits(90, 1) ? address + 1 : 255} << 20) | (u64{1} << 43));
address = 250;
}
}
emit(base(0xeed0000000000000ULL) | (u64{address} << 8) |
(u64{insn.Bits(40, 24)} << 20) | (u64{1} << 45) | (u64{size} << 48));
break;
}
case 0x386: case 0x986: { // Global store of 32/64/128 bits, 64-bit address.
const u32 data = insn.Bits(32, 8);
u32 data = insn.Bits(32, 8);
const u32 size = insn.Bits(73, 3);
if (size < 4 || size > 6 || (size == 5 && (data & 1)) || (size == 6 && (data & 3)) ||
data + (1U << (size - 4)) > 246)
if (size < 4 || size > 6 ||
(data != 255 && ((size == 5 && (data & 1)) || (size == 6 && (data & 3)) ||
data + (1U << (size - 4)) > 246)))
return fail(index, "native global store size");
if (data == 255 && size > 4) {
// Zeros wider than one register: store from zeroed scratch registers.
for (u32 i = 0; i < (1U << (size - 4)); ++i) mov_imm(250 + i, 0);
data = 250;
}
u32 address = insn.Bits(24, 8);
bool extended = insn.Bits(72, 1) != 0;
if (opcode == 0x986) {
@ -1060,13 +1103,14 @@ inline LoweredProgram LowerToMaxwell(std::span<const Instruction> code) {
const auto general_tex = [&]() -> bool {
constexpr std::array<u32, 8> coordinate_count{1, 2, 3, 3, 2, 3, 0, 4};
constexpr std::array<u32, 8> maxwell_type{0, 2, 4, 6, 1, 3, 0, 7};
if (dimension == 6 || insn.Bits(76, 2) || insn.Bits(81, 3) != 7 || insn.Bits(59, 1) ||
const bool offsets = insn.Bits(76, 1) != 0;
if (dimension == 6 || insn.Bits(77, 1) || insn.Bits(81, 3) != 7 || insn.Bits(59, 1) ||
insn.Bits(40, 14) > 0x1fff || insn.Bits(54, 5) >= 18 || (lod > 3 && lod != 6 && lod != 7) ||
(depth_compare && mask != 1) || mask == 0)
return false;
const u32 coordinates = coordinate_count[dimension];
const bool has_lod = lod == 2 || lod == 3 || lod == 6 || lod == 7;
const u32 count = coordinates + (has_lod ? 1 : 0) + (depth_compare ? 1 : 0);
const u32 count = coordinates + (has_lod ? 1 : 0) + (offsets ? 1 : 0) + (depth_compare ? 1 : 0);
const u32 in_a = count <= 4 ? (count + 1) / 2 : 4;
const auto value = [&](u32 i) -> u32 {
if (i < in_a) return source_a == 255 ? 255U : source_a + i;
@ -1082,16 +1126,18 @@ inline LoweredProgram LowerToMaxwell(std::span<const Instruction> code) {
const auto copy = [&](u32 target, u32 source) {
emit(0x5c98000000000000ULL | predicate | target | (u64{15} << 39) | (u64{source} << 20));
};
// Coordinates to R250.., LOD/bias then reference to R246/R247.
// Coordinates to R250.., then LOD/bias, offsets and reference to R246...
for (u32 i = 0; i < coordinates; ++i) copy(250 + i, value(i));
u32 meta = 246;
if (has_lod) copy(meta++, value(coordinates));
if (depth_compare) copy(meta++, value(coordinates + (has_lod ? 1 : 0)));
u32 next = coordinates;
if (has_lod) copy(meta++, value(next++));
if (offsets) copy(meta++, value(next++));
if (depth_compare) copy(meta++, value(next++));
emit(0xc000000000000000ULL | predicate | 250 | (u64{250} << 8) |
(u64{meta == 246 ? 255U : 246U} << 20) | (u64{maxwell_type[dimension]} << 28) |
(u64{mask} << 31) | (u64{insn.Bits(40, 14)} << 36) |
(u64{insn.Bits(90, 1)} << 49) | (u64{depth_compare} << 50) | (u64{7} << 51) |
(u64{lod} << 55));
(u64{offsets} << 54) | (u64{lod} << 55));
const u32 components = static_cast<u32>(std::popcount(mask));
if (insn.Bits(79, 1)) {
// FP16 results: (c0, c1) packed into the first destination, (c2, c3) into
@ -1320,9 +1366,11 @@ inline LoweredProgram LowerToMaxwell(std::span<const Instruction> code) {
break;
}
case 0x245: case 0xa45: case 0xc45: { // I2FP.F32.U32
if ((insn.words[2] & ~(0x400U | (opcode == 0xc45 ? 0x08000000U : 0U))) != 0x00201000) return fail(index, "native packed integer-to-float format");
// Bits 78-79: rounding (RN/RM/RP/RZ), as Maxwell I2F's bits 39-40.
if ((insn.words[2] & ~(0x400U | 0xc000U | (opcode == 0xc45 ? 0x08000000U : 0U))) != 0x00201000) return fail(index, "native packed integer-to-float format");
const u32 src = operand(1, false);
emit(base(0x5cb8000000000000ULL) | (u64{2} << 8) | (u64{2} << 10) | (u64{insn.Bits(74, 1)} << 13) | (u64{src} << 20));
emit(base(0x5cb8000000000000ULL) | (u64{2} << 8) | (u64{2} << 10) | (u64{insn.Bits(74, 1)} << 13) | (u64{src} << 20) |
(u64{insn.Bits(78, 2)} << 39));
break;
}
case 0x207: case 0x807: case 0xa07:
@ -1357,38 +1405,38 @@ inline LoweredProgram LowerToMaxwell(std::span<const Instruction> code) {
emit(out);
break;
}
case 0x212: case 0x812: case 0xc12: { // Bounded LOP3 bitwise forms, no predicate output
case 0x212: case 0x812: case 0xa12: case 0xc12: { // LOP3.LUT, any table, optional P = (result != 0)
const u32 lut = insn.Bits(72, 8);
if ((lut != 0xc0 && lut != 0xfc && lut != 0xf8 && lut != 0x48 && lut != 0xe2) || insn.Bits(80, 1) ||
insn.Bits(87, 4) != 15 ||
(opcode == 0x212 && insn.Bits(40, 24))) return fail(index, "native LUT/predicate mode");
u32 b = opcode == 0xc12 ? uniform_register(insn.Bits(32, 8)) : insn.Bits(32, 8);
if (b == ~0U) return fail(index, "native uniform logic source");
if (opcode == 0x812) {
const u32 pred_target = insn.Bits(81, 3);
if (insn.Bits(80, 1) || insn.Bits(87, 4) != 15 ||
(opcode == 0x212 && insn.Bits(40, 24)) || (opcode == 0xa12 && insn.Bits(62, 2)))
return fail(index, "native LUT/predicate mode");
u32 b = 255;
if (opcode == 0x212) {
b = insn.Bits(32, 8);
} else if (opcode == 0x812) {
mov_imm(251, insn.words[1]);
b = 251;
} else if (opcode == 0xc12) {
b = uniform_register(insn.Bits(32, 8));
if (b == ~0U) return fail(index, "native uniform logic source");
} else {
b = operand(1, false);
}
const u32 a = insn.Bits(24, 8), c = insn.Bits(64, 8);
const auto logical = [&](u32 target, u32 lhs, u32 rhs, u32 operation, u32 pred_target = 7) {
emit(0x5c40000000000000ULL | predicate | target | (u64{lhs} << 8) |
(u64{rhs} << 20) | (u64{operation} << 41) |
(u64{pred_target == 7 ? 0U : 3U} << 44) | (u64{pred_target} << 48));
};
const u32 pred_target = insn.Bits(81, 3);
if (lut == 0xe2) {
logical(250, a, b, 0);
logical(252, c, b, 0);
result.instructions.back() |= u64{1} << 40;
logical(static_cast<u32>(dest), 250, 252, 1, pred_target);
} else if (lut == 0xf8) {
logical(250, b, c, false);
logical(static_cast<u32>(dest), a, 250, 1, pred_target);
} else if (lut == 0x48) {
logical(250, a, c, 2);
logical(static_cast<u32>(dest), 250, b, 0, pred_target);
} else {
logical(static_cast<u32>(dest), a, b, lut == 0xfc ? 1U : 0U, pred_target);
}
emit(0x5be0000000000000ULL | predicate | dest | (u64{a} << 8) | (u64{b} << 20) |
(u64{lut} << 28) | (u64{pred_target == 7 ? 0U : 3U} << 36) | (u64{c} << 39) |
(u64{pred_target} << 48));
break;
}
case 0x213: case 0xa13: case 0xc13: { // IABS: max(x, 0 - x), signed.
if (insn.words[2] & ~(opcode == 0xc13 ? 0x08000000U : 0U))
return fail(index, "native integer absolute mode");
const u32 source = operand(1, false);
emit(0x5c10000000000000ULL | predicate | 250 | (u64{255} << 8) | (u64{source} << 20) |
(u64{1} << 48));
emit(base(0x5c20000000000000ULL) | (u64{source} << 8) | (u64{250} << 20) |
(u64{15} << 39) | (u64{1} << 48));
break;
}
case 0x217: case 0x817: case 0xa17: case 0xc17: { // IMNMX register, immediate, cbuf or uniform operand.

View file

@ -13,6 +13,7 @@
#include "core/core.h"
#include "core/memory.h"
#include "video_core/dma_pusher.h"
#include "video_core/control/channel_state.h"
#include "video_core/engines/maxwell_3d.h"
#include "video_core/gpu.h"
#include "video_core/guest_memory.h"
@ -134,6 +135,16 @@ bool DmaPusher::Step() {
if (++dma_pushbuffer_subindex >= command_list_size) {
// A split method resumes within the submission that split it; ring addresses repeat
// every frame, so a stale one could otherwise swallow the headers of a later entry.
for (const auto& parked : parked_methods) {
static std::atomic<u32> reported{};
if (reported.fetch_add(1) < 16) {
LOG_WARNING(HW_GPU,
"Submission ended with parked method {:#x} (sub {}, {} words left, "
"resume {:#x})",
parked.method, parked.subchannel, parked.method_count,
parked.resume_address);
}
}
parked_methods.clear();
dma_pushbuffer.pop();
dma_pushbuffer_subindex = 0;
@ -264,7 +275,21 @@ void DmaPusher::SetState(const CommandHeader& command_header) {
dma_state.method_count = command_header.method_count;
}
// EDEN_NX2_SEM_WATCH=<gpu address>: log every method whose argument is the low word of an
// address in the 16 bytes there (finds the engine and method that release a semaphore).
void DmaPusher::WatchArgument(u32 method, u32 argument) const {
static const u32 watch = [] {
const char* value = std::getenv("EDEN_NX2_SEM_WATCH");
return value ? static_cast<u32>(std::strtoull(value, nullptr, 16)) : 0U;
}();
if (watch != 0 && (argument & ~0xfU) == watch) {
LOG_INFO(HW_GPU, "Semaphore watch: channel {} subchannel {} method {:#x} argument {:#x}",
channel_state.bind_id, dma_state.subchannel, method, argument);
}
}
void DmaPusher::CallMethod(u32 argument) {
WatchArgument(dma_state.method, argument);
if (dma_state.method < non_puller_methods) {
puller.CallPullerMethod(*this, Engines::Puller::MethodCall{
dma_state.method,
@ -289,6 +314,9 @@ void DmaPusher::CallMethod(u32 argument) {
}
void DmaPusher::CallMultiMethod(const u32* base_start, u32 num_methods) {
for (u32 i = 0; i < num_methods; ++i) {
WatchArgument(dma_state.method + (dma_state.non_incrementing ? 0 : i), base_start[i]);
}
if (dma_state.method < non_puller_methods) {
puller.CallMultiMethod(*this, dma_state.method, dma_state.subchannel, base_start, num_methods, dma_state.method_count);
} else {

View file

@ -173,6 +173,7 @@ private:
void CallMethod(u32 argument);
void CallMultiMethod(const u32* base_start, u32 num_methods);
void ReportUnboundSubchannel();
void WatchArgument(u32 method, u32 argument) const;
public:
/// Logs the GPFIFO entry being processed (and the one before it), read through the GPU MMU

View file

@ -4,6 +4,7 @@
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <algorithm>
#include <bitset>
#include <cstdlib>
#include <fstream>
@ -46,6 +47,46 @@ void KeplerCompute::ConsumeSinkImpl(Core::System& system) {
method_sink.clear();
}
// SET_REPORT_SEMAPHORE_A-D (0x6c0-0x6c3): address high/low, payload, then operation in bits 1:0
// (release / acquire / report only / trap), reduction enable bit 3 with the op in bits 11:9, and
// a one-word (no timestamp) structure in bit 28. NVN2 releases queue syncs from compute this way.
void KeplerCompute::ProcessNativeReportSemaphore(u32 argument) {
const GPUVAddr address = (GPUVAddr{native_registers[0x6c0] & 0x1ffffff} << 32) |
native_registers[0x6c1];
const u32 payload = native_registers[0x6c2];
const u32 operation = argument & 3;
const bool one_word = (argument >> 28) & 1;
static u32 logged{};
if (logged++ < 32) {
LOG_INFO(HW_GPU, "Native compute report semaphore {:#x} = {:#x}, control {:#x}", address,
payload, argument);
}
if (operation != 0 && operation != 2) {
LOG_WARNING(HW_GPU, "Native compute report semaphore operation {} not supported", operation);
return;
}
if ((argument >> 3) & 1) {
const u32 reduction = (argument >> 9) & 7;
rasterizer->SignalFence([this, address, payload, reduction] {
const u32 old_value = memory_manager.Read<u32>(address);
const u32 value = reduction == 0 ? old_value + payload
: reduction == 1 ? std::min(old_value, payload)
: reduction == 2 ? std::max(old_value, payload)
: reduction == 3 ? (old_value >= payload ? 0 : old_value + 1)
: reduction == 4 ? (old_value == 0 || old_value > payload ? payload : old_value - 1)
: reduction == 5 ? (old_value & payload)
: reduction == 6 ? (old_value | payload)
: (old_value ^ payload);
memory_manager.Write<u32>(address, value);
});
return;
}
rasterizer->Query(address, VideoCommon::QueryType::Payload,
one_word ? VideoCommon::QueryPropertiesFlags::IsAFence
: VideoCommon::QueryPropertiesFlags::HasTimeout,
payload, 0);
}
bool KeplerCompute::ProcessNativeMethod(Core::System& system, u32 method, u32 argument, bool is_last_call) {
if (native_context) {
if (method == 0x45 || method == 0x47) native_compute_uploaded = true;
@ -65,11 +106,22 @@ bool KeplerCompute::ProcessNativeMethod(Core::System& system, u32 method, u32 ar
if (!is_last_call) return true;
const u32 entry = ((*native_executing_macro - 0xe00) / 2) % native_macro_positions.size();
native_executing_macro.reset();
static const u32 watch = [] {
const char* value = std::getenv("EDEN_NX2_SEM_WATCH");
return value ? static_cast<u32>(std::strtoull(value, nullptr, 16)) : 0U;
}();
const bool watched = watch != 0 && std::ranges::any_of(native_parameters,
[](u32 parameter) { return (parameter & ~0xfU) == watch; });
if (watched) {
LOG_INFO(HW_GPU, "Semaphore watch: compute macro start={:#x} parameters={:08x}",
native_macro_positions[entry], fmt::join(native_parameters, ","));
}
const auto result = native_macro->native_interpreter.Execute(native_macro->native_code,
native_macro_positions[entry], native_parameters,
[&](u32 address) { return address < native_registers.size() ? native_registers[address] : 0U; },
[&](u32 address, u32 value) {
static u32 diagnostic_writes{};
if (watched) LOG_INFO(HW_GPU, "Semaphore watch: compute macro emit {:#x} = {:#x}", address, value);
if (diagnostic_writes++ < 4096) LOG_DEBUG(HW_GPU, "Native compute MME emit method={:#x}, value={:#x}", address, value);
if (address >= 0xe00) return false;
CallMethod(system, address, value, true);
@ -89,6 +141,10 @@ bool KeplerCompute::ProcessNativeMethod(Core::System& system, u32 method, u32 ar
return true;
}
native_registers[method] = argument;
if (method == 0x6c3) { // SET_REPORT_SEMAPHORE_D: the compute class's semaphore release
ProcessNativeReportSemaphore(argument);
return true;
}
if (method == 0x5a || (method >= 0xc6 && method <= 0x108)) {
VideoCommon::TraceNativeQuery(12, memory_manager.GetID(), method, 0, 0, argument, 0);
}
@ -157,6 +213,13 @@ bool KeplerCompute::ProcessNativeMethod(Core::System& system, u32 method, u32 ar
[&](u64 address, NativeQmdScheduler::Descriptor& descriptor) {
if (!memory_manager.IsFullyMappedRange(address, sizeof(descriptor))) return false;
memory_manager.ReadBlockUnsafe(address, descriptor.data(), sizeof(descriptor));
if (static u32 logged{}; (descriptor[53] & (1U << 23)) && logged < 8) {
++logged;
LOG_INFO(HW_GPU, "Native QMD {:#x} releases: {:08x} | {:08x} | {:08x}", address,
fmt::join(std::span{descriptor}.subspan(24, 4), ","),
fmt::join(std::span{descriptor}.subspan(28, 4), ","),
fmt::join(std::span{descriptor}.subspan(52, 4), ","));
}
for (u32 slot = 0; slot < 2; ++slot) {
const u32 flags = descriptor[25 + slot * 4];
if (!(flags & (1U << 23))) continue;

View file

@ -233,6 +233,7 @@ public:
private:
bool DispatchNativeCompute(const NativeQmdScheduler::Descriptor& descriptor);
void ProcessNativeReportSemaphore(u32 argument);
bool ProcessNativeMethod(Core::System& system, u32 method, u32 argument, bool is_last_call);
NativeQmdScheduler native_qmd;
bool native_mode{};

View file

@ -3135,6 +3135,11 @@ public:
/// Reads a register value located at the input method address
u32 GetRegisterValue(u32 method) const;
/// GPU memory, for Turing macros that read memory into their FIFO or data RAM.
MemoryManager& GetMemoryManager() {
return memory_manager;
}
void SetNativeTuringMacroMode(bool enabled) {
GetNativeMacroEngine().native_turing = enabled;
upload_state.SetNativePartialTransfers(enabled);

View file

@ -68,9 +68,16 @@ bool Puller::CanResumeAcquire(DmaPusher& dma_pusher) {
if (!pending_acquire->reported &&
std::chrono::steady_clock::now() - pending_acquire->since > std::chrono::seconds{2}) {
pending_acquire->reported = true;
LOG_WARNING(HW_GPU, "Channel {} waits on semaphore {:#x} (op {}, {:#x}, now {:#x}) for 2 s",
const auto device = dma_pusher.memory_manager.GpuToCpuAddress(pending_acquire->address);
LOG_WARNING(HW_GPU, "Channel {} waits on semaphore {:#x} (op {}, {:#x}, now {:#x}) for 2 s; "
"device {:#x}, buffer cache holds GPU data: {}, words {:08x} {:08x} {:08x} {:08x}",
dma_pusher.channel_state.bind_id, pending_acquire->address,
pending_acquire->operation, pending_acquire->value, current);
pending_acquire->operation, pending_acquire->value, current, device.value_or(0),
device && dma_pusher.rasterizer->MustFlushRegion(*device, 16, VideoCommon::CacheType::All),
dma_pusher.memory_manager.Read<u32>(pending_acquire->address & ~GPUVAddr{0xf}),
dma_pusher.memory_manager.Read<u32>((pending_acquire->address & ~GPUVAddr{0xf}) + 4),
dma_pusher.memory_manager.Read<u32>((pending_acquire->address & ~GPUVAddr{0xf}) + 8),
dma_pusher.memory_manager.Read<u32>((pending_acquire->address & ~GPUVAddr{0xf}) + 12));
}
return false;
}
@ -157,6 +164,17 @@ void Puller::ProcessFenceActionMethod(DmaPusher& dma_pusher) {
void Puller::ProcessSemaphoreTriggerMethod(DmaPusher& dma_pusher) {
const auto semaphoreOperationMask = 0xF;
const auto op = GpuSemaphoreOperation(regs.semaphore_trigger & semaphoreOperationMask);
// EDEN_NX2_SEM_WATCH=<gpu address>: log every release/acquire on the 16 bytes there.
static const GPUVAddr watch = [] {
const char* value = std::getenv("EDEN_NX2_SEM_WATCH");
return value ? GPUVAddr{std::strtoull(value, nullptr, 16)} : GPUVAddr{};
}();
if (watch != 0 && (regs.semaphore_address.SemaphoreAddress() & ~GPUVAddr{0xf}) == watch) {
LOG_INFO(HW_GPU, "Semaphore watch: channel {} op {} {:#x} value {:#x} (now {:#x})",
dma_pusher.channel_state.bind_id, static_cast<u32>(op),
regs.semaphore_address.SemaphoreAddress(), regs.semaphore_sequence,
dma_pusher.memory_manager.Read<u32>(regs.semaphore_address.SemaphoreAddress()));
}
if (op == GpuSemaphoreOperation::WriteLong) {
const GPUVAddr sequence_address{regs.semaphore_address.SemaphoreAddress()};
const u32 payload = regs.semaphore_sequence;

View file

@ -27,6 +27,7 @@
#include "video_core/engines/maxwell_3d.h"
#include "video_core/engines/maxwell_3d.h"
#include "video_core/dirty_flags.h"
#include "video_core/memory_manager.h"
#include "video_core/rasterizer_interface.h"
#include "video_core/macro.h"
@ -1351,11 +1352,43 @@ void MacroEngine::Execute(Core::System& system, Engines::Maxwell3D& maxwell3d, u
}
LOG_DEBUG(HW_GPU, "Native MME context={:#x}", context);
LOG_DEBUG(HW_GPU, "Native MME start={:#x}, parameters={}, data={:08x}", method, parameters.size(), fmt::join(parameters, ","));
const auto result = native_interpreter.Execute(native_code, method, parameters,
std::vector<u32> fifo(parameters.begin(), parameters.end());
const auto result = native_interpreter.Execute(native_code, method, fifo,
[&](u32 address) { return address < Maxwell3D::Regs::NUM_REGS ? maxwell3d.GetRegisterValue(address) : 0U; },
[&](u32 address, u32 value) {
if (address >= 0xe00) return false;
if (address == 0x556) {
static u32 enable_logs{};
if (enable_logs++ < 400) LOG_INFO(HW_GPU, "Native MME start={:#x} render enable mode={}", method, value);
}
maxwell3d.CallMethod(system, address, value, true);
// Turing MME memory reads (methods 0x550 SET_MME_MEM_ADDRESS_A/B, 0x558 data RAM
// address, 0x55c MME_DMA_READ into data RAM, 0x560 MME_DMA_READ_FIFOED into
// the load FIFO, which the macro then reads after a load barrier).
constexpr u32 MemAddressA = 0x154, MemAddressB = 0x155, DataRamAddress = 0x156;
constexpr u32 DmaRead = 0x157, DmaReadFifoed = 0x158;
if (address == DmaRead || address == DmaReadFifoed) {
const GPUVAddr source = (GPUVAddr{maxwell3d.GetRegisterValue(MemAddressA) & 0x1ffffff} << 32) |
maxwell3d.GetRegisterValue(MemAddressB);
auto& memory = maxwell3d.GetMemoryManager();
const u32 ram = maxwell3d.GetRegisterValue(DataRamAddress);
static u32 dma_logs{};
if (dma_logs < 400) {
++dma_logs;
std::array<u32, 8> words{};
for (u32 i = 0; i < std::min<u32>(value, 8); ++i) words[i] = memory.Read<u32>(source + u64{i} * 4);
LOG_INFO(HW_GPU, "Native MME DMA read{} start={:#x} source={:#x} count={} words={:08x}",
address == DmaReadFifoed ? " fifoed" : "", method, source, value, fmt::join(words, ","));
}
for (u32 i = 0; i < std::min<u32>(value, 0x1000); ++i) {
const u32 word = memory.Read<u32>(source + u64{i} * 4);
if (address == DmaReadFifoed) {
fifo.push_back(word);
} else if (ram + i < native_interpreter.dram.size()) {
native_interpreter.dram[ram + i] = word;
}
}
}
return true;
});
if (!result.success) {

View file

@ -10,6 +10,7 @@
#include <cstdint>
#include <span>
#include <string_view>
#include <vector>
namespace Tegra {
@ -25,8 +26,9 @@ public:
};
template <typename Read, typename Emit>
// `parameters` is the load FIFO; `emit` may append to it (MME_DMA_READ_FIFOED).
Result Execute(std::span<const Word> code, Word start,
std::span<const Word> parameters, Read read, Emit emit) {
std::vector<Word>& parameters, Read read, Emit emit) {
std::array<Word, 24> regs{};
Word initialized{}, carry{}, method{}, increment{};
Word pc = start, loop_count{}, loop_start{}, loop_end{};

View file

@ -61,9 +61,9 @@ public:
if (!read(request.address, state.descriptor)) return "unmapped QMD";
const auto qmd = state.descriptor;
if ((qmd[18] & 0xff) != 0x30 || (qmd[4] & 0x100)) return "unsupported QMD version or queue";
// Validate both release slots before making either visible.
for (Word slot = 0; slot < 2; ++slot) {
const Word flags = qmd[25 + slot * 4];
// Validate the release slots before making any visible.
for (const Word base : ReleaseSlots) {
const Word flags = qmd[base + 1];
if (!(flags & (1U << 23))) continue;
const bool add = (flags & (1U << 26)) != 0;
if ((flags & (0x3bU << 24)) || (flags >> 30) != 1 ||
@ -76,15 +76,15 @@ public:
if (qmd[12] && (qmd[13] & 0xffff) && (qmd[14] & 0xffff) && !dispatch(qmd))
return "native shader dispatch required";
state.completed = true;
for (Word slot = 0; slot < 2; ++slot) {
const Word flags = qmd[25 + slot * 4];
for (const Word base : ReleaseSlots) {
const Word flags = qmd[base + 1];
if (!(flags & (1U << 23))) continue;
const Address destination = (Address{flags & 0xff} << 32) | qmd[24 + slot * 4];
const Address destination = (Address{flags & 0xff} << 32) | qmd[base];
bool released{};
if constexpr (std::is_invocable_r_v<bool, Release, Address, Word, Word>) {
released = release(destination, qmd[26 + slot * 4], flags);
released = release(destination, qmd[base + 2], flags);
} else {
released = release(destination, qmd[26 + slot * 4]);
released = release(destination, qmd[base + 2]);
}
if (!released) return "unmapped QMD release";
}
@ -99,6 +99,10 @@ public:
return {};
}
private:
// Release slots (address low, flags | address high, payload). NVN2 patches a third one at
// word 52 for queue syncs (e.g. a compute queue releasing a semaphore another queue waits on).
static constexpr std::array<Word, 3> ReleaseSlots{24, 28, 52};
struct State {
Descriptor descriptor{};
std::int32_t dependencies{};

View file

@ -234,7 +234,12 @@ void QueryCacheBase<Traits>::CounterReport(GPUVAddr addr, QueryType counter_type
QueryPropertiesFlags flags, u32 payload, u32 subreport) {
const bool has_timestamp = True(flags & QueryPropertiesFlags::HasTimeout);
const bool is_fence = True(flags & QueryPropertiesFlags::IsAFence);
if (static const bool trace = std::getenv("EDEN_NX2_QUERY_TRACE") != nullptr; trace) {
static const GPUVAddr watch = [] {
const char* value = std::getenv("EDEN_NX2_SEM_WATCH");
return value ? GPUVAddr{std::strtoull(value, nullptr, 16)} : GPUVAddr{};
}();
if (static const bool trace = std::getenv("EDEN_NX2_QUERY_TRACE") != nullptr;
trace || (watch != 0 && (addr & ~GPUVAddr{0xf}) == watch)) {
LOG_INFO(HW_GPU, "nx2 report addr={:#x} type={} flags={:#x} payload={:#x}", addr,
static_cast<u32>(counter_type), static_cast<u32>(flags), payload);
}

View file

@ -1103,6 +1103,14 @@ void RasterizerVulkan::AccelerateInlineToMemory(GPUVAddr address, size_t copy_si
if (memory.size() >= sizeof(first_word)) std::memcpy(&first_word, memory.data(), sizeof(first_word));
VideoCommon::TraceNativeQuery(11, gpu_memory->GetID(), address, cpu_addr.value_or(0),
0, first_word, static_cast<u32>(copy_size));
static const GPUVAddr watch = [] {
const char* value = std::getenv("EDEN_NX2_SEM_WATCH");
return value ? GPUVAddr{std::strtoull(value, nullptr, 16)} : GPUVAddr{};
}();
if (watch != 0 && address < watch + 16 && address + copy_size > watch) {
LOG_INFO(Render_Vulkan, "Semaphore watch: inline write {:#x} size {} first word {:#x}",
address, copy_size, first_word);
}
}
if (!cpu_addr) [[unlikely]] {
gpu_memory->WriteBlock(address, memory.data(), copy_size);

View file

@ -4,6 +4,9 @@
// SPDX-FileCopyrightText: 2014 Citra Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <vector>
#include <cstdlib>
#include <chrono>
#include <cstdio>
#include <iostream>
#include <memory>
@ -34,6 +37,7 @@
#include "core/hle/service/filesystem/filesystem.h"
#include "core/loader/loader.h"
#include "frontend_common/config.h"
#include "input_common/drivers/keyboard.h"
#include "input_common/main.h"
#include "network/network.h"
#include "sdl_config.h"
@ -327,8 +331,50 @@ extern "C" SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
state->system.InitializeDebugger();
return SDL_APP_CONTINUE;
}
// EDEN_NX2_KEY_SCRIPT="seconds:code,seconds:-code,...": press (code) or release (-code) keyboard
// keys, by SDL scancode, that many seconds after start. Lets hidden test runs drive menus.
static void RunKeyScript(InputCommon::InputSubsystem& input_subsystem) {
struct KeyEvent {
double seconds;
int code;
};
static const std::vector<KeyEvent> script = [] {
std::vector<KeyEvent> events;
if (const char* text = std::getenv("EDEN_NX2_KEY_SCRIPT")) {
std::string list{text};
size_t start = 0;
while (start < list.size()) {
const size_t end = std::min(list.find(',', start), list.size());
const std::string item = list.substr(start, end - start);
if (const size_t colon = item.find(':'); colon != std::string::npos) {
events.push_back({std::stod(item.substr(0, colon)),
std::stoi(item.substr(colon + 1))});
}
start = end + 1;
}
}
return events;
}();
static const auto begin = std::chrono::steady_clock::now();
static size_t next = 0;
const double elapsed =
std::chrono::duration<double>(std::chrono::steady_clock::now() - begin).count();
while (next < script.size() && script[next].seconds <= elapsed) {
const int code = script[next].code;
LOG_INFO(Frontend, "Key script: {} key {} at {:.1f} s", code < 0 ? "release" : "press",
code < 0 ? -code : code, elapsed);
if (code < 0) {
input_subsystem.GetKeyboard()->ReleaseKey(static_cast<std::size_t>(-code));
} else {
input_subsystem.GetKeyboard()->PressKey(static_cast<std::size_t>(code));
}
++next;
}
}
extern "C" SDL_AppResult SDL_AppIterate(void *appstate) {
SdlState *state = (SdlState *)appstate;
RunKeyScript(state->input_subsystem);
return state->emu_window && state->emu_window->IsOpen() ? SDL_APP_CONTINUE : SDL_APP_SUCCESS;
}
extern "C" SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event) {