更新

Question

我试图使用Alea来加速我正在开展的计划，但我需要一些帮助。

我需要做的是进行大量的bitcount和按位操作，并将值存储在两个数组中。

对于我的第一个数组的每个元素，我必须做一个按位＆amp;使用我的第二个数组的每个元素进行操作，然后计算设置为＆amp;的第1个位。结果

如果结果大于/等于某个值，我需要退出内部for并转到第一个数组的下一个元素。

第一个数组通常是一个大数组，有数百万个元素，第二个数组通常少于200.000个元素。

尝试并行执行所有这些操作，这是我的代码：

[GpuManaged]
private long[] Check(long[] arr1, long[] arr2, int limit)
{
    Gpu.FreeAllImplicitMemory(true);
    var gpu = Gpu.Default;
    long[] result = new long[arr1.Length];
    gpu.For(0, arr1.Length, i =>
    {
        bool found = false;
        long b = arr1[i];
        for (int i2 = 0; i2 < arr2.Length; i2++)
        {
            if (LibDevice.__nv_popcll(b & arr2[i2]) >= limit)
            {
                found = true;
                break;
            }
        }
        if (!found)
        {
            result[i] = b;
        }
    });
    return result;
}

这可以按预期工作，但比我在四核CPU上并行运行的版本快一点。

我在这里肯定遗漏了一些东西，这是我第一次尝试编写GPU代码。

顺便说一下，我的NVIDIA是GeForce GT 740M。

修改

以下代码比前一代码快2倍，至少在我的电脑上。非常感谢迈克尔·兰德尔指出我正确的方向。

private static int[] CheckWithKernel(Gpu gpu, int[] arr1, int[] arr2, int limit)
{
    var lp = new LaunchParam(16, 256);
    var result = new int[arr1.Length];
    try
    {
        using (var dArr1 = gpu.AllocateDevice(arr1))
        using (var dArr2 = gpu.AllocateDevice(arr2))
        using (var dResult = gpu.AllocateDevice<int>(arr1.Length))
        {
            gpu.Launch(Kernel, lp, arr1.Length, arr2.Length, dArr1.Ptr, dArr2.Ptr, dResult.Ptr, limit);
            Gpu.Copy(dResult, result);
            return result;
        }
    }
    finally
    {
        Gpu.Free(arr1);
        Gpu.Free(arr2);
        Gpu.Free(result);
    }
}

private static void Kernel(int a1, int a2, deviceptr<int> arr1, deviceptr<int> arr2, deviceptr<int> arr3, int limit)
{
    var iinit = blockIdx.x * blockDim.x + threadIdx.x;
    var istep = gridDim.x * blockDim.x;
    for (var i = iinit; i < a1; i += istep)
    {
        bool found = false;
        int b = arr1[i];
        for (var j = 0; j < a2; j++)
        {
            if (LibDevice.__nv_popcll(b & arr2[j]) >= limit)
            {
                found = true;
                break;
            }
        }
        if (!found)
        {
            arr3[i] = b;
        }
    }
}

Answer 1

更新

似乎固定不适用于GCHandle.Alloc（）

然而，这个答案的重点是，您可以通过直接内存访问获得更大的性能提升。

http://www.aleagpu.com/release/3_0_3/doc/advanced_features_csharp.html

直接使用设备内存

设备内存提供了更大的灵活性，因为它也允许所有一种指针算术。设备内存分配

Memory<T> Gpu.AllocateDevice<T>(int length)
Memory<T> Gpu.AllocateDevice<T>(T[] array)

第一个重载会为指定的内容创建一个设备内存对象在所选GPU上键入T和长度。第二个分配存储在GPU上并将.NET阵列复制到其中。两者都归来了 Memory<T>对象，它实现IDisposable，因此可以支持使用语法，确保一旦处理正确处理 Memory<T>对象超出范围。 A Memory<T>对象具有属性确定长度，GPU或它所在的设备。该 Memory<T>.Ptr属性返回deviceptr<T>，可以在其中使用 GPU代码访问实际数据或执行指针算术。以下示例说明了设备的简单用例指针。内核仅对部分数据进行操作，由a定义偏移量。

using (var dArg1 = gpu.AllocateDevice(arg1))
using (var dArg2 = gpu.AllocateDevice(arg2))
using (var dOutput = gpu.AllocateDevice<int>(Length/2))
{           
    // pointer arithmetics to access subset of data
    gpu.Launch(Kernel, lp, dOutput.Length, dOutput.Ptr, dArg1.Ptr + Length/2, dArg2.Ptr + Length / 2);

    var result = dOutput.ToArray();

    var expected = arg1.Skip(Length/2).Zip(arg2.Skip(Length/2), (x, y) => x + y);

    Assert.That(result, Is.EqualTo(expected));
}

原始答案

忽略正在进行的逻辑，或者它与GPU代码的相关性。但是，您可以赞美您的 Parallel 例程，并通过将 Arrays 固定在内存中GCHandle.Alloc()和{{}来加快速度。 3}}标记并使用直接指针访问（如果您可以运行GCHandleType.Pinned代码）

备注



您可以通过固定内存来获得成功，但是对于大型阵列，您可以通过直接访问实现很多性能*



您必须在Build Properties *

中标记您的程序集不安全

这显然是未经测试的，只是一个例子*



您可以使用固定，但Parallel Lambda使其更加小巧



示例

private unsafe long[] Check(long[] arr1, long[] arr2, int limit) { Gpu.FreeAllImplicitMemory(true); var gpu = Gpu.Default; var result = new long[arr1.Length]; // Create some pinned memory var resultHandle = GCHandle.Alloc(result, GCHandleType.Pinned); var arr2Handle = GCHandle.Alloc(result, GCHandleType.Pinned); var arr1Handle = GCHandle.Alloc(result, GCHandleType.Pinned); // Get the addresses var resultPtr = (int*)resultHandle.AddrOfPinnedObject().ToPointer(); var arr2Ptr = (int*)arr2Handle.AddrOfPinnedObject().ToPointer(); var arr1Ptr = (int*)arr2Handle.AddrOfPinnedObject().ToPointer(); // I hate nasty lambda statements. I always find local methods easier to read. void Workload(int i) { var found = false; var b = *(arr1Ptr + i); for (var j = 0; j < arr2.Length; j++) { if (LibDevice.__nv_popcll(b & *(arr2Ptr + j)) >= limit) { found = true; break; } } if (!found) { *(resultPtr + i) = b; } } try { gpu.For(0, arr1.Length, i => Workload(i)); } finally { // Make sure we free resources arr1Handle.Free(); arr2Handle.Free(); resultHandle.Free(); } return result; }

其他资源

unsafe


保护对象免受垃圾回收的新GCHandle。这个   GCHandle必须在不再需要时免费发布。

GCHandle.Alloc Method (Object)


固定：此句柄类型与“正常”类似，但允许使用固定对象的地址。这可以防止垃圾   收集器移动物体，从而破坏效率   垃圾收集器。使用Free方法释放已分配的   尽快处理。

GCHandleType Enumeration


在公共语言运行库（CLR）中，不安全代码被称为   无法验证的代码。 C＃中的不安全代码不一定是危险的;它   只是CLR无法验证其安全性的代码。 CLR会   因此，只有在完全信任的情况下才执行不安全的代码   部件。如果您使用不安全的代码，您有责任确保   您的代码不会引入安全风险或指针错误。

注意，此后有了更新，这个：


Unsafe Code and Pointers (C# Programming Guide)

现在是这样的：


http://www.aleagpu.com/release/3_0_3/doc/advanced_features_csharp.html

部分示例和信息已在3.0.4版本中更改或移动。

使用Alea GPU加速嵌套循环和按位操作

1 个答案:

更新

原始答案

其他资源