Uploaded sanitized BC250/ROCm Repository.

2026-08-20 00:45:43 +02:00
parent 7d2184f1e8
commit d7d22e93b3
678 changed files with 65963 additions and 1 deletions
@@ -0,0 +1,151 @@
+/**
+ * HIP Vector Addition Test — AMD BC-250 ROCm Validation
+ * 
+ * Uses hipMallocManaged (unified memory) — REQUIRED for BC-250 which is an
+ * APU-like device with shared system memory (no dedicated VRAM).
+ * Standard hipMalloc + hipMemcpy will crash the system!
+ *
+ * Verifies GPU compute works end-to-end:
+ * 1. HIP runtime initializes & device query
+ * 2. Managed memory allocation (unified address space)
+ * 3. GPU kernel execution
+ * 4. Results are numerically correct
+ */
+#include <hip/hip_runtime.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <unistd.h>  // _exit() — bypasses C++ destructors
+
+#define HIP_CHECK(call) do { \
+    hipError_t err = call; \
+    if (err != hipSuccess) { \
+        fprintf(stderr, "HIP Error: %s at %s:%d\n", \
+                hipGetErrorString(err), __FILE__, __LINE__); \
+        fflush(stderr); \
+        exit(1); \
+    } \
+} while(0)
+
+__global__ void vectorAdd(const float* A, const float* B, float* C, int N) {
+    int i = blockDim.x * blockIdx.x + threadIdx.x;
+    if (i < N) {
+        C[i] = A[i] + B[i];
+    }
+}
+
+int main() {
+    printf("=== HIP Vector Addition Test (Managed Memory) ===\n");
+    printf("    Target: AMD BC-250 (gfx1013, APU shared memory)\n\n");
+    fflush(stdout);
+
+    // Step 1: Query device
+    printf("[1/4] Querying HIP device... ");
+    fflush(stdout);
+    int deviceCount = 0;
+    HIP_CHECK(hipGetDeviceCount(&deviceCount));
+
+    if (deviceCount == 0) {
+        printf("FAIL: No HIP devices found!\n");
+        return 1;
+    }
+
+    hipDeviceProp_t props;
+    HIP_CHECK(hipGetDeviceProperties(&props, 0));
+    printf("OK\n");
+    printf("       Device:          %s\n", props.name);
+    printf("       GCN Arch:        %s\n", props.gcnArchName);
+    printf("       Compute Units:   %d\n", props.multiProcessorCount);
+    printf("       Total Memory:    %zu MB (shared system RAM)\n", props.totalGlobalMem / (1024*1024));
+    printf("       Integrated:      %s\n", props.integrated ? "YES (APU)" : "NO");
+    printf("       Managed Memory:  %s\n", props.managedMemory ? "YES" : "NO");
+    fflush(stdout);
+
+    // Step 2: Allocate MANAGED memory (unified — safe for APU/shared memory)
+    const int N = 1 << 16; // 65536 elements
+    size_t bytes = N * sizeof(float);
+
+    printf("[2/4] Allocating managed memory (%.1f KB x3)... ", bytes/1024.0);
+    fflush(stdout);
+
+    float *A = nullptr, *B = nullptr, *C = nullptr;
+    HIP_CHECK(hipMallocManaged(&A, bytes));
+    HIP_CHECK(hipMallocManaged(&B, bytes));
+    HIP_CHECK(hipMallocManaged(&C, bytes));
+    printf("OK\n");
+    fflush(stdout);
+
+    // Initialize on host (managed memory is accessible from both CPU and GPU)
+    for (int i = 0; i < N; i++) {
+        A[i] = sinf(i) * sinf(i);
+        B[i] = cosf(i) * cosf(i);
+        C[i] = 0.0f;
+    }
+
+    // Step 3: Launch kernel
+    int threadsPerBlock = 256;
+    int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;
+
+    printf("[3/4] Launching kernel (%d blocks x %d threads)... ", blocksPerGrid, threadsPerBlock);
+    fflush(stdout);
+
+    hipEvent_t start, stop;
+    HIP_CHECK(hipEventCreate(&start));
+    HIP_CHECK(hipEventCreate(&stop));
+
+    HIP_CHECK(hipEventRecord(start));
+    hipLaunchKernelGGL(vectorAdd, dim3(blocksPerGrid), dim3(threadsPerBlock), 0, 0, A, B, C, N);
+    HIP_CHECK(hipGetLastError());
+    HIP_CHECK(hipEventRecord(stop));
+    HIP_CHECK(hipEventSynchronize(stop));
+
+    float ms = 0;
+    HIP_CHECK(hipEventElapsedTime(&ms, start, stop));
+    printf("OK (%.3f ms)\n", ms);
+    fflush(stdout);
+
+    // Step 4: Verify on host (managed memory — no memcpy needed!)
+    printf("[4/4] Verifying results... ");
+    fflush(stdout);
+
+    // Ensure GPU is done
+    HIP_CHECK(hipDeviceSynchronize());
+
+    int errors = 0;
+    for (int i = 0; i < N; i++) {
+        float expected = A[i] + B[i]; // sin²(x) + cos²(x) = 1.0
+        if (fabsf(C[i] - expected) > 1e-5) {
+            if (errors < 5) {
+                fprintf(stderr, "\n  Mismatch at [%d]: got %f, expected %f", 
+                        i, C[i], expected);
+            }
+            errors++;
+        }
+    }
+
+    if (errors == 0) {
+        printf("PASSED — all %d elements correct (sin²+cos²=1.0)\n", N);
+    } else {
+        printf("FAILED — %d/%d mismatches\n", errors, N);
+    }
+    fflush(stdout);
+
+    // CRITICAL BC-250 WORKAROUND:
+    // The HIP runtime's static destructors trigger KIQ queue teardown on the
+    // BC-250's shared-memory architecture, causing "timeout waiting for kiq fence"
+    // and a full system hang (no GPU reset possible on shared RAM APU).
+    //
+    // We MUST use _exit() to terminate immediately, bypassing:
+    //   - C++ static destructors (HIP runtime cleanup)
+    //   - atexit() handlers
+    //   - HIP's internal queue teardown via KIQ
+    //
+    // Memory is reclaimed by the OS. The GPU queues are released by KFD
+    // when the process file descriptors are closed, which is safer than
+    // the HIP runtime's explicit teardown path.
+
+    printf("\n=== ROCm HIP Compute: %s ===\n", errors == 0 ? "FULLY OPERATIONAL" : "FAILED");
+    fflush(stdout);
+    fflush(stderr);
+    _exit(errors > 0 ? 1 : 0);  // HARD EXIT — bypasses HIP destructors
+}