adds dockerfile and updated cicd to use it and updated cli usage with benchmark mode

Author: skyler-ruiter

.github/workflows/build-check.yml

@@ -12,48 +12,35 @@ concurrency:
 
 jobs:
   # ── Header / compilation smoke test (no GPU required) ──────────────────────
-  # This job uses a free GitHub-hosted runner. It installs CUDA stubs (headers
-  # + import libraries only — no driver, no device) so we can compile all
-  # library and CLI targets and catch API breakage, missing includes, and
-  # CMake errors without needing a real GPU.
-  #
-  # Tests are NOT run here (they require a real CUDA device). Full GPU testing
-  # happens in ci.yml on the self-hosted runner.
+  # This job uses a free GitHub-hosted runner with an official NVIDIA Docker container.
+  # The container provides the CUDA compiler (nvcc) and headers, allowing us to
+  # compile all library and CLI targets to catch API breakage and CMake errors
+  # without needing a real GPU.
   compile-only:
-    name: Compile (CPU-only, stub CUDA)
+    name: Compile (CPU-only)
     runs-on: ubuntu-24.04
+    container: nvcr.io/nvidia/cuda:12.6.0-devel-ubuntu24.04
 
     steps:
       - name: Checkout
         uses: actions/checkout@v4
         with:
           submodules: recursive
 
-      - name: Install CUDA stub toolkit
+      - name: Install CMake
         run: |
-          # Install CUDA keyring and then only the headers + stub libs.
-          # This lets nvcc compile host-side code without a GPU.
-          wget -qO /tmp/cuda-keyring.deb \
-            https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
-          sudo dpkg -i /tmp/cuda-keyring.deb
-          sudo apt-get update -qq
-          # cuda-cudart-dev  — headers for cudart
-          # cuda-nvcc         — the nvcc compiler
-          # libcuda1-stub     — linker stubs (no driver needed)
-          sudo apt-get install -y --no-install-recommends \
-            cuda-cudart-dev-12-6 \
-            cuda-nvcc-12-6 \
-            libcuda1-560-server || true
-          echo "/usr/local/cuda/bin" >> "$GITHUB_PATH"
+          apt-get update -qq
+          apt-get install -y --no-install-recommends cmake ninja-build git
 
       - name: Configure
         run: |
           cmake -S . -B build/check \
+            -G Ninja \
             -DCMAKE_BUILD_TYPE=Release \
             -DBUILD_TESTING=OFF \
             -DBUILD_EXAMPLES=OFF \
             -DBUILD_PROFILING=OFF \
             -DCMAKE_CUDA_ARCHITECTURES=86
 
       - name: Build (library + CLI only)
-        run: cmake --build build/check --parallel --target fzgmod fzgmod-cli
+        run: cmake --build build/check --target fzgmod fzgmod-cli

Dockerfile

@@ -0,0 +1,24 @@
+# Base image: NVIDIA CUDA Toolkit (Development environment)
+# Using 12.6 to match the development version used for FZGPUModules
+FROM nvcr.io/nvidia/cuda:12.6.0-devel-ubuntu24.04
+
+# Prevent interactive prompts during apt installations
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Install essential build tools and dependencies
+RUN apt-get update -qq && apt-get install -y --no-install-recommends \
+    cmake \
+    ninja-build \
+    git \
+    g++ \
+    libasan8 \
+    libubsan1 \
+    curl \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set up a working directory
+WORKDIR /workspace
+
+# By default, open a bash shell
+CMD ["/bin/bash"]

src/utils/cli/cli.cpp

@@ -598,30 +598,43 @@ static int run_decompress(CliSettings s) {
     size_t output_size = 0;
 
     try {
+        std::vector<uint8_t> orig;
+        if (!s.original_path.empty()) {
+            orig = read_binary_file(s.original_path);
+        }
+
         const auto t0 = std::chrono::high_resolution_clock::now();
         Pipeline::decompressFromFile(s.input_path, &d_output, &output_size, 0);
         FZ_CUDA_CHECK(cudaDeviceSynchronize());
         const auto t1 = std::chrono::high_resolution_clock::now();
         double host_ms = std::chrono::duration<double, std::milli>(t1 - t0).count();
 
-        std::vector<uint8_t> host(output_size);
-        if (output_size > 0) {
-            FZ_CUDA_CHECK(cudaMemcpy(host.data(), d_output, output_size, cudaMemcpyDeviceToHost));
+        // Truncate to the original size if we have it (to remove chunk padding)
+        size_t usable_size = output_size;
+        if (!orig.empty() && orig.size() < output_size) {
+            usable_size = orig.size();
+        }
+
+        std::vector<uint8_t> host(usable_size);
+        if (usable_size > 0) {
+            FZ_CUDA_CHECK(cudaMemcpy(host.data(), d_output, usable_size, cudaMemcpyDeviceToHost));
         }
 
         if (!s.output_path.empty()) {
             write_binary_file(s.output_path, host.data(), host.size());
         }
 
         if (s.report || !s.original_path.empty()) {
-            double tput = static_cast<double>(output_size) / (host_ms * 1e-3) / 1e9;
+            double tput = static_cast<double>(usable_size) / (host_ms * 1e-3) / 1e9;
             std::cout << "\n[Decompress Report]\n"
-                      << "  Output size:     " << output_size << " bytes\n"
-                      << "  Time:            " << std::fixed << std::setprecision(3) << host_ms << " ms\n"
+                      << "  Output size:     " << usable_size << " bytes\n";
+            if (usable_size != output_size) {
+                std::cout << "  (Padded size:    " << output_size << " bytes, truncated to match original)\n";
+            }
+            std::cout << "  Time:            " << std::fixed << std::setprecision(3) << host_ms << " ms\n"
                       << "  Throughput:      " << std::setprecision(2) << tput << " GB/s\n";
 
-            if (!s.original_path.empty()) {
-                std::vector<uint8_t> orig = read_binary_file(s.original_path);
+            if (!orig.empty()) {
                 if (orig.size() != host.size()) {
                     std::cout << "  Compare error:   Size mismatch! Original=" << orig.size() 
                               << ", Reconstructed=" << host.size() << "\n";
@@ -683,6 +696,7 @@ static int run_benchmark(CliSettings s) {
         FZ_CUDA_CHECK(cudaDeviceSynchronize());
 
         TimingSummary compress_stats, decompress_stats;
+        std::vector<uint8_t> final_recon;
 
         for (int i = 0; i < s.benchmark_runs; ++i) {
             const auto t0 = std::chrono::high_resolution_clock::now();
@@ -704,6 +718,11 @@ static int run_benchmark(CliSettings s) {
             }
             decompress_stats.add(std::chrono::duration<double, std::milli>(t3 - t2).count(), pipeline->getLastPerfResult().dag_elapsed_ms);
 
+            if ((s.report || !s.original_path.empty()) && i == s.benchmark_runs - 1) {
+                final_recon.resize(recon_size);
+                FZ_CUDA_CHECK(cudaMemcpy(final_recon.data(), d_recon, recon_size, cudaMemcpyDeviceToHost));
+            }
+            
             if (!pipeline->isPoolManagedDecompOutput() && d_recon) {
                 FZ_CUDA_CHECK(cudaFree(d_recon));
             }
@@ -712,6 +731,37 @@ static int run_benchmark(CliSettings s) {
         print_summary("compress", compress_stats, payload_bytes);
         print_summary("decompress", decompress_stats, payload_bytes);
 
+        if (s.report || !s.original_path.empty()) {
+            double ratio = static_cast<double>(payload_bytes) / compressed_size;
+            std::cout << "\n[Quality Report]\n"
+                      << "  Input size:      " << payload_bytes << " bytes\n"
+                      << "  Compressed size: " << compressed_size << " bytes\n"
+                      << "  Ratio:           " << std::fixed << std::setprecision(2) << ratio << "x\n";
+            
+            std::vector<uint8_t> orig;
+            if (!s.original_path.empty()) {
+                orig = read_binary_file(s.original_path);
+            } else {
+                orig = input_bytes;
+            }
+            
+            if (!orig.empty() && orig.size() == final_recon.size()) {
+                Metrics m;
+                if (s.type == "f32") m = calc_metrics<float>(orig, final_recon);
+                else if (s.type == "f64") m = calc_metrics<double>(orig, final_recon);
+                else if (s.type == "i32") m = calc_metrics<int32_t>(orig, final_recon);
+                else if (s.type == "i64") m = calc_metrics<int64_t>(orig, final_recon);
+                
+                std::cout << "  Value Range:     [" << std::scientific << m.val_min << ", " << m.val_max << "] (Span: " << m.val_range << ")\n"
+                          << "  Max Abs Error:   " << std::scientific << m.max_err << "\n"
+                          << "  PSNR:            " << std::fixed << std::setprecision(2) << m.psnr << " dB\n"
+                          << "  NRMSE:           " << std::scientific << m.nrmse << "\n";
+            } else if (!orig.empty()) {
+                std::cout << "  Compare error:   Size mismatch! Original=" << orig.size() 
+                          << ", Reconstructed=" << final_recon.size() << "\n";
+            }
+        }
+        
     } catch (...) {
         if (d_input) FZ_CUDA_CHECK_WARN(cudaFree(d_input));
         throw;