我正在尝试使用 Alea 来加速我正在开发的程序，但我需要一些帮助。
我需要做的是大量的 bitcount 和 bitwise 操作，其中的值存储在两个数组中。
对于我的第一个数组的每个元素，我必须对第二个数组的每个元素进行按位 & 运算，然后计算 & 结果设置为 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 倍，至少在我的 PC 上是这样。非常感谢 Michael Randall 为我指明了正确的方向。
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;
}
}
}
最佳答案
更新
似乎固定不适用于 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)
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 代码的相关性。但是，您可以通过使用
GCHandle.Alloc() 和 GCHandleType.Pinned 标志将数组固定在内存中并使用直接指针访问(如果您可以运行 unsafe 代码)来补充您的 Parallel 例程并可能加快速度示例
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;
}
其他资源
GCHandle.Alloc Method (Object)
GCHandleType Enumeration
Unsafe Code and Pointers (C# Programming Guide)
现在是这样的:
一些示例和信息在 3.0.4 版中已更改或移动。