Add shader unit-testing (#457)

* Initialize catch-2 based unit tests

* Add nihstro submodule

Enabled only during testing to help with assembling shaders in-code.

* Implement `ADD` instruction unit-test

* Add arithmetic/logical instruction unit tests

* Add embedded catch2 submodule

Will use the host catch2 if available.

.gitmodules

@@ -61,3 +61,9 @@
 [submodule "third_party/dynarmic"]
 	path = third_party/dynarmic
 	url = https://github.com/Panda3DS-emu/dynarmic
+[submodule "third_party/nihstro"]
+	path = third_party/nihstro
+	url = https://github.com/neobrain/nihstro.git
+[submodule "third_party/Catch2"]
+	path = third_party/Catch2
+	url = https://github.com/catchorg/Catch2.git

CMakeLists.txt

@@ -33,6 +33,7 @@ option(GPU_DEBUG_INFO "Enable additional GPU debugging info" OFF)
 option(ENABLE_OPENGL "Enable OpenGL rendering backend" ON)
 option(ENABLE_VULKAN "Enable Vulkan rendering backend" ON)
 option(ENABLE_LTO "Enable link-time optimization" OFF)
+option(ENABLE_TESTS "Compile unit-tests" OFF)
 option(ENABLE_USER_BUILD "Make a user-facing build. These builds have various assertions disabled, LTO, and more" OFF)
 option(ENABLE_HTTP_SERVER "Enable HTTP server. Used for Discord bot support" OFF)
 option(ENABLE_DISCORD_RPC "Compile with Discord RPC support (disabled by default)" ON)
@@ -520,3 +521,28 @@ endif()
 if(ENABLE_LTO OR ENABLE_USER_BUILD)
     set_target_properties(Alber PROPERTIES INTERPROCEDURAL_OPTIMIZATION TRUE)
 endif()
+
+if(ENABLE_TESTS)
+    enable_testing()
+
+    find_package(Catch2 3)
+    if(NOT Catch2_FOUND)
+        add_subdirectory(third_party/Catch2)
+    endif()
+
+    add_library(nihstro-headers INTERFACE)
+    target_include_directories(nihstro-headers SYSTEM INTERFACE ./third_party/nihstro/include)
+
+    add_executable(AlberTests
+        tests/dynapica.cpp
+    )
+    target_link_libraries(
+        AlberTests
+        PRIVATE
+        Catch2::Catch2WithMain
+        AlberCore
+        nihstro-headers
+    )
+
+    add_test(AlberTests AlberTests)
+endif()

tests/dynapica.cpp

@@ -0,0 +1,229 @@
+#include <nihstro/inline_assembly.h>
+
+#include <PICA/dynapica/shader_rec.hpp>
+#include <PICA/shader.hpp>
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <initializer_list>
+#include <memory>
+
+using namespace Floats;
+static const nihstro::SourceRegister input0 = nihstro::SourceRegister::MakeInput(0);
+static const nihstro::SourceRegister input1 = nihstro::SourceRegister::MakeInput(1);
+static const nihstro::DestRegister output0 = nihstro::DestRegister::MakeOutput(0);
+
+static std::unique_ptr<PICAShader> assembleVertexShader(std::initializer_list<nihstro::InlineAsm> code) {
+	const auto shaderBinary = nihstro::InlineAsm::CompileToRawBinary(code);
+	auto newShader = std::make_unique<PICAShader>(ShaderType::Vertex);
+	newShader->reset();
+
+	for (const nihstro::Instruction& instruction : shaderBinary.program) {
+		newShader->uploadWord(instruction.hex);
+	}
+	for (const nihstro::SwizzlePattern& swizzle : shaderBinary.swizzle_table) {
+		newShader->uploadDescriptor(swizzle.hex);
+	}
+	newShader->finalize();
+	return newShader;
+}
+
+class VertexShaderTest {
+  private:
+	std::unique_ptr<PICAShader> shader;
+
+  public:
+	explicit VertexShaderTest(std::initializer_list<nihstro::InlineAsm> code) : shader(assembleVertexShader(code)) {}
+
+	// Multiple inputs, singular scalar output
+	float runScalar(std::initializer_list<float> inputs) {
+		usize inputIndex = 0;
+		for (const float& input : inputs) {
+			const std::array<Floats::f24, 4> input_vec = std::array<Floats::f24, 4>{f24::fromFloat32(input), f24::zero(), f24::zero(), f24::zero()};
+			shader->inputs[inputIndex++] = input_vec;
+		}
+		shader->run();
+		return shader->outputs[0][0];
+	}
+
+	static std::unique_ptr<VertexShaderTest> assembleTest(std::initializer_list<nihstro::InlineAsm> code) {
+		return std::make_unique<VertexShaderTest>(code);
+	}
+};
+
+TEST_CASE("ADD", "[shader][vertex]") {
+	const auto shader = VertexShaderTest::assembleTest({
+		{nihstro::OpCode::Id::ADD, output0, input0, input1},
+		{nihstro::OpCode::Id::END},
+	});
+
+	REQUIRE(shader->runScalar({+1.0f, -1.0f}) == +0.0f);
+	REQUIRE(shader->runScalar({+0.0f, -0.0f}) == -0.0f);
+	REQUIRE(std::isnan(shader->runScalar({+INFINITY, -INFINITY})));
+	REQUIRE(std::isinf(shader->runScalar({INFINITY, +1.0f})));
+	REQUIRE(std::isinf(shader->runScalar({INFINITY, -1.0f})));
+}
+
+TEST_CASE("MUL", "[shader][vertex]") {
+	const auto shader = VertexShaderTest::assembleTest({
+		{nihstro::OpCode::Id::MUL, output0, input0, input1},
+		{nihstro::OpCode::Id::END},
+	});
+
+	REQUIRE(shader->runScalar({+1.0f, -1.0f}) == -1.0f);
+	REQUIRE(shader->runScalar({-1.0f, +1.0f}) == -1.0f);
+	REQUIRE(shader->runScalar({INFINITY, 0.0f}) == 0.0f);
+	REQUIRE(shader->runScalar({+INFINITY, +INFINITY}) == INFINITY);
+	REQUIRE(shader->runScalar({+INFINITY, -INFINITY}) == -INFINITY);
+	REQUIRE(std::isnan(shader->runScalar({NAN, 0.0f})));
+}
+
+TEST_CASE("RCP", "[shader][vertex]") {
+	const auto shader = VertexShaderTest::assembleTest({
+		{nihstro::OpCode::Id::RCP, output0, input0},
+		{nihstro::OpCode::Id::END},
+	});
+
+	// REQUIRE(shader->RunScalar({-0.0f}) == INFINITY); // Violates IEEE
+	REQUIRE(shader->runScalar({0.0f}) == INFINITY);
+	REQUIRE(shader->runScalar({INFINITY}) == 0.0f);
+	REQUIRE(std::isnan(shader->runScalar({NAN})));
+
+	REQUIRE(shader->runScalar({16.0f}) == Catch::Approx(0.0625f).margin(0.001f));
+	REQUIRE(shader->runScalar({8.0f}) == Catch::Approx(0.125f).margin(0.001f));
+	REQUIRE(shader->runScalar({4.0f}) == Catch::Approx(0.25f).margin(0.001f));
+	REQUIRE(shader->runScalar({2.0f}) == Catch::Approx(0.5f).margin(0.001f));
+	REQUIRE(shader->runScalar({1.0f}) == Catch::Approx(1.0f).margin(0.001f));
+	REQUIRE(shader->runScalar({0.5f}) == Catch::Approx(2.0f).margin(0.001f));
+	REQUIRE(shader->runScalar({0.25f}) == Catch::Approx(4.0f).margin(0.001f));
+	REQUIRE(shader->runScalar({0.125f}) == Catch::Approx(8.0f).margin(0.002f));
+	REQUIRE(shader->runScalar({0.0625f}) == Catch::Approx(16.0f).margin(0.004f));
+}
+
+TEST_CASE("RSQ", "[shader][vertex]") {
+	const auto shader = VertexShaderTest::assembleTest({
+		{nihstro::OpCode::Id::RSQ, output0, input0},
+		{nihstro::OpCode::Id::END},
+	});
+
+	REQUIRE(shader->runScalar({-0.0f}) == INFINITY);
+	REQUIRE(shader->runScalar({INFINITY}) == 0.0f);
+	REQUIRE(std::isnan(shader->runScalar({-2.0f})));
+	REQUIRE(std::isnan(shader->runScalar({-INFINITY})));
+	REQUIRE(std::isnan(shader->runScalar({NAN})));
+	REQUIRE(shader->runScalar({16.0f}) == Catch::Approx(0.25f).margin(0.001f));
+	REQUIRE(shader->runScalar({8.0f}) == Catch::Approx(1.0f / std::sqrt(8.0f)).margin(0.001f));
+	REQUIRE(shader->runScalar({4.0f}) == Catch::Approx(0.5f).margin(0.001f));
+	REQUIRE(shader->runScalar({2.0f}) == Catch::Approx(1.0f / std::sqrt(2.0f)).margin(0.001f));
+	REQUIRE(shader->runScalar({1.0f}) == Catch::Approx(1.0f).margin(0.001f));
+	REQUIRE(shader->runScalar({0.5f}) == Catch::Approx(1.0f / std::sqrt(0.5f)).margin(0.001f));
+	REQUIRE(shader->runScalar({0.25f}) == Catch::Approx(2.0f).margin(0.001f));
+	REQUIRE(shader->runScalar({0.125f}) == Catch::Approx(1.0 / std::sqrt(0.125)).margin(0.002f));
+	REQUIRE(shader->runScalar({0.0625f}) == Catch::Approx(4.0f).margin(0.004f));
+}
+
+TEST_CASE("LG2", "[shader][vertex]") {
+	const auto shader = VertexShaderTest::assembleTest({
+		{nihstro::OpCode::Id::LG2, output0, input0},
+		{nihstro::OpCode::Id::END},
+	});
+
+	REQUIRE(std::isnan(shader->runScalar({NAN})));
+	REQUIRE(std::isnan(shader->runScalar({-1.f})));
+	REQUIRE(std::isinf(shader->runScalar({0.f})));
+	REQUIRE(shader->runScalar({4.f}) == Catch::Approx(2.f));
+	REQUIRE(shader->runScalar({64.f}) == Catch::Approx(6.f));
+	REQUIRE(shader->runScalar({1.e24f}) == Catch::Approx(79.7262742773f));
+}
+
+TEST_CASE("EX2", "[shader][vertex]") {
+	const auto shader = VertexShaderTest::assembleTest({
+		{nihstro::OpCode::Id::EX2, output0, input0},
+		{nihstro::OpCode::Id::END},
+	});
+
+	REQUIRE(std::isnan(shader->runScalar({NAN})));
+	REQUIRE(shader->runScalar({-800.f}) == Catch::Approx(0.f));
+	REQUIRE(shader->runScalar({0.f}) == Catch::Approx(1.f));
+	REQUIRE(shader->runScalar({2.f}) == Catch::Approx(4.f));
+	REQUIRE(shader->runScalar({6.f}) == Catch::Approx(64.f));
+	REQUIRE(shader->runScalar({79.7262742773f}) == Catch::Approx(1.e24f));
+	REQUIRE(std::isinf(shader->runScalar({800.f})));
+}
+
+TEST_CASE("MAX", "[shader][vertex]") {
+	const auto shader = VertexShaderTest::assembleTest({
+		{nihstro::OpCode::Id::MAX, output0, input0, input1},
+		{nihstro::OpCode::Id::END},
+	});
+
+	REQUIRE(shader->runScalar({1.0f, 0.0f}) == 1.0f);
+	REQUIRE(shader->runScalar({0.0f, 1.0f}) == 1.0f);
+	REQUIRE(shader->runScalar({0.0f, +INFINITY}) == +INFINITY);
+	REQUIRE(shader->runScalar({0.0f, -INFINITY}) == -INFINITY);
+	REQUIRE(shader->runScalar({NAN, 0.0f}) == 0.0f);
+	REQUIRE(shader->runScalar({-INFINITY, +INFINITY}) == +INFINITY);
+	REQUIRE(std::isnan(shader->runScalar({0.0f, NAN})));
+}
+
+TEST_CASE("MIN", "[shader][vertex]") {
+	const auto shader = VertexShaderTest::assembleTest({
+		{nihstro::OpCode::Id::MIN, output0, input0, input1},
+		{nihstro::OpCode::Id::END},
+	});
+
+	REQUIRE(shader->runScalar({1.0f, 0.0f}) == 0.0f);
+	REQUIRE(shader->runScalar({0.0f, 1.0f}) == 0.0f);
+	REQUIRE(shader->runScalar({0.0f, +INFINITY}) == 0.0f);
+	REQUIRE(shader->runScalar({0.0f, -INFINITY}) == -INFINITY);
+	REQUIRE(shader->runScalar({NAN, 0.0f}) == 0.0f);
+	REQUIRE(shader->runScalar({-INFINITY, +INFINITY}) == -INFINITY);
+	REQUIRE(std::isnan(shader->runScalar({0.0f, NAN})));
+}
+
+TEST_CASE("SGE", "[shader][vertex]") {
+	const auto shader = VertexShaderTest::assembleTest({
+		{nihstro::OpCode::Id::SGE, output0, input0, input1},
+		{nihstro::OpCode::Id::END},
+	});
+
+	REQUIRE(shader->runScalar({INFINITY, 0.0f}) == 1.0f);
+	REQUIRE(shader->runScalar({0.0f, INFINITY}) == 0.0f);
+	REQUIRE(shader->runScalar({NAN, 0.0f}) == 0.0f);
+	REQUIRE(shader->runScalar({0.0f, NAN}) == 0.0f);
+	REQUIRE(shader->runScalar({+INFINITY, +INFINITY}) == 1.0f);
+	REQUIRE(shader->runScalar({+INFINITY, -INFINITY}) == 1.0f);
+	REQUIRE(shader->runScalar({-INFINITY, +INFINITY}) == 0.0f);
+	REQUIRE(shader->runScalar({+1.0f, -1.0f}) == 1.0f);
+	REQUIRE(shader->runScalar({-1.0f, +1.0f}) == 0.0f);
+}
+
+TEST_CASE("SLT", "[shader][vertex]") {
+	const auto shader = VertexShaderTest::assembleTest({
+		{nihstro::OpCode::Id::SLT, output0, input0, input1},
+		{nihstro::OpCode::Id::END},
+	});
+
+	REQUIRE(shader->runScalar({INFINITY, 0.0f}) == 0.0f);
+	REQUIRE(shader->runScalar({0.0f, INFINITY}) == 1.0f);
+	REQUIRE(shader->runScalar({NAN, 0.0f}) == 0.0f);
+	REQUIRE(shader->runScalar({0.0f, NAN}) == 0.0f);
+	REQUIRE(shader->runScalar({+INFINITY, +INFINITY}) == 0.0f);
+	REQUIRE(shader->runScalar({+INFINITY, -INFINITY}) == 0.0f);
+	REQUIRE(shader->runScalar({-INFINITY, +INFINITY}) == 1.0f);
+	REQUIRE(shader->runScalar({+1.0f, -1.0f}) == 0.0f);
+	REQUIRE(shader->runScalar({-1.0f, +1.0f}) == 1.0f);
+}
+
+TEST_CASE("FLR", "[shader][vertex]") {
+	const auto shader = VertexShaderTest::assembleTest({
+		{nihstro::OpCode::Id::FLR, output0, input0},
+		{nihstro::OpCode::Id::END},
+	});
+
+	REQUIRE(shader->runScalar({0.5}) == 0.0f);
+	REQUIRE(shader->runScalar({-0.5}) == -1.0f);
+	REQUIRE(shader->runScalar({1.5}) == 1.0f);
+	REQUIRE(shader->runScalar({-1.5}) == -2.0f);
+	REQUIRE(std::isnan(shader->runScalar({NAN})));
+	REQUIRE(std::isinf(shader->runScalar({INFINITY})));
+}

third_party/Catch2

@@ -0,0 +1 @@
+Subproject commit 4acc51828f7f93f3b2058a63f54d112af4034503

third_party/nihstro

@@ -0,0 +1 @@
+Subproject commit e924e21b1da60170f0f0a4e5a073cb7d579969c0