VERY experimental Nintendo Switch 2 emulator
C++
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include <array>
#include <cstdint>
#include <string_view>
#include <type_traits>
#include <unordered_map>
namespace Tegra {
// Native QMD 3.0 dependency scheduling; nonempty grids require a dispatch backend.
class NativeQmdScheduler {
public:
using Word = std::uint32_t;
using Address = std::uint64_t;
using Descriptor = std::array<Word, 64>;
struct RejectShaderDispatch { bool operator()(const Descriptor&) const { return false; } };
template <typename Read, typename Release>
std::string_view Signal(Address address, Word argument, Read read, Release release) {
return Signal(address, argument, read, release, RejectShaderDispatch{});
}
template <typename Read, typename Release, typename Dispatch>
std::string_view Signal(Address address, Word argument, Read read, Release release, Dispatch dispatch) {
struct Pending { Address address; Word action; Word count; };
std::array<Pending, 256> pending{};
std::size_t count = 1;
pending[0] = {address, argument & 15, ((argument >> 14) & 0x3ff) + 1};
for (std::size_t i = 0; i < count; ++i) {
const auto request = pending[i];
if (states.size() >= 4096 && !states.contains(request.address)) return "QMD cache limit";
auto& state = states[request.address];
if (request.action == 3 || request.action == 2) {
if (request.action == 3 || !state.loaded) {
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";
if constexpr (std::is_same_v<Dispatch, RejectShaderDispatch>) {
if (qmd[12] && (qmd[13] & 0xffff) && (qmd[14] & 0xffff))
return "native shader dispatch required";
}
state.dependencies = std::int32_t((qmd[4] >> 14) & 0xffff) + state.deferred;
state.deferred = 0;
state.loaded = true;
state.completed = false;
}
state.scheduled = true;
} else if (request.action == 7 || request.action == 12) {
const auto delta = request.action == 7 ? -std::int32_t(request.count) : std::int32_t(request.count);
if (!state.loaded || state.completed) { state.deferred += delta; continue; }
state.dependencies += delta;
} else if (request.action == 0 || request.action == 1) {
continue;
} else {
return "unsupported PCAS action";
}
if (!state.loaded || !state.scheduled || state.completed || state.dependencies > 0) continue;
if (state.dependencies < 0) return "QMD dependency underflow";
// The SDK patches release payloads while a scheduled QMD is
// waiting for its remaining dependencies. Fetch them at execution.
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];
if (!(flags & (1U << 23))) continue;
const bool add = (flags & (1U << 26)) != 0;
if ((flags & (0x3bU << 24)) || (flags >> 30) != 1 ||
(add && (flags & (7U << 20)))) return "unsupported QMD release format";
if (add) {
if constexpr (!std::is_invocable_r_v<bool, Release, Address, Word, Word>)
return "unsupported QMD reduction callback";
}
}
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];
if (!(flags & (1U << 23))) continue;
const Address destination = (Address{flags & 0xff} << 32) | qmd[24 + slot * 4];
bool released{};
if constexpr (std::is_invocable_r_v<bool, Release, Address, Word, Word>) {
released = release(destination, qmd[26 + slot * 4], flags);
} else {
released = release(destination, qmd[26 + slot * 4]);
}
if (!released) return "unmapped QMD release";
}
if (qmd[16] & 1) {
const Word action = (qmd[16] >> 1) & 7;
if (action != 4 && action != 3 && action != 1) return "unsupported dependent QMD action";
if (count == pending.size()) return "QMD chain limit";
pending[count++] = {Address{qmd[15]} << 8, action == 4 ? 7U : action == 3 ? 3U : 2U, 1};
}
if (qmd[16] & (1U << 5)) return "second dependent QMD unsupported";
}
return {};
}
private:
struct State {
Descriptor descriptor{};
std::int32_t dependencies{};
std::int32_t deferred{};
bool loaded{};
bool scheduled{};
bool completed{};
};
std::unordered_map<Address, State> states;
};
} // namespace Tegra