Блог

Я изучаю вычислительные шейдеры в DirectX и OpenGL

и я написал некоторый код для тестирования вычислительного шейдера и проверил время выполнения.

но была некоторая разница между временем выполнения DirectX и Opengl

и изображение выше показывает, насколько оно отличается (слева-DirectX, справа-Opengl, время-наносекунды).

даже вычислительный шейдер DirectX работает медленнее, чем процессор

вот мой код, который вычисляет сумму обоих векторов: один для вычислительного шейдера и один для процессора

         std::vector<Data> dataA(32);
        std::vector<Data> dataB(32);

        for (int i = 0; i < 32;   i)
        {
            dataA[i].v1 = glm::vec3(i, i, i);
            dataA[i].v2 = glm::vec2(i, 0);

            dataB[i].v1 = glm::vec3(-i, i, 0.0f);
            dataB[i].v2 = glm::vec2(0, -i);
        }

        InputBufferA = ShaderBuffer::Create(sizeof(Data), 32, BufferType::Read, dataA.data());
        InputBufferB = ShaderBuffer::Create(sizeof(Data), 32, BufferType::Read, dataB.data());
        OutputBufferA =ShaderBuffer::Create(sizeof(Data), 32, BufferType::ReadWrite);

        computeShader->Bind();
        InputBufferA->Bind(0, ShaderType::CS);
        InputBufferB->Bind(1, ShaderType::CS);
        OutputBufferA->Bind(0,ShaderType::CS);

        // Check The Compute Shader Calculation time
        std::chrono::system_clock::time_point time1 = std::chrono::system_clock::now();
        RenderCommand::DispatchCompute(1, 1, 1);
        std::chrono::system_clock::time_point time2 = std::chrono::system_clock::now();
        std::chrono::nanoseconds t =time2- time1;
        QCAT_CORE_INFO("Compute Shader time : {0}", t.count());
        
        // Check The Cpu Calculation time
        std::vector<Data> dataC(32);
        time1 = std::chrono::system_clock::now();
        for (int i = 0; i < 32;   i)
        {
            dataC[i].v1 = (dataA[i].v1   dataB[i].v1);
            dataC[i].v2 = (dataA[i].v2   dataB[i].v2);
        }
        time2 = std::chrono::system_clock::now();
        t = time2 - time1;
        QCAT_CORE_INFO("CPU time : {0}", t.count() );
 

а вот код glsl

 #version 450 core
struct Data
{
    vec3 a;
    vec2 b;
};
layout(std430,binding =0) readonly buffer Data1
{
    Data input1[];
};

layout(std430,binding =1) readonly buffer Data2
{
    Data input2[];
};

layout(std430,binding =2) writeonly buffer Data3
{
    Data outputData[];
};

layout (local_size_x = 32, local_size_y = 1, local_size_z = 1) in;

void main()
{
  uint index = gl_GlobalInvocationID.x;

  outputData[index].a = input1[index].a   input2[index].a;
  outputData[index].b = input1[index].b   input2[index].b;
}
 

and hlsl code

 
struct Data
{
    float3 v1;
    float2 v2;
};
StructuredBuffer<Data> gInputA : register(t0);
StructuredBuffer<Data> gInputB : register(t1);
RWStructuredBuffer<Data> gOutput : register(u0);

[numthreads(32,1,1)]
void CSMain(int3  dtid : SV_DispatchThreadID)
{
    gOutput[dtid.x].v1 = gInputA[dtid.x].v1   gInputB[dtid.x].v1;
    gOutput[dtid.x].v2 = gInputA[dtid.x].v2   gInputB[dtid.x].v2;
}
 

довольно простой код, не так ли?

но время работы Opengl в 10 раз лучше, чем у DirectX

я не понимаю, почему это произошло, есть ли что-то замедляющее производительность??

это код, который при создании RWStructuredBuffer отличается только от StructuredBuffer: BindFlags = D3D11_BIND_SHADER_RESOURCE

         desc.Usage = D3D11_USAGE_DEFAULT;
        desc.ByteWidth = size * count;
        desc.BindFlags = D3D11_BIND_UNORDERED_ACCESS;
        desc.CPUAccessFlags = 0;
        desc.StructureByteStride = size;
        desc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;

        D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc;
        uavDesc.Format = DXGI_FORMAT_UNKNOWN;
        uavDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
        uavDesc.Buffer.FirstElement = 0;
        uavDesc.Buffer.Flags = 0;
        uavDesc.Buffer.NumElements = count;
 

и в opengl я создаю SSBO таким образом

     glGenBuffers(1, amp;m_renderID);
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_renderID);
    glBufferData(GL_SHADER_STORAGE_BUFFER, int(size * count), pData, GL_STATIC_DRAW);
 

это весь код для выполнения вычислительного шейдера в обоих API

и каждый результат показывает мне, что opengl лучше, чем directx

Какие свойства делают это различие?

находится в буфере или шейдерном коде?