mirror of
https://git.triforceproject.com/triforce/source
synced 2026-11-21 00:59:59 -04:00
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:
57
host/crash_threads.h
Normal file
57
host/crash_threads.h
Normal file
@@ -0,0 +1,57 @@
|
||||
/* (Triforce) What the other threads were doing when one crashed (host/crash_threads.c; HOS_CRASH_THREADS=0: not taken).
|
||||
A crash report had the faulting thread alone: its registers, its guest frames, the memory three of its registers point to.
|
||||
The crash while a save loads (BaseProcCreateAndDeleteThread, the game's f_80119570 walking objects whose memory holds
|
||||
something else: -1, text, zeros; three in 105 lab runs, lab round 78) looks like an object freed and used again under
|
||||
that walk, and nothing in its reports says which thread freed it. So a report now starts by taking every other
|
||||
thread's host stack, each thread stopped only for its own unwind, on a helper thread while the faulting thread writes
|
||||
its own lines, and ends with one line a thread: the ones running game or host code first, with more frames, then the
|
||||
ones waiting in the system. Triforce.map turns the offsets into the game's functions (scripts/prof.py).
|
||||
Plain functions here: tests/test_crash_threads.py checks them. */
|
||||
#ifndef HOS_CRASH_THREADS_H
|
||||
#define HOS_CRASH_THREADS_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
enum {
|
||||
CRASH_THREADS_MAX = 384, /* (threads in a snapshot at most: the game has about 120) */
|
||||
CRASH_THREADS_FRAMES = 16, /* (frames kept of each stack) */
|
||||
CRASH_THREADS_WAIT_MS = 1500, /* (the report waits this long for the snapshot, then goes on without it) */
|
||||
};
|
||||
|
||||
/* HOS_CRASH_THREADS: on unless it is 0 */
|
||||
static inline int crash_threads_on(const char *env) { return !(env && env[0] == '0' && !env[1]); }
|
||||
|
||||
static inline int crash_threads_lower(int ch) { return ch >= 'A' && ch <= 'Z' ? ch + 32 : ch; }
|
||||
static inline int crash_threads_prefix(const char *s, const char *lower_prefix) {
|
||||
for (; *lower_prefix; s++, lower_prefix++)
|
||||
if (crash_threads_lower((unsigned char)*s) != *lower_prefix) return 0;
|
||||
return 1;
|
||||
}
|
||||
/* A thread whose top frame is in this module is waiting in the system (a sleep, a wait, a system call), not running the
|
||||
game's or the host's code: the report lists it after the others, with fewer frames. No module known ("?"): running */
|
||||
static inline int crash_threads_waiting(const char *top_module) {
|
||||
return crash_threads_prefix(top_module, "ntdll") || crash_threads_prefix(top_module, "kernelbase") ||
|
||||
crash_threads_prefix(top_module, "kernel32") || crash_threads_prefix(top_module, "win32u") ||
|
||||
crash_threads_prefix(top_module, "user32");
|
||||
}
|
||||
/* The frames of a stack that go into its line: all kept for a running thread, 12 for a waiting one (the system's and the
|
||||
host's wait take the first four or five; the game's functions come after them), never more than it has */
|
||||
static inline int crash_threads_shown(int frames, int waiting) {
|
||||
const int most = waiting ? 12 : CRASH_THREADS_FRAMES;
|
||||
return frames < 0 ? 0 : frames < most ? frames : most;
|
||||
}
|
||||
|
||||
/* Whether `need` bytes at sp lie in a thread's stack [lo, hi). The walk of a stopped thread reads nothing outside it: a read
|
||||
there can fault, a fault goes through the host's handlers first (host/mkw_glue.c commit_on_touch commits a reserved guest
|
||||
page and logs it: the log's lock and the heap's, which the stopped thread may hold), and the report would hang where it
|
||||
should end the process. A frame the walk cannot follow inside the stack ends the walk */
|
||||
static inline int crash_threads_in_stack(uint64_t sp, uint64_t need, uint64_t lo, uint64_t hi) {
|
||||
return sp >= lo && sp <= hi && need <= hi - sp;
|
||||
}
|
||||
|
||||
/* Starts the snapshot (once a process; the calling thread is left out). Then the caller writes its own report */
|
||||
void hos_crash_threads_begin(void);
|
||||
/* Waits for the snapshot, CRASH_THREADS_WAIT_MS at most, and writes its lines */
|
||||
void hos_crash_threads_end(void);
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user