ILGPU 고급 기능과 최적화

using ILGPU;
using ILGPU.Runtime;
using ILGPU.Runtime.Cuda;
using System;
using System.Diagnostics;

class Program
{
    static void Main()
    {
        // 컨텍스트 초기화
        using var context = Context.Create(builder => builder.Cuda().EnableAlgorithms());
        using var accelerator = context.CreateCudaAccelerator(0); // H100

        // 데이터 준비
        const int numRows = 1_000_000;
        const int numNonZeros = 10_000_000;
        float[] values = new float[numNonZeros];
        int[] colIndices = new int[numNonZeros];
        int[] rowPtr = new int[numRows + 1];
        float[] vector = new float[numRows];
        float[] result = new float[numRows];

        // 임의 데이터 초기화
        Random rand = new Random();
        int nnzIndex = 0;
        for (int row = 0; row < numRows; row++)
        {
            rowPtr[row] = nnzIndex;
            int numElements = rand.Next(5, 15);
            for (int i = 0; i < numElements && nnzIndex < numNonZeros; i++)
            {
                values[nnzIndex] = (float)rand.NextDouble();
                colIndices[nnzIndex] = rand.Next(0, numRows);
                nnzIndex++;
            }
        }
        rowPtr[numRows] = nnzIndex;
        for (int i = 0; i < numRows; i++)
            vector[i] = (float)rand.NextDouble();

        // 메모리 할당
        using var valuesBuffer = accelerator.Allocate1D<float>(numNonZeros);
        using var colIndicesBuffer = accelerator.Allocate1D<int>(numNonZeros);
        using var rowPtrBuffer = accelerator.Allocate1D<int>(numRows + 1);
        using var vectorBuffer = accelerator.Allocate1D<float>(numRows);
        using var resultBuffer = accelerator.Allocate1D<float>(numRows);

        // 비동기 스트림 생성
        using var stream = accelerator.CreateStream();

        // 데이터 전송 (비동기)
        var stopwatch = Stopwatch.StartNew();
        valuesBuffer.CopyFromCPUAsync(stream, values);
        colIndicesBuffer.CopyFromCPUAsync(stream, colIndices);
        rowPtrBuffer.CopyFromCPUAsync(stream, rowPtr);
        vectorBuffer.CopyFromCPUAsync(stream, vector);

        // 커널 정의
        var kernel = accelerator.LoadAutoGroupedStreamKernel<
            Index1D, ArrayView<float>, ArrayView<int>, ArrayView<int>, ArrayView<float>, ArrayView<float>>(
            SparseMatrixVectorKernel);

        // 커널 실행 (비동기)
        kernel(stream, numRows, valuesBuffer.View, colIndicesBuffer.View, rowPtrBuffer.View, vectorBuffer.View, resultBuffer.View);

        // 결과 다운로드 (비동기)
        resultBuffer.CopyToCPUAsync(stream, result);
        stream.Synchronize();
        stopwatch.Stop();
        Console.WriteLine($"Total Execution Time (with async): {stopwatch.ElapsedMilliseconds} ms");

        // 결과 검증 (샘플링)
        float expected = 0.0f;
        for (int i = rowPtr[0]; i < rowPtr[1]; i++)
            expected += values[i] * vector[colIndices[i]];
        Console.WriteLine($"Result[0]: {result[0]} (Expected: {expected})");
    }

    static void SparseMatrixVectorKernel(
        Index1D row,
        ArrayView<float> values,
        ArrayView<int> colIndices,
        ArrayView<int> rowPtr,
        ArrayView<float> vector,
        ArrayView<float> result)
    {
        if (row >= rowPtr.Length - 1) return;

        // 공유 메모리 할당 (최적화)
        var sharedValues = SharedMemory.Allocate<float>(256);
        var sharedColIndices = SharedMemory.Allocate<int>(256);
        int threadIdx = Group.IdxX;
        int blockSize = Group.DimX;

        float sum = 0.0f;
        int start = rowPtr[row];
        int end = rowPtr[row + 1];

        // 공유 메모리로 데이터 캐싱
        for (int i = start; i < end; i += blockSize)
        {
            int idx = i + threadIdx;
            if (idx < end)
            {
                sharedValues[threadIdx] = values[idx];
                sharedColIndices[threadIdx] = colIndices[idx];
            }
            Group.Barrier();

            for (int j = 0; j < blockSize && i + j < end; j++)
                sum += sharedValues[j] * vector[sharedColIndices[j]];
            Group.Barrier();
        }

        result[row] = sum;
    }
}

dotnet new console -n ILGPUSpMV
cd ILGPUSpMV
dotnet add package ILGPU
dotnet add package ILGPU.Algorithms
# 위 코드로 Program.cs 작성
dotnet run

Total Execution Time (with async): 15 ms
Result[0]: 1.23456 (Expected: 1.23456)