Skip to content
Draft
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
24 changes: 23 additions & 1 deletion .github/workflows/build.yml
Original file line number Diff line number Diff line change
Expand Up @@ -119,8 +119,30 @@ jobs:
mkw_macos_context_abi_tests \
mkw_macos_host_context_tests \
mkw_macos_guest_flat_memory_tests \
mkw_macos_external_audio_tests
mkw_macos_external_audio_tests \
mkw_ax_mix_kernels_tests

- name: Test execution substrate
shell: bash
run: ctest --test-dir build-macos --output-on-failure

- name: Check ARM audio kernels with sanitizers
shell: bash
run: |
clang++ -std=c++17 -O2 -fno-fast-math \
-fsanitize=address,undefined -fno-sanitize-recover=all \
-DMKW_AX_MIX_REQUIRE_NEON=1 \
-Iruntime/include -Iruntime/src/hle/audio \
runtime/tests/ax_mix_kernels_tests.cpp -o build-macos/ax-mix-sanitized
build-macos/ax-mix-sanitized
build-macos/mkw_ax_mix_kernels_tests --benchmark 20000

- name: Build and test GX performance paths
shell: bash
run: |
cmake -S runtime -B build-macos -DMKW_BUILD_AURORA_TESTS=ON
cmake --build build-macos --parallel 3 --target \
gx_fifo_tests shader_module_cache_tests gx_shader_layout_tests \
mkw_gx_texture_binding_tests mkw_gx_sync_tests mkw_gx_dl_cache_tests
ctest --test-dir build-macos --output-on-failure \
-R '^(GXFifoTest|RuntimeDirectDrawTest|ShaderModuleCacheTest|GxShader(Layout|Key|Arena|Mode|State)|mkw_gx_(texture_binding|sync|dl_cache)_tests)'
2 changes: 1 addition & 1 deletion aurora-main
60 changes: 60 additions & 0 deletions runtime/cmake/PlatformTests.cmake
Original file line number Diff line number Diff line change
Expand Up @@ -155,6 +155,7 @@ endif()
if(TARGET gx_fifo_tests)
target_sources(gx_fifo_tests PRIVATE
"${MKW_TEST_RUNTIME_DIR}/tests/gx_fifo_invalidation_tests.cpp"
"${MKW_TEST_RUNTIME_DIR}/tests/gx_direct_draw_tests.cpp"
"${MKW_TEST_RUNTIME_DIR}/src/hle/gx/gx_fifo.cpp")
target_include_directories(gx_fifo_tests PRIVATE
"${MKW_AURORA_DIR}/tests" "${MKW_TEST_RUNTIME_DIR}/include"
Expand All @@ -164,7 +165,66 @@ if(TARGET gx_fifo_tests)
if(MKW_PLATFORM_WINDOWS)
target_link_libraries(gx_fifo_tests PRIVATE advapi32)
endif()

get_target_property(_mkw_gx_sources gx_fifo_tests SOURCES)
get_target_property(_mkw_gx_source_dir gx_fifo_tests SOURCE_DIR)
get_target_property(_mkw_gx_includes gx_fifo_tests INCLUDE_DIRECTORIES)
get_target_property(_mkw_gx_links gx_fifo_tests LINK_LIBRARIES)
set(_mkw_gx_encoder_sources)
foreach(_mkw_gx_source IN LISTS _mkw_gx_sources)
if(_mkw_gx_source MATCHES "(^|/)lib/")
get_filename_component(_mkw_gx_absolute "${_mkw_gx_source}" ABSOLUTE
BASE_DIR "${_mkw_gx_source_dir}")
list(APPEND _mkw_gx_encoder_sources "${_mkw_gx_absolute}")
endif()
endforeach()

add_executable(mkw_gx_texture_binding_tests
"${MKW_TEST_RUNTIME_DIR}/tests/gx_texture_binding_tests.cpp"
"${MKW_AURORA_DIR}/tests/gx_test_stubs.cpp"
${_mkw_gx_encoder_sources})
add_executable(mkw_gx_sync_tests
"${MKW_TEST_RUNTIME_DIR}/tests/gx_worker_tests.cpp"
"${MKW_TEST_RUNTIME_DIR}/tests/gx_copy_tests.cpp"
"${MKW_AURORA_DIR}/tests/gx_test_stubs.cpp"
${_mkw_gx_encoder_sources})
target_compile_definitions(mkw_gx_sync_tests PRIVATE MKW_GX_COPY_TESTING=1)
foreach(_mkw_gx_test IN ITEMS mkw_gx_texture_binding_tests mkw_gx_sync_tests)
target_include_directories(${_mkw_gx_test} PRIVATE
${_mkw_gx_includes} "${MKW_TEST_RUNTIME_DIR}/tests")
target_compile_definitions(${_mkw_gx_test} PRIVATE AURORA TARGET_PC=1)
target_compile_features(${_mkw_gx_test} PRIVATE cxx_std_20)
target_link_libraries(${_mkw_gx_test} PRIVATE ${_mkw_gx_links} Threads::Threads)
set_target_properties(${_mkw_gx_test} PROPERTIES UNITY_BUILD OFF)
aurora_copy_runtime_dlls(${_mkw_gx_test})
add_test(NAME ${_mkw_gx_test} COMMAND ${_mkw_gx_test})
set_tests_properties(${_mkw_gx_test} PROPERTIES TIMEOUT 120)
endforeach()

add_executable(mkw_gx_dl_cache_tests "${MKW_TEST_RUNTIME_DIR}/tests/gx_dl_cache_tests.cpp")
target_include_directories(mkw_gx_dl_cache_tests PRIVATE
"${MKW_TEST_RUNTIME_DIR}/include"
"${MKW_TEST_RUNTIME_DIR}/third_party/toml11"
"${MKW_AURORA_DIR}/include")
target_compile_features(mkw_gx_dl_cache_tests PRIVATE cxx_std_20)
target_compile_definitions(mkw_gx_dl_cache_tests PRIVATE AURORA TARGET_PC=1 NOMINMAX)
target_link_libraries(mkw_gx_dl_cache_tests PRIVATE xxHash::xxhash ${AURORA_SDL3_TARGET})
set_target_properties(mkw_gx_dl_cache_tests PROPERTIES UNITY_BUILD OFF)
add_test(NAME mkw_gx_dl_cache_tests COMMAND mkw_gx_dl_cache_tests)
endif()

add_executable(mkw_ax_mix_kernels_tests "${MKW_TEST_RUNTIME_DIR}/tests/ax_mix_kernels_tests.cpp")
target_include_directories(mkw_ax_mix_kernels_tests PRIVATE
"${MKW_TEST_RUNTIME_DIR}/include"
"${MKW_TEST_RUNTIME_DIR}/src/hle/audio")
target_compile_features(mkw_ax_mix_kernels_tests PRIVATE cxx_std_17)
if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|ARM64)$")
target_compile_definitions(mkw_ax_mix_kernels_tests PRIVATE MKW_AX_MIX_REQUIRE_NEON=1)
elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(AMD64|amd64|x86_64|X86_64)$")
target_compile_options(mkw_ax_mix_kernels_tests PRIVATE -march=x86-64-${MKW_X86_CPU_PROFILE})
endif()
set_target_properties(mkw_ax_mix_kernels_tests PROPERTIES UNITY_BUILD OFF)
add_test(NAME mkw_ax_mix_kernels_tests COMMAND mkw_ax_mix_kernels_tests)

add_executable(mkw_fiber_manager_tests
"${MKW_TEST_RUNTIME_DIR}/tests/fiber_manager_tests.cpp"
Expand Down
14 changes: 14 additions & 0 deletions runtime/include/runtime_config.h
Original file line number Diff line number Diff line change
Expand Up @@ -47,6 +47,7 @@ struct RuntimeUserConfig {
std::optional<std::string> displayMode;
std::optional<uint32_t> frameInterpolationFps;
std::optional<bool> metalFxSpatialUpscaling;
std::optional<std::string> shaderMode;
std::optional<bool> skipUnreadyPipelines;
std::optional<bool> vsync;
std::optional<bool> gxWorker;
Expand Down Expand Up @@ -294,6 +295,7 @@ inline void EnsureConfigFile() {
"frame_interpolation_fps = 0\n"
"display_mode = \"windowed\"\n"
"graphics_api = \"auto\"\n"
"shader_mode = 'specialized'\n"
"skip_unready_pipelines = true\n"
"vsync = false\n"
"# Runs GX command processing on its own thread. Read once, at startup.\n"
Expand Down Expand Up @@ -485,6 +487,10 @@ inline RuntimeUserConfig ParseConfigDocument(const toml::value& document) {
}
config.metalFxSpatialUpscaling =
FindConfigValue<bool>(document, "video", "metalfx_spatial_upscaling");
if (auto value = FindConfigValue<std::string>(document, "video", "shader_mode");
value && (*value == "specialized" || *value == "hybrid")) {
config.shaderMode = *value;
}
config.skipUnreadyPipelines = FindConfigValue<bool>(document, "video", "skip_unready_pipelines");
config.vsync = FindConfigValue<bool>(document, "video", "vsync");
config.gxWorker = FindConfigValue<bool>(document, "video", "gx_worker");
Expand Down Expand Up @@ -702,6 +708,12 @@ inline bool SetDisplayMode(std::string value) {
return WriteSetting("video", "display_mode", FormatString(value));
}

inline bool SetShaderMode(std::string value) {
if (value != "specialized" && value != "hybrid") return false;
Mutable().shaderMode = value;
return WriteSetting("video", "shader_mode", FormatString(value));
}

inline bool SetSkipUnreadyPipelines(bool value) {
Mutable().skipUnreadyPipelines = value;
return WriteSetting("video", "skip_unready_pipelines", value ? "true" : "false");
Expand Down Expand Up @@ -1036,6 +1048,8 @@ inline uint32_t FrameInterpolationFps(uint32_t fallback = 0) {
return Get().frameInterpolationFps.value_or(fallback);
}

inline std::string ShaderMode() { return Get().shaderMode.value_or("specialized"); }

// Whether to skip draws whose graphics pipeline has not finished compiling yet.
inline bool SkipUnreadyPipelines(bool fallback = true) {
return Get().skipUnreadyPipelines.value_or(fallback);
Expand Down
130 changes: 123 additions & 7 deletions runtime/src/hle/audio/ax_mix_kernels.h
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,7 @@
#include "isa/big_endian.h"

// AX/DSP fixed-point mix kernels: the inner loops of the AXWii command-list mix in ax_mix.cpp.
// Each exists as a scalar reference (a literal transcription of the loop it replaced) and an AVX2 form.
// Each has a scalar reference and architecture-specific SIMD forms.

#include <cstddef>
#include <cstdint>
Expand All @@ -16,8 +16,23 @@
#define MKW_AX_MIX_AVX2 0
#endif

#if !MKW_AX_MIX_AVX2 && defined(__aarch64__) && defined(__ARM_NEON) && !defined(__AARCH64EB__)
#include <arm_neon.h>
#define MKW_AX_MIX_NEON 1
#else
#define MKW_AX_MIX_NEON 0
#endif

namespace AxMixKernels {

// Mix buses retain the low 32 bits, matching the SIMD adds.
inline int32_t AddWrap32(int32_t value, uint32_t addend) {
const uint32_t bits = static_cast<uint32_t>(value) + addend;
int32_t result;
std::memcpy(&result, &bits, sizeof(result));
return result;
}

inline int16_t ClampToS16(int32_t value) {
if (value < -0x8000) {
return static_cast<int16_t>(-0x8000);
Expand All @@ -39,7 +54,7 @@ inline uint16_t MixAddRampScalar(int32_t* out, const int16_t* input, uint32_t co
const int32_t scaled =
(static_cast<int32_t>(input[i]) * static_cast<int32_t>(volume)) >> 15;
const int16_t sample = ClampToS16(scaled);
out[i] += sample;
out[i] = AddWrap32(out[i], static_cast<uint32_t>(sample));
volume = static_cast<uint16_t>(volume + delta);
last = sample;
}
Expand Down Expand Up @@ -90,7 +105,7 @@ inline uint16_t MixAddRampAvx2(int32_t* out, const int16_t* input, uint32_t coun
const int32_t scaled =
(static_cast<int32_t>(input[i]) * static_cast<int32_t>(volume)) >> 15;
const int16_t sample = ClampToS16(scaled);
out[i] += sample;
out[i] = AddWrap32(out[i], static_cast<uint32_t>(sample));
volume = static_cast<uint16_t>(volume + delta);
last = sample;
}
Expand All @@ -99,10 +114,46 @@ inline uint16_t MixAddRampAvx2(int32_t* out, const int16_t* input, uint32_t coun
}
#endif

#if MKW_AX_MIX_NEON
inline uint16x4_t Ramp4(uint16_t volume, uint16_t delta) {
static constexpr uint16_t lanes[] = {0, 1, 2, 3};
return vmla_n_u16(vdup_n_u16(volume), vld1_u16(lanes), delta);
}

inline int16x4_t ScaleBlock4(int16x4_t samples, uint16x4_t ramp) {
const int32x4_t gain = vreinterpretq_s32_u32(vmovl_u16(ramp));
const int32x4_t product = vmulq_s32(vmovl_s16(samples), gain);
return vqmovn_s32(vshrq_n_s32(product, 15));
}

inline uint16_t MixAddRampNeon(int32_t* out, const int16_t* input, uint32_t count,
uint16_t volume, uint16_t delta, int16_t& dpop) {
uint32_t i = 0;
int16_t last = dpop;
if (count >= 4) {
uint16x4_t ramp = Ramp4(volume, delta);
const uint16x4_t step = vdup_n_u16(static_cast<uint16_t>(delta * 4u));
int16x4_t block = vdup_n_s16(0);
for (; count - i >= 4; i += 4) {
block = ScaleBlock4(vld1_s16(input + i), ramp);
vst1q_s32(out + i, vaddw_s16(vld1q_s32(out + i), block));
ramp = vadd_u16(ramp, step);
}
last = vget_lane_s16(block, 3);
volume = vget_lane_u16(ramp, 0);
}
volume = MixAddRampScalar(out + i, input + i, count - i, volume, delta, last);
dpop = last;
return volume;
}
#endif

inline uint16_t MixAddRamp(int32_t* out, const int16_t* input, uint32_t count,
uint16_t volume, uint16_t delta, int16_t& dpop) {
#if MKW_AX_MIX_AVX2
return MixAddRampAvx2(out, input, count, volume, delta, dpop);
#elif MKW_AX_MIX_NEON
return MixAddRampNeon(out, input, count, volume, delta, dpop);
#else
return MixAddRampScalar(out, input, count, volume, delta, dpop);
#endif
Expand Down Expand Up @@ -162,10 +213,29 @@ inline uint16_t ScaleRampAvx2(int16_t* samples, uint32_t count, uint16_t volume,
}
#endif

#if MKW_AX_MIX_NEON
inline uint16_t ScaleRampNeon(int16_t* samples, uint32_t count, uint16_t volume,
uint16_t delta) {
uint32_t i = 0;
if (count >= 4) {
uint16x4_t ramp = Ramp4(volume, delta);
const uint16x4_t step = vdup_n_u16(static_cast<uint16_t>(delta * 4u));
for (; count - i >= 4; i += 4) {
vst1_s16(samples + i, ScaleBlock4(vld1_s16(samples + i), ramp));
ramp = vadd_u16(ramp, step);
}
volume = vget_lane_u16(ramp, 0);
}
return ScaleRampScalar(samples + i, count - i, volume, delta);
}
#endif

inline uint16_t ScaleRamp(int16_t* samples, uint32_t count, uint16_t volume,
uint16_t delta) {
#if MKW_AX_MIX_AVX2
return ScaleRampAvx2(samples, count, volume, delta);
#elif MKW_AX_MIX_NEON
return ScaleRampNeon(samples, count, volume, delta);
#else
return ScaleRampScalar(samples, count, volume, delta);
#endif
Expand All @@ -179,8 +249,9 @@ inline uint16_t ScaleRamp(int16_t* samples, uint32_t count, uint16_t volume,
inline void MixAccumRamp32Scalar(int32_t* dst, const int32_t* src, const uint16_t* ramp,
uint32_t count) {
for (uint32_t i = 0; i < count; ++i) {
dst[i] += static_cast<int32_t>(
(static_cast<int64_t>(src[i]) * static_cast<int64_t>(ramp[i])) >> 15);
const int64_t product = static_cast<int64_t>(src[i]) * ramp[i];
const uint32_t scaled = static_cast<uint32_t>(static_cast<uint64_t>(product) >> 15);
dst[i] = AddWrap32(dst[i], scaled);
}
}

Expand Down Expand Up @@ -208,16 +279,37 @@ inline void MixAccumRamp32Avx2(int32_t* dst, const int32_t* src, const uint16_t*
_mm256_add_epi32(acc, result));
}
for (; i < count; ++i) {
dst[i] += static_cast<int32_t>(
(static_cast<int64_t>(src[i]) * static_cast<int64_t>(ramp[i])) >> 15);
const int64_t product = static_cast<int64_t>(src[i]) * ramp[i];
const uint32_t scaled = static_cast<uint32_t>(static_cast<uint64_t>(product) >> 15);
dst[i] = AddWrap32(dst[i], scaled);
}
}
#endif

#if MKW_AX_MIX_NEON
inline void MixAccumRamp32Neon(int32_t* dst, const int32_t* src, const uint16_t* ramp,
uint32_t count) {
uint32_t i = 0;
for (; count - i >= 4; i += 4) {
const int32x4_t source = vld1q_s32(src + i);
const int32x4_t gain = vreinterpretq_s32_u32(vmovl_u16(vld1_u16(ramp + i)));
const int64x2_t lowProduct = vmull_s32(vget_low_s32(source), vget_low_s32(gain));
const int64x2_t highProduct = vmull_s32(vget_high_s32(source), vget_high_s32(gain));
// Keep bits 15..46, including products whose shifted value exceeds int32.
const int32x4_t scaled = vcombine_s32(vshrn_n_s64(lowProduct, 15),
vshrn_n_s64(highProduct, 15));
vst1q_s32(dst + i, vaddq_s32(vld1q_s32(dst + i), scaled));
}
MixAccumRamp32Scalar(dst + i, src + i, ramp + i, count - i);
}
#endif

inline void MixAccumRamp32(int32_t* dst, const int32_t* src, const uint16_t* ramp,
uint32_t count) {
#if MKW_AX_MIX_AVX2
MixAccumRamp32Avx2(dst, src, ramp, count);
#elif MKW_AX_MIX_NEON
MixAccumRamp32Neon(dst, src, ramp, count);
#else
MixAccumRamp32Scalar(dst, src, ramp, count);
#endif
Expand Down Expand Up @@ -270,9 +362,31 @@ inline void LoadBigEndian32Avx2(int32_t* dst, const uint8_t* src, size_t count)
}
#endif

#if MKW_AX_MIX_NEON
inline void StoreBigEndian32Neon(uint8_t* dst, const int32_t* src, size_t count) {
size_t i = 0;
for (; count - i >= 4; i += 4) {
const uint8x16_t bytes = vreinterpretq_u8_s32(vld1q_s32(src + i));
vst1q_u8(dst + i * sizeof(uint32_t), vrev32q_u8(bytes));
}
StoreBigEndian32Scalar(dst + i * sizeof(uint32_t), src + i, count - i);
}

inline void LoadBigEndian32Neon(int32_t* dst, const uint8_t* src, size_t count) {
size_t i = 0;
for (; count - i >= 4; i += 4) {
const uint8x16_t bytes = vld1q_u8(src + i * sizeof(uint32_t));
vst1q_s32(dst + i, vreinterpretq_s32_u8(vrev32q_u8(bytes)));
}
LoadBigEndian32Scalar(dst + i, src + i * sizeof(uint32_t), count - i);
}
#endif

inline void StoreBigEndian32(uint8_t* dst, const int32_t* src, size_t count) {
#if MKW_AX_MIX_AVX2
StoreBigEndian32Avx2(dst, src, count);
#elif MKW_AX_MIX_NEON
StoreBigEndian32Neon(dst, src, count);
#else
StoreBigEndian32Scalar(dst, src, count);
#endif
Expand All @@ -281,6 +395,8 @@ inline void StoreBigEndian32(uint8_t* dst, const int32_t* src, size_t count) {
inline void LoadBigEndian32(int32_t* dst, const uint8_t* src, size_t count) {
#if MKW_AX_MIX_AVX2
LoadBigEndian32Avx2(dst, src, count);
#elif MKW_AX_MIX_NEON
LoadBigEndian32Neon(dst, src, count);
#else
LoadBigEndian32Scalar(dst, src, count);
#endif
Expand Down
Loading
Loading