Files
Triforce-Source/tests/test_taau_env_lookup.py
ruckus7382sfgsgdf 6c7117635c 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.
2026-11-20 17:06:21 -06:00

185 lines
9.8 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--;} };
/* ((Triforce, FG-2) the picture it wrote, taken for frame generation after the upscale: outside the lock, when it drew) */
static int hudless_calls, hudless_lock_depth = -1;
static uint64_t hudless_key;
static void hudless_after_dispatch(VkCommandBuffer,uint64_t key){++hudless_calls;hudless_key=key;hudless_lock_depth=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;
check(hudless_calls==0,"a rejected invocation takes no picture for frame generation");
auto accepted=[&](const char* text,bool result){
key_reads=0;int prior=upscale_calls;upscale_result=result;
const int hudless_before=hudless_calls;
check(taau_stand_in(19,state,program)==result,"eligible helper result forwarded");
check(hudless_calls==hudless_before+(result?1:0) && (!result || (hudless_key==target && hudless_lock_depth==0)),
"the picture it drew is taken for frame generation, outside the recording lock, and only when it drew");
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()