// The browser's pipeline cache: every render and compute pipeline the game makes is recorded (its WGSL and its whole // descriptor) to /rxcache/pipelines.bin, which the page keeps in IndexedDB; the next time the page opens they are all // made again in the background, a few at a time, and kept. The browser's WebGPU (Dawn) gives back the object it // already has for an identical descriptor, so when the game first needs one of them it is ready at once instead of a // Tint -> HLSL -> D3D compile in the middle of play (first jumps, new areas, camera cuts all stalled on these), and // Chrome's own disk cache of compiled shaders makes the background compiles cheap after the first time. // /rxcache/seed.bin (the page fetches pipelines.bin from the server when there is one) is made in the same way. // The records hold the WebGPU structs as bytes: a cache from another build of the page may make pipelines the game // never asks for, which costs only their compile. #include #include #include #include #include #include #include #include #include #include #include "rx_internal.h" namespace rx { namespace { #if RX_WEB constexpr uint32_t kMagic = 0x43505852; // "RXPC" constexpr uint32_t kVersion = 1; const char* const kCachePath = "/rxcache/pipelines.bin"; const char* const kSeedPath = "/rxcache/seed.bin"; uint32_t layout_signature() { return (uint32_t)(sizeof(WGPUBindGroupLayoutEntry) * 1 + sizeof(WGPUVertexBufferLayout) * 3 + sizeof(WGPUVertexAttribute) * 7 + sizeof(WGPUColorTargetState) * 11 + sizeof(WGPUBlendState) * 13 + sizeof(WGPUPrimitiveState) * 17 + sizeof(WGPUDepthStencilState) * 19 + sizeof(WGPUMultisampleState) * 23); } struct Writer { std::string& out; template void put(const T& v) { out.append(reinterpret_cast(&v), sizeof v); } void bytes(const void* p, size_t n) { out.append(static_cast(p), n); } }; struct Reader { const uint8_t* p; const uint8_t* end; bool ok = true; template T get() { T v{}; if (end - p < (ptrdiff_t)sizeof v) { ok = false; return v; } std::memcpy(&v, p, sizeof v); p += sizeof v; return v; } const uint8_t* take(size_t n) { if ((size_t)(end - p) < n) { ok = false; return nullptr; } const uint8_t* r = p; p += n; return r; } }; std::mutex cache_mu; // (the recorders: the render thread and the compute path) std::string pending; // records made since the last save (appended to the file: the whole file is ~60-95 MB) size_t saved_size = 0; int64_t last_save_ns = 0; std::unordered_set known_modules, known_records; // A loaded record, where it is in its file: read again when the prewarm makes it. (The files stay in the page's file // system, JavaScript memory: held in the host heap, the cache and the seed were ~120 MB of its ~570 for minutes of // prewarm, and the open world ran it out of memory.) struct Item { uint8_t file; // 0 the page's cache, 1 the seed uint32_t off, len; char type; }; FILE* files[2]; std::unordered_map module_texts; // (loaded, for the prewarm) /// A record's bytes (into buf, reused) bool read_item(const Item& item, std::string& buf) { FILE* f = files[item.file & 1]; buf.resize(item.len); return f && !std::fseek(f, (long)item.off, SEEK_SET) && std::fread(buf.data(), 1, item.len, f) == item.len; } // the prewarm (render thread: everything here, recording included, runs on it) std::deque prewarm; // render ('R') and compute ('C') records to make std::unordered_map warm_modules; std::vector warm_render; std::vector warm_compute; std::atomic in_flight{0}; int64_t warmed = 0, prewarm_total = 0, prewarm_t0 = 0; uint64_t text_hash(const std::string& s) { return hash_bytes(s.data(), s.size(), 0x9e3779b97f4a7c15ull); } void add_record(char type, const std::string& payload) { // (mu held) const uint64_t h = hash_bytes(payload.data(), payload.size(), (uint64_t)type); if (!known_records.insert(h).second) return; Writer w{pending}; w.put(type); w.put((uint32_t)payload.size()); w.bytes(payload.data(), payload.size()); } uint64_t add_module(const std::string& text) { // (mu held) const uint64_t h = text_hash(text); if (known_modules.insert(h).second) { std::string payload; Writer w{payload}; w.put(h); w.bytes(text.data(), text.size()); add_record('M', payload); } return h; } uint64_t add_module_hashed(uint64_t h, const std::string& wgsl) { // (mu held) if (!h) return add_module(web_shader_source(wgsl)); if (known_modules.count(h) || wgsl.empty()) return h; return add_module(web_shader_source(wgsl)); } void put_layouts(Writer& w, const std::vector* layouts, int n) { w.put((uint32_t)n); for (int i = 0; i < n; i++) { w.put((uint32_t)layouts[i].size()); w.bytes(layouts[i].data(), layouts[i].size() * sizeof(WGPUBindGroupLayoutEntry)); } } /// Reads a cache file's records (the page's own cache, or a seed): modules go to module_texts and the rest onto the /// prewarm, as places in the file, which stays open until the prewarm is done. void load(const char* path, bool keep) { FILE* f = std::fopen(path, "rb"); if (!f) return; uint32_t head[3] = {}; if (std::fread(head, 1, sizeof head, f) != sizeof head || head[0] != kMagic || head[1] != kVersion || head[2] != layout_signature()) { std::fclose(f); hos_log("rx: pipeline cache %s is from another build: not used", path); return; } std::fseek(f, 0, SEEK_END); const long size = std::ftell(f) - (long)sizeof head; std::fseek(f, sizeof head, SEEK_SET); if (keep && size > (96l << 20)) { // (grown past use: started again) std::fclose(f); std::remove(path); hos_log("rx: pipeline cache %s: %ld MB, started again", path, size >> 20); return; } const uint8_t which = keep ? 0 : 1; files[which] = f; std::string payload; long pos = (long)sizeof head; int modules = 0, records = 0; for (;;) { char type; uint32_t n; if (std::fread(&type, 1, 1, f) != 1 || std::fread(&n, 1, 4, f) != 4) break; pos += 5; payload.resize(n); if (std::fread(payload.data(), 1, n, f) != n) break; const uint32_t off = (uint32_t)pos; pos += n; const uint64_t h = hash_bytes(payload.data(), n, (uint64_t)type); if (!keep && known_records.count(h)) continue; if (keep) known_records.insert(h); if (type == 'M' && n >= 8) { uint64_t mh; std::memcpy(&mh, payload.data(), 8); if (keep) known_modules.insert(mh); module_texts.emplace(mh, Item{which, off + 8, n - 8, 'M'}); modules++; } else if (type == 'R' || type == 'C') { prewarm.push_back(Item{which, off, n, type}); records++; } } hos_log("rx: pipeline cache %s: %d modules, %d pipelines to make in the background", path, modules, records); } WGPUShaderModule warm_module(uint64_t h) { auto it = warm_modules.find(h); if (it != warm_modules.end()) return it->second; auto t = module_texts.find(h); static std::string text; if (t == module_texts.end() || !read_item(t->second, text)) return warm_modules[h] = nullptr; WGPUShaderSourceWGSL src{}; src.chain.sType = WGPUSType_ShaderSourceWGSL; src.code = WGPUStringView{text.data(), text.size()}; WGPUShaderModuleDescriptor d{}; d.nextInChain = &src.chain; return warm_modules[h] = program_module(&d); } WGPUPipelineLayout warm_layout(Reader& r, WGPUShaderStage visibility_unused) { (void)visibility_unused; const uint32_t n = r.get(); WGPUBindGroupLayout bgl[4]{}; if (n > 4) { r.ok = false; return nullptr; } for (uint32_t i = 0; i < n; i++) { const uint32_t count = r.get(); const uint8_t* p = r.take((size_t)count * sizeof(WGPUBindGroupLayoutEntry)); if (!r.ok) return nullptr; std::vector e(count); std::memcpy(e.data(), p, (size_t)count * sizeof(WGPUBindGroupLayoutEntry)); WGPUBindGroupLayoutDescriptor ld{}; ld.entryCount = count; ld.entries = e.data(); bgl[i] = wgpuDeviceCreateBindGroupLayout(dev.device, &ld); } WGPUPipelineLayoutDescriptor pld{}; pld.bindGroupLayoutCount = n; pld.bindGroupLayouts = bgl; WGPUPipelineLayout pl = wgpuDeviceCreatePipelineLayout(dev.device, &pld); for (uint32_t i = 0; i < n; i++) wgpuBindGroupLayoutRelease(bgl[i]); return pl; } void warm_one(const Item& item) { static std::string bytes; if (!read_item(item, bytes)) return; const uint8_t* p = reinterpret_cast(bytes.data()); Reader r{p, p + item.len}; const char type = item.type; if (type == 'C') { const uint64_t mh = r.get(); WGPUPipelineLayout pl = warm_layout(r, WGPUShaderStage_Compute); WGPUShaderModule m = warm_module(mh); if (!r.ok || !m || !pl) { if (pl) wgpuPipelineLayoutRelease(pl); return; } WGPUComputePipelineDescriptor cd{}; cd.layout = pl; cd.compute.module = m; cd.compute.entryPoint = WGPUStringView{"main", 4}; WGPUCreateComputePipelineAsyncCallbackInfo cb{}; cb.mode = WGPUCallbackMode_AllowProcessEvents; cb.callback = [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline p, WGPUStringView, void*, void*) { in_flight--; if (status == WGPUCreatePipelineAsyncStatus_Success && p) warm_compute.push_back(p); }; in_flight++; wgpuDeviceCreateComputePipelineAsync(dev.device, &cd, cb); wgpuPipelineLayoutRelease(pl); return; } if (type != 'R') return; const uint64_t vh = r.get(), fh = r.get(); WGPUPipelineLayout pl = warm_layout(r, WGPUShaderStage_Vertex); const uint32_t nbuf = r.get(); if (!r.ok || nbuf > 32) { if (pl) wgpuPipelineLayoutRelease(pl); return; } std::vector buffers(nbuf); std::vector> attributes(nbuf); for (uint32_t i = 0; i < nbuf; i++) { buffers[i] = r.get(); const uint32_t na = r.get(); if (!r.ok || na > 64) { r.ok = false; break; } attributes[i].resize(na); for (uint32_t a = 0; a < na; a++) attributes[i][a] = r.get(); buffers[i].attributes = attributes[i].data(); buffers[i].attributeCount = na; } const uint32_t nt = r.get(); if (!r.ok || nt > 8) { if (pl) wgpuPipelineLayoutRelease(pl); return; } std::vector targets(nt); std::array blends{}; for (uint32_t i = 0; i < nt; i++) { targets[i] = r.get(); const uint32_t has_blend = r.get(); blends[i] = r.get(); targets[i].blend = has_blend ? &blends[i] : nullptr; targets[i].nextInChain = nullptr; } WGPUPrimitiveState prim = r.get(); const uint32_t has_depth = r.get(); WGPUDepthStencilState depth = r.get(); WGPUMultisampleState ms = r.get(); WGPUShaderModule vs = warm_module(vh), fs = fh ? warm_module(fh) : nullptr; if (!r.ok || !pl || !vs || (fh && !fs)) { if (pl) wgpuPipelineLayoutRelease(pl); return; } prim.nextInChain = nullptr; depth.nextInChain = nullptr; ms.nextInChain = nullptr; WGPUFragmentState fst{}; if (fs) { fst.module = fs; fst.entryPoint = WGPUStringView{"main", 4}; fst.targetCount = nt; fst.targets = targets.data(); } WGPURenderPipelineDescriptor d{}; d.layout = pl; d.vertex.module = vs; d.vertex.entryPoint = WGPUStringView{"main", 4}; d.vertex.bufferCount = nbuf; d.vertex.buffers = buffers.data(); d.primitive = prim; d.depthStencil = has_depth ? &depth : nullptr; d.multisample = ms; d.fragment = fs ? &fst : nullptr; WGPUCreateRenderPipelineAsyncCallbackInfo cb{}; cb.mode = WGPUCallbackMode_AllowProcessEvents; cb.callback = [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline p, WGPUStringView, void*, void*) { in_flight--; if (status == WGPUCreatePipelineAsyncStatus_Success && p) warm_render.push_back(p); }; in_flight++; wgpuDeviceCreateRenderPipelineAsync(dev.device, &d, cb); wgpuPipelineLayoutRelease(pl); } void save() { // (render thread: the records made since the last save, appended) std::lock_guard lk(cache_mu); if (pending.empty()) return; FILE* f = std::fopen(kCachePath, "rb"); const bool fresh = !f; if (f) std::fclose(f); f = std::fopen(kCachePath, "ab"); if (!f) return; if (fresh) { const uint32_t head[3] = {kMagic, kVersion, layout_signature()}; std::fwrite(head, 1, sizeof head, f); } std::fwrite(pending.data(), 1, pending.size(), f); std::fclose(f); std::string().swap(pending); } #endif } // namespace extern "C" void rx_pipecache_memory(int64_t* recorded_bytes, int64_t* seed_bytes, int64_t* prewarm_left) { #if RX_WEB *recorded_bytes = (int64_t)pending.capacity(); *seed_bytes = 0; *prewarm_left = (int64_t)prewarm.size(); #else *recorded_bytes = *seed_bytes = *prewarm_left = 0; #endif } std::string web_shader_source(const std::string& wgsl) { // the browser (Tint) enforces derivative uniformity, which wgpu (naga) does not: the translated programs sample // in control flow it cannot prove uniform return RX_WEB ? "diagnostic(off, derivative_uniformity);\n" + wgsl : wgsl; } void pipecache_start() { #if RX_WEB static const bool off = env_flag("RX_NO_PIPELINE_CACHE"); if (off) return; std::lock_guard lk(cache_mu); load(kCachePath, true); load(kSeedPath, false); prewarm_total = (int64_t)prewarm.size(); prewarm_t0 = hos_now_ns(); last_save_ns = hos_now_ns(); #endif } uint64_t pipecache_text_hash(const std::string& wgsl) { #if RX_WEB return text_hash(web_shader_source(wgsl)); #else (void)wgsl; return 0; #endif } bool pipecache_has_module(uint64_t h) { #if RX_WEB std::lock_guard lk(cache_mu); return known_modules.count(h) != 0; #else (void)h; return false; #endif } void pipecache_record_render(const WGPURenderPipelineDescriptor& d, const ShaderModule& vs, const ShaderModule* fs, const std::vector* layouts, int nlayouts) { #if RX_WEB std::lock_guard lk(cache_mu); std::string payload; Writer w{payload}; w.put(add_module_hashed(vs.cache_hash, vs.source())); w.put(fs ? add_module_hashed(fs->cache_hash, fs->source()) : (uint64_t)0); put_layouts(w, layouts, nlayouts); w.put((uint32_t)d.vertex.bufferCount); for (size_t i = 0; i < d.vertex.bufferCount; i++) { WGPUVertexBufferLayout b = d.vertex.buffers[i]; b.attributes = nullptr; b.nextInChain = nullptr; w.put(b); w.put((uint32_t)d.vertex.buffers[i].attributeCount); for (size_t a = 0; a < d.vertex.buffers[i].attributeCount; a++) { WGPUVertexAttribute at = d.vertex.buffers[i].attributes[a]; at.nextInChain = nullptr; w.put(at); } } const uint32_t nt = d.fragment ? (uint32_t)d.fragment->targetCount : 0; w.put(nt); for (uint32_t i = 0; i < nt; i++) { WGPUColorTargetState t = d.fragment->targets[i]; const WGPUBlendState blend = t.blend ? *t.blend : WGPUBlendState{}; const uint32_t has_blend = t.blend != nullptr; t.blend = nullptr; t.nextInChain = nullptr; w.put(t); w.put(has_blend); w.put(blend); } WGPUPrimitiveState prim = d.primitive; prim.nextInChain = nullptr; w.put(prim); w.put((uint32_t)(d.depthStencil != nullptr)); WGPUDepthStencilState depth = d.depthStencil ? *d.depthStencil : WGPUDepthStencilState{}; depth.nextInChain = nullptr; w.put(depth); WGPUMultisampleState ms = d.multisample; ms.nextInChain = nullptr; w.put(ms); add_record('R', payload); #else (void)d; (void)vs; (void)fs; (void)layouts; (void)nlayouts; #endif } void pipecache_record_compute(const std::string& wgsl, const std::vector& layout) { #if RX_WEB std::lock_guard lk(cache_mu); std::string payload; Writer w{payload}; w.put(add_module(web_shader_source(wgsl))); put_layouts(w, &layout, 1); add_record('C', payload); #else (void)wgsl; (void)layout; #endif } void pipecache_step() { #if RX_WEB // as many in the browser's compilers as it keeps up with (their callbacks: at present), up to ~6 ms a frame here: // done fast, while the title screen and the first loads run (spread thin, 2026-10-15, it was still going when the // opening area loaded and took that to 11 fps; fast, it was done in ~30 s and the area came in at 55-60 fps) int made = 0; const int64_t t0 = hos_now_ns(); while (!prewarm.empty() && in_flight.load() < 16 && made < 24 && hos_now_ns() - t0 < 6000000) { warm_one(prewarm.front()); prewarm.pop_front(); made++; warmed++; } if (prewarm_total && prewarm.empty() && in_flight.load() == 0) { hos_log("rx: pipeline cache: %lld pipelines made in the background in %.1f s", (long long)warmed, (hos_now_ns() - prewarm_t0) / 1e9); prewarm_total = 0; module_texts.clear(); for (FILE*& f : files) if (f) std::fclose(f), f = nullptr; } const int64_t now = hos_now_ns(); if (now - last_save_ns > 10000000000LL) { // (every 10 s, when something new was made) last_save_ns = now; save(); } #endif } } // namespace rx #ifdef __EMSCRIPTEN__ // (debugging: HOS_BIG_ALLOC_MB and RX_LEAK_SAMPLE, hos/web/stubs.c: they hook malloc itself, which this goes to) #endif