test_01: load metallib by path to run on paravirtual CI GPU

Replace the MetalAdder class usage with a direct Metal C++ dispatch that
loads default.metallib by explicit path (just like tests 02 and 03 do).
newDefaultLibrary() searches for an app bundle and silently produces
all-zero results on the CI paravirtual device; newLibrary(path) works fine.

Also drops MetalAdder.cpp from the test executable (no longer needed)
and removes the SKIP_RETURN_CODE 77 — the test now runs and must pass.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: larsgeb

CMakeLists.txt

@@ -194,18 +194,15 @@ compile_metal_shader(
 # =============================================================================
 enable_testing()
 
-add_executable(test_01_adder tests/test_01_adder.cpp 01-MetalAdder/MetalAdder.cpp)
+add_executable(test_01_adder tests/test_01_adder.cpp)
 configure_metal_target(test_01_adder)
-target_include_directories(test_01_adder PRIVATE "${CMAKE_SOURCE_DIR}/01-MetalAdder")
 add_dependencies(test_01_adder metallib_01)
 set_target_properties(test_01_adder PROPERTIES
     RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/01-MetalAdder"
 )
 add_test(NAME test_01_adder COMMAND test_01_adder
     WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/01-MetalAdder"
 )
-# newDefaultLibrary() doesn't work on the CI paravirtual GPU; skip gracefully.
-set_tests_properties(test_01_adder PROPERTIES SKIP_RETURN_CODE 77)
 
 add_executable(test_02_1d_ops
     tests/test_02_1d_ops.cpp

tests/test_01_adder.cpp

@@ -1,11 +1,10 @@
-// Test: Verify GPU array addition matches CPU computation
-// Use a small array so the test runs on both real Apple Silicon and the
-// CI paravirtual GPU (which can't handle the 108 M element sample size).
-#define METAL_ADDER_ARRAY_LENGTH 10000
+// Verify the add_arrays GPU kernel from 01-MetalAdder.
+// Loads default.metallib by explicit path so this test works on both real
+// Apple Silicon and the CI paravirtual GPU, which rejects newDefaultLibrary()
+// (that API searches for an app bundle and silently fails on the VM).
 
-#include <iostream>
 #include <cstdlib>
-#include <cmath>
+#include <iostream>
 
 #define NS_PRIVATE_IMPLEMENTATION
 #define CA_PRIVATE_IMPLEMENTATION
@@ -14,7 +13,7 @@
 #include "Metal/Metal.hpp"
 #include "QuartzCore/QuartzCore.hpp"
 
-#include "MetalAdder.hpp"
+static const unsigned int kN = 10000;
 
 int main()
 {
@@ -24,31 +23,74 @@ int main()
         std::cerr << "FAIL: No Metal device found." << std::endl;
         return 1;
     }
-    std::string deviceName = device->name()->utf8String();
-    std::cout << "Running on " << deviceName << std::endl;
+    std::cout << "Running on " << device->name()->utf8String() << std::endl;
+
+    NS::Error *error = nullptr;
 
-    // MetalAdder uses newDefaultLibrary() which the Apple Paravirtual device
-    // cannot load correctly — results are silently all-zero regardless of size.
-    // Tests 02 and 03 load their metallib explicitly and run fine on the VM.
-    if (deviceName.find("Paravirtual") != std::string::npos)
+    // Load by explicit path — works on both real and paravirtual GPUs.
+    auto libPath = NS::String::string("default.metallib", NS::ASCIIStringEncoding);
+    MTL::Library *lib = device->newLibrary(libPath, &error);
+    if (!lib)
     {
-        std::cout << "SKIP: newDefaultLibrary() not supported on Paravirtual device." << std::endl;
+        std::cerr << "FAIL: Could not load default.metallib: "
+                  << (error ? error->description()->utf8String() : "unknown") << std::endl;
         device->release();
-        return 77; // CTest SKIP_RETURN_CODE
+        return 1;
     }
 
-    MetalAdder *adder = new MetalAdder(device);
+    auto fnName = NS::String::string("add_arrays", NS::ASCIIStringEncoding);
+    MTL::Function *fn = lib->newFunction(fnName);
+    lib->release();
+    if (!fn)
+    {
+        std::cerr << "FAIL: add_arrays not found in default.metallib" << std::endl;
+        device->release();
+        return 1;
+    }
 
-    // Run GPU addition
-    adder->sendComputeCommand();
+    MTL::ComputePipelineState *pso = device->newComputePipelineState(fn, &error);
+    fn->release();
+    if (!pso)
+    {
+        std::cerr << "FAIL: Could not create pipeline state" << std::endl;
+        device->release();
+        return 1;
+    }
+
+    MTL::CommandQueue *queue = device->newCommandQueue();
+
+    // Allocate shared-memory buffers and fill inputs with random data.
+    size_t nbytes = kN * sizeof(float);
+    MTL::Buffer *bufA      = device->newBuffer(nbytes, MTL::ResourceStorageModeShared);
+    MTL::Buffer *bufB      = device->newBuffer(nbytes, MTL::ResourceStorageModeShared);
+    MTL::Buffer *bufResult = device->newBuffer(nbytes, MTL::ResourceStorageModeShared);
+
+    float *a = (float *)bufA->contents();
+    float *b = (float *)bufB->contents();
+    for (unsigned int i = 0; i < kN; i++)
+    {
+        a[i] = (float)rand() / RAND_MAX;
+        b[i] = (float)rand() / RAND_MAX;
+    }
 
-    // Verify against CPU
-    float *a = (float *)adder->_mBufferA->contents();
-    float *b = (float *)adder->_mBufferB->contents();
-    float *result = (float *)adder->_mBufferResult->contents();
+    // Dispatch the kernel.
+    auto cmdBuf = queue->commandBuffer();
+    auto enc    = cmdBuf->computeCommandEncoder();
+    enc->setComputePipelineState(pso);
+    enc->setBuffer(bufA,      0, 0);
+    enc->setBuffer(bufB,      0, 1);
+    enc->setBuffer(bufResult, 0, 2);
+    NS::UInteger tgSize = pso->maxTotalThreadsPerThreadgroup();
+    if (tgSize > kN) tgSize = kN;
+    enc->dispatchThreads(MTL::Size::Make(kN, 1, 1), MTL::Size::Make(tgSize, 1, 1));
+    enc->endEncoding();
+    cmdBuf->commit();
+    cmdBuf->waitUntilCompleted();
 
+    // Verify against CPU reference.
+    float *result = (float *)bufResult->contents();
     int errors = 0;
-    for (unsigned long i = 0; i < arrayLength; i++)
+    for (unsigned int i = 0; i < kN; i++)
     {
         if (result[i] != (a[i] + b[i]))
         {
@@ -59,14 +101,18 @@ int main()
         }
     }
 
-    delete adder;
+    pso->release();
+    queue->release();
+    bufA->release();
+    bufB->release();
+    bufResult->release();
     device->release();
 
     if (errors > 0)
     {
-        std::cerr << "FAIL: " << errors << " mismatches out of " << arrayLength << std::endl;
+        std::cerr << "FAIL: " << errors << " mismatches out of " << kN << std::endl;
         return 1;
     }
-    std::cout << "PASS: GPU addition matches CPU (" << arrayLength << " elements)" << std::endl;
+    std::cout << "PASS: GPU addition matches CPU (" << kN << " elements)" << std::endl;
     return 0;
 }