将内核链接在一起时值会随机变化

Question

我对整个 OpenCL 世界还很陌生，我创建了两个非常简单的内核，我试图将它们链接在一起，但我得到了相当虚假的结果。当单独运行时，它们会按预期工作，但当组合在一起时，我会看到 st运行ge 结果。

所以，每个内核单独看起来像这样

矢量 3 噪声

__kernel void addVector3Noise( __global struct State* states, __global float3* randomVector3Values){
    int stateNum = get_global_id(0);
    struct State state = states[stateNum];
    float3 randomVal = randomVector3Values[stateNum];
    struct State newState;
    newState.Vec3 = (float3)(state.Vec3.x + randomVal.x,state.Vec3.y + randomVal.y,state.Vec3.z + randomVal.z); 
    newState.Vec4 = state.Vec4;
    states[stateNum] = newState;
}

为了测试这个，所有的状态都有 Vec3 of [ 1.0f, 1.0f, 1.0f]，所有的运行dom 值都相同，所以我得到的输出是一个状态数组值 [2.0f, 2.0f, 2.0f] 正如我所期望的那样。

矢量 4 噪声

__kernel void addVector4Noise(__global struct State* states,
__global float3* randomVector4Values){
    int stateNum = get_global_id(0);
    struct State state = states[stateNum];
    float3 randomVal = randomVector4Values[stateNum];
    float4 newVector4 = randomQuaternionRotation(state.Vector4, randomVal);
    struct State newState;
    newState.Vector3 = state.Vector3;
    newState.Vector4= newVector4;
    states[stateNum] = newState;    
}

运行这个用非常简单的测试数据也给了我想要的东西。

现在将它们链接在一起时会出现问题。我按照 Vector 4 noise -> Vector 3 noise 的顺序调用它们。现在，当运行向量 4 噪声内核时，我看到向量 3 的值发生变化，并且这种变化似乎遵循某种模式。

因此，在 vector 4 内核运行之后，我希望每个状态下的 vector 3 与插入时相同。这意味着每个状态都会有一个 Vector [1.0f,1.0f,1.0f] 的 3 值以下是我实际看到的向量 3 的结果：

[1.0,1.0,1.0] 
[0.576367259,1.0,1.0]
[0.999199867,0.6448302,1.0]
[1.313311, 1.067663, 0.3307195]
[-0.08005857, 1.067663, 1.450237]
[1, 0.2340522, 1.136126]
[1, 1, 0.3025152]
[1, 1, 1]

并且该模式在所有 Vector 3 Values 中重复出现。请注意，在内核中，它只是将 Vector3 从先前状态复制到新状态。

这就是我使用 OpenCL.Net

将它们链接在一起的方式

    using (var env = "*".CreateCLEnvironment(DeviceType.Gpu))
    {           
        var source = LoadProgram("kernels.cl");
        var context = env.Context;

        ErrorCode errorCode;
        var program = Cl.CreateProgramWithSource(context, 1u, source, null, out errorCode);
        CheckSuccess(errorCode);
        errorCode = Cl.BuildProgram(program, (uint)env.Devices.Length, env.Devices, "-cl-opt-disable", null,
            IntPtr.Zero);
        if (errorCode != ErrorCode.Success)
        {
            var info = Cl.GetProgramBuildInfo(program, env.Devices[0], ProgramBuildInfo.Log, out errorCode).ToString();
            throw new Exception(info);
        }

        var kernels = Cl.CreateKernelsInProgram(program, out errorCode);
        CheckSuccess(errorCode);
        var Vector4NoiseKernel = kernels[0];
        var Vector3NoiseKernel = kernels[1];

        var rnd = new Random();
        var states = Enumerable.Range(1, ArrayLength)
            .Select(_ => new State
            {
                Vector3 = new Vector3(1, 1, 1),
                Vector4 = new Vector4(0.5f,0.5f,0.5f,0.5f)
            })
            .ToArray();
        var randomVector4Values = Enumerable.Range(1, ArrayLength)
            .Select(_ => new Vector3(2f, 2f, 2f))
            .ToArray();

        var randomVector3Values = Enumerable.Range(1, ArrayLength)
            .Select(_ => new Vector3(1f, 1f, 1f))
            .ToArray();

        var vector4StatesBuffer = context.CreateBuffer(states, MemFlags.ReadWrite);
        var randomVector4ValuesBuffer = context.CreateBuffer(randomVector4Values, MemFlags.ReadOnly);

        Event ev;

        Cl.SetKernelArg(vector4NoiseKernel, 0, vector4StatesBuffer);
        Cl.SetKernelArg(vector4NoiseKernel, 1, randomVector4ValuesBuffer);

        errorCode = Cl.EnqueueNDRangeKernel(env.CommandQueues[0], vector4NoiseKernel, 1, null
            , new[] { new IntPtr(ArrayLength) }, new[] { new IntPtr(1) }, 0u, null, out ev);
        errorCode.Check();

        env.CommandQueues[0].ReadFromBuffer(vector4StatesBuffer, states, waitFor: ev);

        var randomVector3ValuesBuffer = context.CreateBuffer(randomVector3Values, MemFlags.ReadOnly);
        var vector3StatesBuffer = context.CreateBuffer(states, MemFlags.ReadWrite);


        Cl.SetKernelArg(vector3NoiseKernel, 0, vector3StatesBuffer);
        Cl.SetKernelArg(vector3NoiseKernel, 1, randomVector3ValuesBuffer);

        errorCode = Cl.EnqueueNDRangeKernel(env.CommandQueues[0], vector3NoiseKernel, 1, null
            , new[] { new IntPtr(ArrayLength) }, new[] { new IntPtr(1) }, 0u, null, out ev);
        errorCode.Check();

        Cl.Finish(env.CommandQueues[0]).Check();
        env.CommandQueues[0].ReadFromBuffer(vector3StatesBuffer, states, waitFor: ev);
    }

请原谅这里的大量代码，但这是一个 playground 项目，我几乎只是吐出一些想法，所以整洁和优雅在这里不是问题:)

在此先感谢您提供的任何帮助。

编辑因此，今天早上我做的第一件事是将每个内核拉出到自己的 cl 文件中，并确保每个内核都有自己的状态版本，其中仅包含它所需的内容（分别为 Vector4 和 Vector3），以及一个新的 using 语句新分离出的 Vector3 噪声内核的所有 gubbins。令我高兴的是，Vector4 噪声内核完全符合我的预期，但是，当涉及到 Vector3 噪声时，出现了与之前类似的问题。仍然将 [1.0f,1.0f,1.0f] 作为运行dom 值和起始 Vector3 值传递，但它仍然没有产生我期望的输出。这次重复的模式是：

[2.0f,2.0f,2.0f]
[1.0f,2.0f,2.0f]
[2.0f,1.0f,2.0f]
[2.0f,2.0f,1.0f]
[2.0f,2.0f,2.0f]

Answer 1

在 OpenCL 中，3 分量向量类型占用的大小与 4 分量向量类型相同。例如，float3 被定义为 16 个字节，而不是 12 个字节。如果您在主机上使用的数据结构（在本例中为 Vector3 class）大小不同，您可能会运行出问题。

在您编辑的 post 中输出的模式是三个 2.0，然后是 1.0，这表明这可能是您所看到的行为的原因。

一种解决方案是在主机端使用 Vector4 代替 Vector3。

Answer 2

因此，在@jprice 指出 C# 和 OpenCL 类型之间的大小差异后，我设法通过在 C# 端明确声明我的结构的总大小符合预期来解决这个问题在 OpenCL 方面，所以现在我的结构看起来像这样。

[StructLayout(LayoutKind.Sequential, Size = 32)]
public struct State
{
    public Vector3 Vector3;
    public Vector4 Vector4;
}

由于 OpenCL 端的 float3 和 float4 都是 16 字节，因此将 32 字节分配给我的包含两者的结构导致了正确的行为。

将内核链接在一起时值会随机变化

Values Change Randomly When Chaining Together Kernels

c#

c++

gpgpu

opencl

opencl.net