एचएलएसएल बफर स्ट्रिंग और थ्रेडिंग - यहां क्या हो रहा है?

Question

मैं डायरेक्ट कॉम्प्यूट टेक्नोलॉजीज में वास्तव में नया हूं, और एमएसडीएन वेबसाइट पर दस्तावेज से सीखने का प्रयास कर रहा हूं, जो कि कम से कम कहने के लिए घना है।

मैं एक मूल एचएलएसएल फ़ाइल बनाना चाहता हूं जो 4x4 मैट्रिक्स और 4xN मैट्रिक्स लेता है और गुणा परिणाम देता है। लेकिन कोड के साथ कुछ समय बिताने के बाद, मुझे कुछ अजीब चीजें मिली हैं जो मुझे समझ में नहीं आती हैं - मुख्य रूप से मैं कैसे थ्रेड्स को पास करता हूं, बफर और आउटपुट डेटा को संसाधित करता हूं।

इन सभी उदाहरणों के साथ, मैं दो 16 फ्लोट बफर में जाता हूं और 16 फ्लोट बफर निकालता हूं और फिर 4x1x1 समूह के साथ डिस्पैच करता हूं - मैं आपको कोड दिखा सकता हूं, लेकिन मैं ईमानदारी से नहीं जानता कि आपको मेरी मदद करने में क्या मदद मिलेगी । मुझे बताएं कि मेरे सी ++ कोड का एक अनुभाग है जिसे आप देखना चाहते हैं।

निम्न कोड के साथ

:

StructuredBuffer<float4x4> base_matrix  : register(t0); // byteWidth = 64 
StructuredBuffer<float4> extended_matrix : register(t1); // byteWidth = 64 
RWStructuredBuffer<float4> BufferOut  : register(u0); // byteWidth = 64, zeroed out before reading from the GPU 

[numthreads(1, 1, 1)] 
void CSMain(uint3 DTid : SV_DispatchThreadID) 
{ 
    BufferOut[DTid.x].x = 1; 
} 

मैं निम्न मान बाहर निकलना:

1.000 0.000 0.000 0.000 
1.000 0.000 0.000 0.000 
1.000 0.000 0.000 0.000 
1.000 0.000 0.000 0.000 

यह मेरे लिए समझ में आता है - बफर 4 धागे के रूप में पार्स किया गया है, जिनमें से प्रत्येक को क्रियान्वित 1 Float4 समूह।

1.000 1.000 1.000 1.000 
1.000 1.000 1.000 1.000 
1.000 1.000 1.000 1.000 
1.000 1.000 1.000 1.000 

और वास्तविक कोड के साथ मैं चलाना चाहते हैं:

StructuredBuffer<float4x4> base_matrix  : register(t0); 
StructuredBuffer<float4> extended_matrix : register(t1); 
RWStructuredBuffer<float4> BufferOut  : register(u0); 

[numthreads(1, 1, 1)] 
void CSMain(uint3 DTid : SV_DispatchThreadID) 
{ 
    BufferOut[DTid.x] = mul(base_matrix[0],extended_matrix[DTid.x]) 
} 

मैं

StructuredBuffer<float4x4> base_matrix  : register(t0); // byteWidth = 64 
StructuredBuffer<float4> extended_matrix : register(t1); // byteWidth = 64 
RWStructuredBuffer<float4> BufferOut  : register(u0); // byteWidth = 64, zeroed out before reading from the GPU 

[numthreads(1, 1, 1)] 
void CSMain(uint3 DTid : SV_DispatchThreadID) 
{ 
    BufferOut[DTid.x].x = 1; 
    BufferOut[DTid.x].y = 2; 
    BufferOut[DTid.x].z = 3; 
    BufferOut[DTid.x].w = 4; 
} 

मैं निम्न मान बाहर निकलना:

निम्न कोड के साथ

निम्नलिखित मान बाहर:

0.000 0.000 0.000 0.000 
0.000 0.000 0.000 0.000 
0.000 0.000 0.000 0.000 
0.000 0.000 0.000 0.000 

मैं बता सकता हूं कि मुझे यहां एक महत्वपूर्ण बात याद आ रही है, लेकिन मेरे जीवन के लिए मुझे उचित दस्तावेज नहीं मिल रहा है कि यह कैसे काम करता है। क्या कोई मुझे इस कोड में क्या चल रहा है समझने में मदद कर सकता है?

अपने समय के लिए धन्यवाद,

ज़ैक

एक और नोट के रूप में, इस कोड को एक साथ cribbed था माइक्रोसॉफ्ट डायरेक्ट एसडीके (जून 2010) \ नमूने \ सी ++ \ Direct3D11 \ BasicCompute11 नमूना उपलब्ध का उपयोग कर। अगर मैं कुछ गलत कर रहा हूं, तो मुझे बताने में संकोच न करें। मैं एचएलएसएल में वास्तव में नया हूँ।

संपादित करें: मेरा बफर निर्माण कोड।

CreateStructuredBuffer(g_pDevice, sizeof(float)*16,  1,   g_matrix,   &g_pBuf0); 
CreateStructuredBuffer(g_pDevice, sizeof(float)*4,  NUM_ELEMENTS, g_extended_matrix, &g_pBuf1); 
CreateStructuredBuffer(g_pDevice, sizeof(float)*4,  NUM_ELEMENTS, NULL,    &g_pBufResult); 

//-------------------------------------------------------------------------------------- 
// Create Structured Buffer 
//-------------------------------------------------------------------------------------- 
HRESULT CreateStructuredBuffer(ID3D11Device* pDevice, UINT uElementSize, UINT uCount, VOID* pInitData, ID3D11Buffer** ppBufOut) 
{ 
    *ppBufOut = NULL; 

    D3D11_BUFFER_DESC desc; 
    ZeroMemory(&desc, sizeof(desc)); 
    desc.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE; 
    desc.ByteWidth = uElementSize * uCount; 
    desc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED; 
    desc.StructureByteStride = uElementSize; 

    if (pInitData) 
    { 
     D3D11_SUBRESOURCE_DATA InitData; 
     InitData.pSysMem = pInitData; 
     return pDevice->CreateBuffer(&desc, &InitData, ppBufOut); 
    } else 
     return pDevice->CreateBuffer(&desc, NULL, ppBufOut); 
} 

कोशिश कर रहा .1, .2, .3, .4 ...

StructuredBuffer<float4x4> base_matrix  : register(t0); 
StructuredBuffer<float4> extended_matrix : register(t1); 
StructuredBuffer<uint>  loop_multiplier : register(t2); 
RWStructuredBuffer<float4> BufferOut  : register(u0); 

[numthreads(1, 1, 1)] 
void CSMain(uint3 DTid : SV_DispatchThreadID) 
{ 
    BufferOut[DTid.x].x = .1; 
    BufferOut[DTid.x].y = .2; 
BufferOut[DTid.x].z = .3; 
BufferOut[DTid.x].w = .4; 
} 

इस बाहर हो गया:

0.100 0.100 0.100 0.100 
0.100 0.100 0.100 0.100 
0.100 0.100 0.100 0.100 
0.100 0.100 0.100 0.100 

Answer 1

मैं अपने रास्ते की कोशिश की है, लेकिन मैं एक मिल गया सही परिणाम मैं अपनी छोटी प्रतिष्ठा के कारण टिप्पणी नहीं जोड़ सकता। यहां मेरा कोड है।

HLSL:

RWStructuredBuffer आउटपुट: रजिस्टर (u0);

[numthreads (1, 1, 1)]

शून्य मुख्य (DTid uint3: SV_DispatchThreadID)

{ अगर (DTid.x> 4)

return; 

Output[DTid.x].x= 1.f; 

Output[DTid.x].y = 2.f; 

Output[DTid.x].z = 3.f; 

Output[DTid.x].w = 4.f; 

}

सी ++:

पथनाम

परिभाषित करें

एल "C: \ D3D_Reseach \ RenderPro \ 64 \ डीबग \ ComputeShader.cso \ Users \ ई \ डेस्कटॉप"

struct बफर

{

XMFLOAT4 Test; 

};

पूर्णांक APIENTRY wWinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR

lpCmdLine, पूर्णांक nCmdShow)

{

Hardware HardWare; 

WinSystem Win; 

Win.CreateWindows(HardWare, 400, 300); 

ShowWindow(Win.hwnd, SW_HIDE); 

//UAV 

SharedComPtr<ID3D11UnorderedAccessView> Resource; 

SharedComPtr<ID3D11Buffer>       _Buffer; 

ShaderResourceView::STRUCT_BUUFER_DESC Desc; 

Desc.ACCESS = 0; 

Desc.BIND = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS; 

Desc.FORMAT = DXGI_FORMAT_UNKNOWN; 

Desc.HasScr = false; 

Desc.MISC = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED; 

Desc.USAGE = D3D11_USAGE_DEFAULT; 

Desc.ByteWidth= 4 * sizeof(Buffer); 

Desc.StructureByteStride= sizeof(Buffer); 

Desc.UAV_OR_SRV = ShaderResourceView::UAV; 

ShaderResourceView :: CreateStructBuffer (HardWare.GetD3DDevice(), वर्णन, nullptr, संसाधन। GetTwoLevel(), _Buffer.GetTwoLevel(), सच);

//CompilerShader 

SharedComPtr<ID3D11ComputeShader>  ComputerSahder; 

SharedComPtr<ID3DBlob>        Blob; 

WCHAR *Name = PathName; 

CompilerShader::CompileShaderFromBinary(ComputerSahder.GetTwoLevel(), Name, HardWare.GetD3DDevice(), 
                   Blob.GetTwoLevel(), CompilerShader::ShaderFlag::ComputeShader); 

//Set ComputerHlsl 

HardWare.GetDeviceContext()->CSSetUnorderedAccessViews(0, 1, 

संसाधन। गेटोवोलेवल(), 0);

HardWare.GetDeviceContext()->CSSetShader(ComputerSahder.Get(), 0, 0); 

HardWare.GetDeviceContext()->Dispatch(4, 1, 1); 

//SRV 

Buffer Hy[4]; 

VOID *P = Hy; 

ID3D11Buffer* pBuffer; 

BufferSystem::CreateConstanceBuffer(HardWare.GetD3DDevice(), P, pBuffer, 

Desc.ByteWidth, D3D11_USAGE_STAGING);

HardWare.GetDeviceContext()->CopyResource(pBuffer, _Buffer.Get()); 

D3D11_MAPPED_SUBRESOURCE Data; 

HardWare.GetDeviceContext()->Map(pBuffer, 0, D3D11_MAP_READ, 0, &Data); 

Buffer *PP = reinterpret_cast<Buffer*>(Data.pData); 

for (UINT i = 0; i < 4; ++i) { 

    float a = PP[i].Test.x; 

    a = PP[i].Test.y; 

    a = PP[i].Test.z; 

    a = PP[i].Test.w; 

    a = PP[i].Test.w; 

} 

}