Triforce v0.6.0 "Sage Of Power"

Faster frames (the replay's memory work, held submits, helper threads, collection and capture cuts), the game letting old areas go (QueryMemoryInfo), the 0.5.2 stutter fixed, AMD RX 5000/6000 and integrated-GPU fixes, the GPU device chosen by name, the in-game menus and launcher reworked, controller, Linux and benchmark fixes.
This commit is contained in:
ruckus7382sfgsgdf
2026-11-20 17:06:21 -06:00
parent b0e46adb48
commit 6c7117635c
265 changed files with 26893 additions and 2549 deletions

84
gpu/vk/segment_plan.h Normal file
View File

@@ -0,0 +1,84 @@
// ((Triforce) the parallel replay's early segments (vk_replay.cpp replay_handle_early): how many a large command buffer is cut
// into and where. With more segments than recording threads the last ones ran in a round of their own, one thread recording while
// the others idled: the count is bounded by the recorders (the helper threads and the replay thread, which records the last one).
// And a command buffer's first draws cost two to three times its last ones a draw (their states and bindings are new), so equal
// counts left the first segment the slowest: the boundaries cut each command buffer's recording time, measured over its length in
// the frames before (Profile), into equal parts)
#pragma once
#include <algorithm>
#include <cstddef>
#include <cstdint>
namespace mkwvk::segment_plan {
/// The recorders of a parallel replay: the workers, and the replay thread itself when it records a segment
inline int recorders(int workers, bool self) {
return std::max(0, workers) + (self ? 1 : 0);
}
/// The segments a command buffer of `total` draws and dispatches is cut into: one per `per` of them, at least one, at most
/// `cap`. With `one_round` it is also at most `recorders`, so that no segment waits for a thread to come free (a round of its
/// own). recorders <= 0 sets no such bound.
inline int segment_count(int64_t total, int64_t per, int recorders, int cap, bool one_round) {
if (per < 1) per = 1;
if (cap < 1) cap = 1;
int bound = cap;
if (one_round && recorders > 0) bound = std::min(bound, recorders);
return (int)std::clamp<int64_t>(total / per, 1, bound);
}
/// A command buffer's recording time over its length: bins of equal draw-and-dispatch counts, each the time recorded in it (an
/// average over frames)
constexpr int kBins = 32;
struct Profile {
double ms[kBins] = {};
bool valid = false;
};
/// What one command buffer's segments took: segment k covered [from[k], to[k]) of the command buffer (fractions, in order) and
/// took ms[k]; its time is spread evenly over the bins it covers, then blended into the profile (alpha: the new one's weight;
/// the first sample is taken whole)
inline void profile_add(Profile& p, const double* from, const double* to, const double* ms, size_t n, double alpha) {
double sample[kBins] = {};
bool any = false;
for (size_t k = 0; k < n; k++) {
const double a = std::clamp(from[k], 0.0, 1.0), b = std::clamp(to[k], 0.0, 1.0);
if (b <= a || !(ms[k] >= 0)) continue;
for (int i = 0; i < kBins; i++) {
const double lo = (double)i / kBins, hi = (double)(i + 1) / kBins;
const double o = std::min(b, hi) - std::max(a, lo);
if (o > 0) sample[i] += ms[k] * o / (b - a), any = true;
}
}
if (!any) return;
for (int i = 0; i < kBins; i++) p.ms[i] = p.valid ? p.ms[i] * (1 - alpha) + sample[i] * alpha : sample[i];
p.valid = true;
}
/// The n-1 boundaries (in draws and dispatches, out[0..n-2]) that cut the profile's time into n equal parts; even counts when
/// the profile has nothing yet
inline void balanced_targets(const Profile& p, int n, int64_t total, int64_t* out) {
if (n < 2) return;
double sum = 0;
for (int i = 0; i < kBins; i++) sum += p.valid && p.ms[i] > 0 ? p.ms[i] : 0;
for (int k = 1; k < n; k++) {
if (sum <= 0) {
out[k - 1] = total * k / n;
continue;
}
const double want = sum * k / n;
double cum = 0, pos = 1;
for (int i = 0; i < kBins; i++) {
const double d = p.ms[i] > 0 ? p.ms[i] : 0;
if (cum + d >= want && d > 0) {
pos = (i + (want - cum) / d) / kBins;
break;
}
cum += d;
}
out[k - 1] = (int64_t)(pos * (double)total + 0.5);
}
}
} // namespace mkwvk::segment_plan