fix(ci): resolve test failures on GPU-less CI runners and add DGX Spark builds

- What: Marked all 3 GPU integration tests with #[ignore = "requires NVIDIA
  GPU with NVML drivers"] so they are skipped on CI runners without GPUs.
  Run locally with: cargo test -- --ignored
- What: Updated ci.yml to use standard cargo test (ignored tests auto-skipped).
  Added clarifying comment about GPU test exclusion strategy.
- What: Updated release.yml with explicit DGX Spark labels for aarch64 targets:
  "Linux ARM64 / DGX Spark (glibc)" and "Linux ARM64 / DGX Spark (static)".
- What: Fixed release artifact handling: consolidated tarball collection with
  find, moved SHA256SUMS.txt generation to a flat release/ directory, and
  simplified the release upload glob.
- What: Added Swatinem/rust-cache with per-target cache keys in release builds.
- What: Removed --locked flag from build commands (no Cargo.lock committed).
- Why: CI failed because gpu_integration tests (nvml_initializes_successfully,
  gpu_collector_returns_valid_stats, gpu_process_collector_initializes) require
  NVIDIA GPU hardware not available on GitHub Actions ubuntu-latest runners.
- Why: DGX Spark uses NVIDIA Grace CPU (aarch64), so ARM64 builds are critical.

Tests: cargo test --workspace --all-features (9 passed, 3 ignored, 0 failed).
Tests: cargo test --test gpu_integration -- --ignored (3 passed locally with GPU).

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: DennySORA

.github/workflows/ci.yml

@@ -42,25 +42,19 @@ jobs:
       - run: cargo clippy --workspace --all-targets --all-features -- -D warnings
 
   test:
-    name: Test (${{ matrix.os }})
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest]
+    name: Test
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@v2
+      # Run all tests EXCEPT GPU integration tests (no NVIDIA GPU on CI runners).
+      # GPU tests are marked #[ignore] and can be run locally with: cargo test -- --ignored
       - run: cargo test --workspace --all-features
 
   build:
-    name: Build (${{ matrix.os }})
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest]
+    name: Build
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable

.github/workflows/release.yml

@@ -19,22 +19,25 @@ jobs:
       fail-fast: false
       matrix:
         include:
+          # ── x86_64 Linux (DGX A100 / H100 / B200) ──
           - target: x86_64-unknown-linux-gnu
             os: ubuntu-latest
-            archive: tar.gz
             use_cross: false
+            label: "Linux x86_64 (glibc)"
           - target: x86_64-unknown-linux-musl
             os: ubuntu-latest
-            archive: tar.gz
             use_cross: true
+            label: "Linux x86_64 (static)"
+
+          # ── aarch64 Linux (DGX Spark — NVIDIA Grace ARM CPU) ──
           - target: aarch64-unknown-linux-gnu
             os: ubuntu-latest
-            archive: tar.gz
             use_cross: true
+            label: "Linux ARM64 / DGX Spark (glibc)"
           - target: aarch64-unknown-linux-musl
             os: ubuntu-latest
-            archive: tar.gz
             use_cross: true
+            label: "Linux ARM64 / DGX Spark (static)"
 
     steps:
       - uses: actions/checkout@v4
@@ -43,20 +46,23 @@ jobs:
         with:
           targets: ${{ matrix.target }}
 
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: ${{ matrix.target }}
+
       - name: Install cross
         if: matrix.use_cross
         run: cargo install cross --git https://github.com/cross-rs/cross
 
       - name: Build (native)
-        if: "!matrix.use_cross"
-        run: cargo build --release --locked --target ${{ matrix.target }}
+        if: ${{ !matrix.use_cross }}
+        run: cargo build --release --target ${{ matrix.target }}
 
       - name: Build (cross)
-        if: matrix.use_cross
-        run: cross build --release --locked --target ${{ matrix.target }}
+        if: ${{ matrix.use_cross }}
+        run: cross build --release --target ${{ matrix.target }}
 
-      - name: Package (tar.gz)
-        if: matrix.archive == 'tar.gz'
+      - name: Package
         run: |
           cd target/${{ matrix.target }}/release
           tar czvf ../../../dgxtop-${{ matrix.target }}.tar.gz dgxtop
@@ -66,7 +72,7 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: dgxtop-${{ matrix.target }}
-          path: dgxtop-${{ matrix.target }}.${{ matrix.archive }}
+          path: dgxtop-${{ matrix.target }}.tar.gz
 
   release:
     name: Create Release
@@ -75,25 +81,23 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Download artifacts
+      - name: Download all artifacts
         uses: actions/download-artifact@v4
         with:
           path: artifacts
 
-      - name: Generate checksums
+      - name: Prepare release assets
         run: |
-          cd artifacts
-          for dir in dgxtop-*/; do
-            for file in "$dir"*; do
-              sha256sum "$file" >> ../checksums.sha256
-            done
-          done
-          cd ..
-          mv checksums.sha256 artifacts/
-
-      - name: Create release
+          mkdir -p release
+          # Move all tarballs to release/
+          find artifacts -name "*.tar.gz" -exec mv {} release/ \;
+          # Generate SHA256 checksums
+          cd release
+          sha256sum *.tar.gz > SHA256SUMS.txt
+          cat SHA256SUMS.txt
+
+      - name: Create GitHub Release
         uses: softprops/action-gh-release@v2
         with:
           generate_release_notes: true
-          files: |
-            artifacts/**/*
+          files: release/*

tests/gpu_integration.rs

@@ -3,6 +3,7 @@ use dgxtop::collectors::gpu::{GpuCollector, init_nvml};
 use dgxtop::collectors::gpu_process::GpuProcessCollector;
 
 #[test]
+#[ignore = "requires NVIDIA GPU with NVML drivers"]
 fn nvml_initializes_successfully() {
     let nvml = init_nvml();
     assert!(nvml.is_ok(), "NVML init failed: {:?}", nvml.err());
@@ -17,6 +18,7 @@ fn nvml_initializes_successfully() {
 }
 
 #[test]
+#[ignore = "requires NVIDIA GPU with NVML drivers"]
 fn gpu_collector_returns_valid_stats() {
     let mut collector = GpuCollector::try_new().expect("GpuCollector init failed");
     assert!(collector.is_available());
@@ -45,6 +47,7 @@ fn gpu_collector_returns_valid_stats() {
 }
 
 #[test]
+#[ignore = "requires NVIDIA GPU with NVML drivers"]
 fn gpu_process_collector_initializes() {
     let gpu_collector = GpuCollector::try_new().expect("GpuCollector init failed");
     let mut proc_collector =