mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-20 23:19:57 -04:00
Copy large textures out of the game's memory on several threads at once: a level of 1 MiB or more goes to a small worker pool as bands of rows (par_jobs.c, tex_deswizzle.c tex_bl_copy_mt), and so does a large block copy for the GPU's ASTC decoder, so the upload's storage copy no longer runs on the drawing thread alone. The bytes are those of the one-thread copy; par_jobs = 0 turns it off.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
117
runtime/par_jobs.c
Normal file
117
runtime/par_jobs.c
Normal file
@@ -0,0 +1,117 @@
|
||||
// A pool of persistent threads that runs one job at a time (par_jobs.h). The threads sleep on a condition variable
|
||||
// between jobs and cost nothing while the game does not use them. A job is n pieces claimed one by one from an atomic
|
||||
// counter by the caller and the workers alike, so a slow piece or a busy core evens out. One caller at a time: the
|
||||
// pool's busy lock is only tried, never waited for, so a second caller (or a piece that calls par_run) runs alone
|
||||
// rather than waiting, and no caller can wait for a pool that waits for it.
|
||||
//
|
||||
// Size: the usable hardware threads less two (the drawing thread and the game's main thread), at most PAR_MAX_THREADS
|
||||
// in all, the caller counted. NX2NAVI_PAR_JOBS=0 runs every job on its caller (cfg.c).
|
||||
#include <string.h>
|
||||
|
||||
#include "cfg.h"
|
||||
#include "host.h"
|
||||
#include "par_jobs.h"
|
||||
#include "platform/platform.h"
|
||||
|
||||
#define PAR_MAX_THREADS 8
|
||||
#define PAR_MEMCPY_MIN (1u << 20) // below this, waking the pool costs about what the copy does
|
||||
#define PAR_MEMCPY_PIECE (256u << 10)
|
||||
|
||||
static struct {
|
||||
PlatOnce once;
|
||||
PlatMutex busy; // held by the caller for its whole job
|
||||
PlatMutex lock;
|
||||
PlatCond work, done;
|
||||
int threads; // workers, the caller not counted
|
||||
int off;
|
||||
uint64_t gen; // bumped per job; a worker takes part in each job once
|
||||
int active; // workers that have not finished the current job
|
||||
void (*fn)(void *arg, int i); // the current job (written under lock before gen is bumped)
|
||||
void *arg;
|
||||
int n;
|
||||
volatile int32_t next; // the first piece not yet claimed
|
||||
} J = {PLAT_ONCE_INIT, .lock = PLAT_MUTEX_INIT, .work = PLAT_COND_INIT, .done = PLAT_COND_INIT};
|
||||
|
||||
static void claim(void) {
|
||||
for (;;) {
|
||||
int i = __atomic_fetch_add(&J.next, 1, __ATOMIC_RELAXED);
|
||||
if (i >= J.n) return;
|
||||
J.fn(J.arg, i);
|
||||
}
|
||||
}
|
||||
|
||||
static void worker(void *arg) {
|
||||
(void)arg;
|
||||
uint64_t seen = 0;
|
||||
plat_mutex_lock(&J.lock);
|
||||
for (;;) {
|
||||
while (J.gen == seen) plat_cond_wait(&J.work, &J.lock);
|
||||
seen = J.gen;
|
||||
plat_mutex_unlock(&J.lock);
|
||||
claim();
|
||||
plat_mutex_lock(&J.lock);
|
||||
if (!--J.active) plat_cond_broadcast(&J.done);
|
||||
}
|
||||
}
|
||||
|
||||
static void pool_init(void *param) {
|
||||
(void)param;
|
||||
if (!cfg_bool("NX2NAVI_PAR_JOBS")) {
|
||||
J.off = 1;
|
||||
rt_log("par_jobs: off (NX2NAVI_PAR_JOBS=0): large texture copies run on the thread that makes them");
|
||||
return;
|
||||
}
|
||||
int cpus = (int)plat_cpu_usable() - 2;
|
||||
int n = (cpus < 1 ? 1 : cpus > PAR_MAX_THREADS ? PAR_MAX_THREADS : cpus) - 1;
|
||||
for (int i = 0; i < n; i++) {
|
||||
if (!plat_thread_spawn(worker, NULL, "par jobs", 0)) break;
|
||||
J.threads++;
|
||||
}
|
||||
rt_log("par_jobs: %d workers for large texture copies (and the thread that asks)", J.threads);
|
||||
}
|
||||
|
||||
int par_threads(void) {
|
||||
plat_once(&J.once, pool_init, NULL);
|
||||
return J.off ? 1 : J.threads + 1;
|
||||
}
|
||||
|
||||
void par_run(int n, void (*fn)(void *arg, int i), void *arg) {
|
||||
if (n <= 0) return;
|
||||
if (n == 1 || par_threads() < 2 || !plat_mutex_trylock(&J.busy)) {
|
||||
for (int i = 0; i < n; i++) fn(arg, i);
|
||||
return;
|
||||
}
|
||||
plat_mutex_lock(&J.lock);
|
||||
J.fn = fn, J.arg = arg, J.n = n;
|
||||
__atomic_store_n(&J.next, 0, __ATOMIC_RELAXED);
|
||||
J.active = J.threads;
|
||||
J.gen++;
|
||||
plat_cond_broadcast(&J.work);
|
||||
plat_mutex_unlock(&J.lock);
|
||||
claim();
|
||||
plat_mutex_lock(&J.lock);
|
||||
while (J.active) plat_cond_wait(&J.done, &J.lock);
|
||||
plat_mutex_unlock(&J.lock);
|
||||
plat_mutex_unlock(&J.busy);
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
char *dst;
|
||||
const char *src;
|
||||
size_t n, piece;
|
||||
} Copy;
|
||||
|
||||
static void copy_piece(void *arg, int i) {
|
||||
const Copy *c = arg;
|
||||
size_t at = (size_t)i * c->piece, len = c->n - at < c->piece ? c->n - at : c->piece;
|
||||
memcpy(c->dst + at, c->src + at, len);
|
||||
}
|
||||
|
||||
void par_memcpy(void *dst, const void *src, size_t n) {
|
||||
if (n < PAR_MEMCPY_MIN || par_threads() < 2) {
|
||||
memcpy(dst, src, n);
|
||||
return;
|
||||
}
|
||||
Copy c = {dst, src, n, PAR_MEMCPY_PIECE};
|
||||
par_run((int)((n + c.piece - 1) / c.piece), copy_piece, &c);
|
||||
}
|
||||
Reference in New Issue
Block a user