Files
Triforce-Source/tests/test_taau_env_lookup.py
ruckus7382sfgsgdf 6f338c8f56 Triforce v0.5.0
In-game mods (GameBanana browser, search and installs, with the Mask Salesman), code-patch and cheat mods, the devs' test18 to test45 work (full performance overlay, frame pacing on, steady frame rate, save export and import, bug capture, new options rows, Setup's Mods page and Add to Steam), occlusion queries and new defaults, Auto resolution that scales, replay helper threads and robust buffers off by default, the options in sections.
2026-11-17 22:40:50 -06:00

177 lines
9.1 KiB
Python

"""Actual-source TAAU key/full stand-in spy; GPU boundaries are spies, no Vulkan loader or performance measurement.
Use --emit-only FILE to stage C++ without invoking a compiler.
"""
# SPDX-License-Identifier: GPL-3.0-or-later
import argparse
from pathlib import Path
import re
import subprocess
import tempfile
RUN_ALL_ARGS = ["--cxx", "g++"]
ROOT = Path(__file__).resolve().parents[1]
def block(source, marker):
start = source.index(marker)
return source[start:start + re.search(r'^}', source[start:], re.M).end()]
def fixture(source):
return (PREFIX + block(source, 'bool taau_key(uint64_t key) {') + '\n' +
block(source, 'bool taau_stand_in(VkCommandBuffer cmd,') + '\n' + SUFFIX)
PREFIX = r'''
#define _CRT_SECURE_NO_WARNINGS
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
static const char *configured_keys, *no_f16;
static int key_reads;
static const char* fixture_getenv(const char* name) {
if (!strcmp(name, "RX_VK_TAAU_KEYS")) { ++key_reads; return configured_keys; }
if (!strcmp(name, "RX_VK_NO_F16")) return no_f16;
return nullptr;
}
#define getenv fixture_getenv
namespace Shader { namespace Backend { namespace SPIRV { static bool mma_software = true; } } }
using VkCommandBuffer = int;
using VkImageView = int;
constexpr int VK_IMAGE_VIEW_TYPE_2D=2, VK_FORMAT_B10G11R11_UFLOAT_PACK32=7;
enum class ViewUse { Storage };
struct Desc { unsigned count=1; int format=23; };
struct Info { std::vector<Desc> texture_descriptors, image_descriptors; };
struct Stage { Info info; };
struct NvnState {};
struct Program { uint64_t key; std::vector<Stage> stages; };
struct Texture { int format=VK_FORMAT_B10G11R11_UFLOAT_PACK32; };
static Texture texture;
static struct { bool push_descriptor=false; } dev;
static bool vkCmdPushDescriptorSetKHR=true;
struct ImageInfo { VkImageView imageView; };
static struct DrawWork { std::vector<ImageInfo> imgs; } draw_work;
static DrawWork& dw() { return draw_work; } // (vk_draw.cpp's dw is a TLS_OBJECT: the calling thread's, by a call)
static unsigned handle_value=5;
static bool resolve_image=true, upscale_result=true;
static int upscale_calls, view_calls, handle_calls;
static VkCommandBuffer forwarded_cmd;
static VkImageView forwarded_input,forwarded_output;
static Texture* forwarded_texture;
static uint32_t forwarded_level;
static uint64_t forwarded_key;
static std::string forwarded_text;
static bool forwarded_temporal;
static uint32_t handle_of(const NvnState&,const Stage&,const Desc&,uint32_t index){
++handle_calls;return index==0?handle_value:0;
}
static int image_format(int f){return f+100;}
static VkImageView texture_view_of(uint32_t handle,int type,ViewUse use,int format,Texture** out,uint32_t* level){
++view_calls;
if(handle!=5 || type!=VK_IMAGE_VIEW_TYPE_2D || use!=ViewUse::Storage || format!=123) return 0;
*out=resolve_image?&texture:nullptr;*level=7;return 99;
}
/* (the recording lock of a parallel replay: taau_stand_in holds it around typed_upscale, whose pipeline and history images
every recording thread shares) */
static int lock_depth;
struct ParLock { ParLock(){lock_depth++;} ~ParLock(){lock_depth--;} };
static bool typed_upscale(VkCommandBuffer cmd,VkImageView input,VkImageView output,Texture* out,uint32_t level,uint64_t key,const char* text,bool temporal){
if(lock_depth<=0) return false; /* (not under the lock: the upscale is refused, and the checks of its calls fail) */
++upscale_calls;forwarded_cmd=cmd;forwarded_input=input;forwarded_output=output;forwarded_texture=out;
forwarded_level=level;forwarded_key=key;forwarded_text=text;forwarded_temporal=temporal;return upscale_result;
}
'''
SUFFIX = r'''
static unsigned failures=0;
static void check(bool ok,const char* what){if(!ok){++failures;fprintf(stderr,"FAIL: %s\n",what);}}
int main(int argc,char** argv){
if(argc!=2)return 90;
uint64_t target=0xfd029a317a9a4b94ull;bool expected=true;
if(!strcmp(argv[1],"hardware"))Shader::Backend::SPIRV::mma_software=false,expected=false;
else if(!strcmp(argv[1],"no-f16"))Shader::Backend::SPIRV::mma_software=false,no_f16="1";
else if(!strcmp(argv[1],"empty"))configured_keys="",expected=false;
else if(!strcmp(argv[1],"disabled"))configured_keys="-",expected=false;
else if(!strcmp(argv[1],"custom"))configured_keys="0123456789abcdef",target=0x0123456789abcdefull;
else if(!strcmp(argv[1],"prefixes"))configured_keys="abcd,fd029a";
else if(strcmp(argv[1],"software"))return 91;
check(taau_key(target)==expected && !taau_key(0),"existing key matcher unchanged");
NvnState state{};Program program{target,{}};Stage stage;
stage.info.texture_descriptors={{1,23},{2,23}};stage.info.image_descriptors={{1,23}};program.stages.push_back(stage);
key_reads=0;
check(!taau_stand_in(19,state,program),"capability rejection unchanged");
check(key_reads==0,"first rejected invocation performs no key lookup after matcher priming");
key_reads=0;
for(int i=0;i<1000;i++)check(!taau_stand_in(19,state,program),"warm rejection unchanged");
check(key_reads==0,"1000 warm rejected invocations perform no key lookup");
check(handle_calls==0 && view_calls==0 && upscale_calls==0,"capability rejection avoids resource boundary calls");
if(expected){
dev.push_descriptor=true;dw().imgs={{11},{22},{33},{44}};
auto rejected=[&](const char* what){key_reads=0;int prior=upscale_calls;check(!taau_stand_in(19,state,program),what);check(key_reads==0 && upscale_calls==prior,"rejected resource guard never reads/forwards keys");};
vkCmdPushDescriptorSetKHR=false;rejected("missing push entry");vkCmdPushDescriptorSetKHR=true;
auto stages=program.stages;program.stages.clear();rejected("empty stages");program.stages=stages;
program.stages[0].info.texture_descriptors.clear();rejected("no textures");program.stages=stages;
program.stages[0].info.image_descriptors.clear();rejected("no images");program.stages=stages;
dw().imgs.pop_back();rejected("descriptor span too short");dw().imgs.push_back({44});
dw().imgs[0].imageView=0;rejected("no input view");dw().imgs[0].imageView=11;
dw().imgs[3].imageView=0;rejected("no output view");dw().imgs[3].imageView=44;
handle_value=0;rejected("no handle");handle_value=5;
resolve_image=false;rejected("no resolved image");resolve_image=true;
texture.format=0;rejected("wrong output format");texture.format=VK_FORMAT_B10G11R11_UFLOAT_PACK32;
auto accepted=[&](const char* text,bool result){
key_reads=0;int prior=upscale_calls;upscale_result=result;
check(taau_stand_in(19,state,program)==result,"eligible helper result forwarded");
check(upscale_calls==prior+1 && key_reads==(configured_keys?2:1),"eligible invocation retains per-call lookup count");
check(forwarded_cmd==19 && forwarded_input==11 && forwarded_output==44 && forwarded_texture==&texture && forwarded_level==7 && forwarded_key==target && forwarded_temporal,"eligible arguments preserved");
check(forwarded_text==text,"current key text forwarded verbatim");
};
accepted(configured_keys?configured_keys:"fd029a317a9a4b94",true);
configured_keys="later diagnostic override";accepted(configured_keys,false);
configured_keys=nullptr;accepted("fd029a317a9a4b94",true);
}
printf("%s failures=%u eligible=%d\n",argv[1],failures,upscale_calls);
return failures?1:0;
}
'''
def main():
p = argparse.ArgumentParser(description=__doc__)
p.add_argument('--source', type=Path, default=ROOT)
p.add_argument('--cxx', default='clang++')
p.add_argument('--emit-only', type=Path)
p.add_argument('--cxx-arg', action='append', default=[], help='extra compiler/linker flag (repeatable)')
args = p.parse_args()
cpp = fixture((args.source / 'gpu/vk/vk_draw.cpp').read_text(encoding='utf-8'))
if args.emit_only:
with args.emit_only.open('x', encoding='utf-8') as f:
f.write(cpp)
print('STAGED ONLY:', args.emit_only)
return
with tempfile.TemporaryDirectory(prefix='taau-env-') as temp:
folder = Path(temp)
source, exe = folder / 'fixture.cpp', folder / 'fixture.exe'
source.write_text(cpp, encoding='utf-8')
if Path(args.cxx).name.lower() in ('cl', 'cl.exe', 'clang-cl', 'clang-cl.exe'):
command = [args.cxx, '/nologo', '/std:c++17', '/EHsc', '/W4', '/WX', str(source),
'/Fo' + str(folder / 'fixture.obj'), '/Fe' + str(exe), *args.cxx_arg]
else:
command = [args.cxx, '-std=c++17', '-Wall', '-Wextra', '-Werror', *args.cxx_arg, str(source), '-o', str(exe)]
subprocess.run(command, cwd=folder, check=True)
failed = False
for case in ('software', 'hardware', 'no-f16', 'empty', 'disabled', 'custom', 'prefixes'):
result = subprocess.run([str(exe), case], cwd=folder)
print(case, 'exit', result.returncode, flush=True)
failed |= result.returncode != 0
if failed:
raise SystemExit(1)
print('PASS: seven key configurations; rejected lookups removed, eligible per-call forwarding preserved')
if __name__ == '__main__':
main()