I have the following CRC calculation that is executed 12 times in parallel on different data sources.

我有以下CRC计算，在不同的数据源上并行执行12次。

Can I offload this to the GPU once the CPU thread count is exhausted, or is the GPU not suited for such tasks and it does not make sense to do such a calculation on the GPU ?

一旦CPU线程数用完，或者GPU不适合执行此类任务而在GPU上执行这样的计算没有意义，我是否可以将其卸载到GPU？

If this is the wrong place to ask this question, could you please suggest where it should be asked.

如果这不是问这个问题的地方，你能建议应该在哪里问吗？

private static readonly byte[] _crcLookup = new byte[1024];

public static uint CalculateCRC(byte[] data, uint lower, uint upper)
{
    uint offset = 0;
    uint addr = 0;

    var segment = data;

    uint crc = uint.MaxValue;
    addr = lower;
    while (addr <= upper)
    {
        crc = crc >> 8 ^ _crcLookup [(byte)(data[addr] ^ crc)];
        addr++;
    }

    crc = ~crc;
    return crc;
}

Parallel implementation

并行实现

var dataSegments = new ConcurrentBag<(byte[] data, uint lower, uint upper)>();

Parallel.ForEach(dataSegments, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, segment =>
{
    uint result = CalculateCRC(segment.data, segment.lower, segment.upper);
    // Do something with the result...
});

Can I offload this to the GPU once the CPU thread count is exhausted, or is the GPU not suited for such tasks and it does not make sense to do such a calculation on the GPU ?

Technically yes, but only with great difficulty. You cannot run arbitrary c# code on a GPU, so you would likely need to write the GPU code in some other language, with all the complexity that entails.

从技术上讲，是的，但难度很大。您不能在GPU上运行任意的C#代码，因此您可能需要用其他语言编写GPU代码，而这会带来所有的复杂性。

But chances are you will only see a performance reduction. CRC calculations should be IO limited if the code is decently well optimized. So the extra overhead to transfer data to the GPU would very likely cost more than it could benefit. Also, GPUs are designed for massive parallelism. In the while (addr <= upper)-loop you have a dependency between iterations, so it could not directly be parallelized. It might be possible to do some hierarchical version of CRC, but even then, the overhead would be prohibitive.

但您可能只会看到性能下降。如果代码进行了良好的优化，则CRC计算应该是IO受限的。因此，将数据传输到GPU的额外开销很可能会付出比收益更高的成本。此外，GPU专为大规模并行而设计。在WHILE(addr<=up)循环中，迭代之间存在依赖关系，因此不能直接并行化。做一些分级版本的CRC是可能的，但即使那样，开销也是令人望而却步的。

Parallelizing on the 12 different data sources should be done on different threads, not on the GPU. A CPU core is much faster than a "GPU core". You just have single/double digit CPU cores, but possibly thousands of GPU cores.

在12个不同数据源上的并行化应该在不同的线程上完成，而不是在GPU上。CPU核比“GPU核”快得多。你只有个位数或两位数的CPU核心，但可能有数千个GPU核心。

Here is the code:

以下是代码：

private static readonly byte[] _crcLookup = new byte[1024];

public static uint CalculateCRC(byte[] data, uint lower, uint upper)
{
    uint offset = 0;
    uint addr = 0;

    var segment = data;

    uint crc = uint.MaxValue;
    addr = lower;
    while (addr <= upper)
    {
        crc = crc >> 8 ^ _crcLookup [(byte)(data[addr] ^ crc)];
        addr++;
    }

    crc = ~crc;
    return crc;
}

var dataSegments = new ConcurrentBag<(byte[] data, uint lower, uint upper)>();

Parallel.ForEach(dataSegments, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, segment =>
{
    uint result = CalculateCRC(segment.data, segment.lower, segment.upper);
    // Do something with the result...
});

Using a GPU for non-graphics operations in C# like a CRC calculation might not be straightforward. While there are libraries like CUDA.NET that allow for GPU programming in C#, it's important to note that not all operations benefit from GPU parallelization. In some cases, the overhead of transferring data between CPU and GPU memory can outweigh the benefits gained from parallelization.

将GPU用于C#中的非图形操作，如CRC计算，可能并不简单。虽然有像CUDA.NET这样的库允许用C#进行GPU编程，但重要的是要注意，并不是所有的操作都能从GPU并行化中受益。在某些情况下，在CPU和GPU内存之间传输数据的开销可能会超过并行化带来的好处。