Skip to content

Commit 671cf55

Browse files
TheMostDiligentTheMostDiligent
committed
ShaderResourceCacheGL: rework inline constant buffer initialization
1 parent 52a999a commit 671cf55

3 files changed

Lines changed: 84 additions & 127 deletions

File tree

‎Graphics/GraphicsEngineOpenGL/include/ShaderResourceCacheGL.hpp‎

Lines changed: 24 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -158,7 +158,20 @@ class ShaderResourceCacheGL : public ShaderResourceCacheBase
158158
using TResourceCount = std::array<Uint16, 4>; // same as PipelineResourceSignatureGLImpl::TBindings.
159159
static size_t GetRequiredMemorySize(const TResourceCount& ResCount, Uint32 TotalInlineConstants = 0);
160160

161-
void Initialize(const TResourceCount& Count, IMemoryAllocator& MemAllocator, Uint64 DynamicUBOSlotMask, Uint64 DynamicSSBOSlotMask, Uint32 TotalInlineConstants = 0);
161+
struct InitAttribs
162+
{
163+
const TResourceCount& ResCount;
164+
IMemoryAllocator& MemAllocator;
165+
InlineConstantBufferAttribsGL* pInlineConstantBuffers = nullptr;
166+
Uint32 NumInlineConstantBuffers = 0;
167+
Uint64 DynamicUBOSlotMask = 0;
168+
Uint64 DynamicSSBOSlotMask = 0;
169+
170+
#ifdef DILIGENT_DEBUG
171+
Uint32 DbgTotalInlineConstants = 0;
172+
#endif
173+
};
174+
void Initialize(const InitAttribs& Attribs);
162175

163176
void SetUniformBuffer(Uint32 CacheOffset, RefCntAutoPtr<BufferGLImpl>&& pBuff, Uint64 BaseOffset, Uint64 RangeSize)
164177
{
@@ -299,10 +312,10 @@ class ShaderResourceCacheGL : public ShaderResourceCacheBase
299312
}
300313

301314
// clang-format off
302-
Uint32 GetUBCount() const { return (m_TexturesOffset - m_UBsOffset) / sizeof(CachedUB); }
303-
Uint32 GetTextureCount() const { return (m_ImagesOffset - m_TexturesOffset) / sizeof(CachedResourceView); }
304-
Uint32 GetImageCount() const { return (m_SSBOsOffset - m_ImagesOffset) / sizeof(CachedResourceView); }
305-
Uint32 GetSSBOCount() const { return (m_MemoryEndOffset - m_SSBOsOffset) / sizeof(CachedSSBO); }
315+
Uint32 GetUBCount() const { return (m_TexturesOffset - m_UBsOffset) / sizeof(CachedUB); }
316+
Uint32 GetTextureCount() const { return (m_ImagesOffset - m_TexturesOffset) / sizeof(CachedResourceView); }
317+
Uint32 GetImageCount() const { return (m_SSBOsOffset - m_ImagesOffset) / sizeof(CachedResourceView); }
318+
Uint32 GetSSBOCount() const { return (m_ResourceEndOffset - m_SSBOsOffset) / sizeof(CachedSSBO); }
306319
// clang-format on
307320

308321
const CachedUB& GetConstUB(Uint32 CacheOffset) const
@@ -331,7 +344,7 @@ class ShaderResourceCacheGL : public ShaderResourceCacheBase
331344

332345
bool IsInitialized() const
333346
{
334-
return m_MemoryEndOffset != InvalidResourceOffset;
347+
return m_ResourceEndOffset != InvalidResourceOffset;
335348
}
336349

337350
ResourceCacheContentType GetContentType() const { return m_ContentType; }
@@ -364,11 +377,6 @@ class ShaderResourceCacheGL : public ShaderResourceCacheBase
364377
return m_HasInlineConstants;
365378
}
366379

367-
void InitInlineConstantBuffer(Uint32 CacheOffset,
368-
RefCntAutoPtr<BufferGLImpl> pBuffer,
369-
Uint32 NumConstants,
370-
Uint32 InlineConstantOffset);
371-
372380
void SetInlineConstants(Uint32 CacheOffset,
373381
const void* pConstants,
374382
Uint32 FirstConstant,
@@ -389,7 +397,6 @@ class ShaderResourceCacheGL : public ShaderResourceCacheBase
389397

390398
#ifdef DILIGENT_DEBUG
391399
void DbgVerifyDynamicBufferMasks() const;
392-
void DbgVerifyResourceInitialization() const;
393400
#endif
394401

395402
private:
@@ -417,10 +424,10 @@ class ShaderResourceCacheGL : public ShaderResourceCacheBase
417424
static constexpr const Uint16 InvalidResourceOffset = 0xFFFF;
418425
static constexpr const Uint16 m_UBsOffset = 0;
419426

420-
Uint16 m_TexturesOffset = InvalidResourceOffset;
421-
Uint16 m_ImagesOffset = InvalidResourceOffset;
422-
Uint16 m_SSBOsOffset = InvalidResourceOffset;
423-
Uint16 m_MemoryEndOffset = InvalidResourceOffset;
427+
Uint16 m_TexturesOffset = InvalidResourceOffset;
428+
Uint16 m_ImagesOffset = InvalidResourceOffset;
429+
Uint16 m_SSBOsOffset = InvalidResourceOffset;
430+
Uint16 m_ResourceEndOffset = InvalidResourceOffset;
424431

425432
std::unique_ptr<Uint8, STDDeleter<Uint8, IMemoryAllocator>> m_pResourceData;
426433

@@ -439,8 +446,7 @@ class ShaderResourceCacheGL : public ShaderResourceCacheBase
439446
bool m_HasInlineConstants = false;
440447

441448
#ifdef DILIGENT_DEVELOPMENT
442-
bool m_bStaticResourcesInitialized = false;
443-
std::vector<bool> m_DbgAssignedInlineConstants;
449+
bool m_bStaticResourcesInitialized = false;
444450
#endif
445451
};
446452

‎Graphics/GraphicsEngineOpenGL/src/PipelineResourceSignatureGLImpl.cpp‎

Lines changed: 13 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -224,37 +224,11 @@ void PipelineResourceSignatureGLImpl::CreateLayout(const bool IsSerialized)
224224

225225
if (m_pStaticResCache)
226226
{
227-
m_pStaticResCache->Initialize(StaticResCounter, GetRawAllocator(), 0x0, 0x0, m_TotalStaticInlineConstants);
228-
229-
// Initialize inline constant buffers in the static cache.
230-
// This allows static inline constants to be set on the signature and later copied to SRBs.
231-
if (m_NumInlineConstantBuffers > 0)
232-
{
233-
Uint32 InlineConstantOffset = 0;
234-
for (Uint32 i = 0; i < m_NumInlineConstantBuffers; ++i)
235-
{
236-
const InlineConstantBufferAttribsGL& InlineCBAttr = GetInlineConstantBufferAttribs(i);
237-
VERIFY_EXPR(InlineCBAttr.pBuffer);
238-
VERIFY_EXPR(InlineCBAttr.NumConstants > 0);
239-
240-
// Only initialize inline constant buffers that are within the static cache range.
241-
// Mutable and dynamic inline constant buffers are not stored in the static cache.
242-
if (InlineCBAttr.CacheOffset < StaticResCounter[BINDING_RANGE_UNIFORM_BUFFER])
243-
{
244-
m_pStaticResCache->InitInlineConstantBuffer(
245-
InlineCBAttr.CacheOffset,
246-
InlineCBAttr.pBuffer,
247-
InlineCBAttr.NumConstants,
248-
InlineConstantOffset);
249-
250-
InlineConstantOffset += InlineCBAttr.NumConstants;
251-
}
252-
}
253-
VERIFY_EXPR(InlineConstantOffset == m_TotalStaticInlineConstants);
254-
}
227+
ShaderResourceCacheGL::InitAttribs CacheInitAttribs{StaticResCounter, GetRawAllocator(), m_pInlineConstantBuffers, m_NumInlineConstantBuffers};
255228
#ifdef DILIGENT_DEBUG
256-
m_pStaticResCache->DbgVerifyResourceInitialization();
229+
CacheInitAttribs.DbgTotalInlineConstants = m_TotalStaticInlineConstants;
257230
#endif
231+
m_pStaticResCache->Initialize(CacheInitAttribs);
258232
}
259233
}
260234

@@ -606,34 +580,18 @@ void PipelineResourceSignatureGLImpl::UpdateInlineConstantBuffers(const ShaderRe
606580

607581
void PipelineResourceSignatureGLImpl::InitSRBResourceCache(ShaderResourceCacheGL& ResourceCache)
608582
{
609-
ResourceCache.Initialize(m_BindingCount, m_SRBMemAllocator.GetResourceCacheDataAllocator(0), m_DynamicUBOMask, m_DynamicSSBOMask, m_TotalInlineConstants);
610-
611-
// Initialize inline constant buffers.
612-
// Each inline constant buffer shares a single dynamic UBO created in CreateLayout().
613-
// The staging data is stored contiguously at the tail of the resource cache memory.
614-
if (m_NumInlineConstantBuffers > 0)
615-
{
616-
// Inline constant data starts at m_MemoryEndOffset in the cache
617-
Uint32 InlineConstantOffset = 0;
618-
for (Uint32 i = 0; i < m_NumInlineConstantBuffers; ++i)
619-
{
620-
const InlineConstantBufferAttribsGL& InlineCBAttr = GetInlineConstantBufferAttribs(i);
621-
VERIFY_EXPR(InlineCBAttr.pBuffer);
622-
VERIFY_EXPR(InlineCBAttr.NumConstants > 0);
623-
624-
ResourceCache.InitInlineConstantBuffer(
625-
InlineCBAttr.CacheOffset,
626-
InlineCBAttr.pBuffer,
627-
InlineCBAttr.NumConstants,
628-
InlineConstantOffset);
629-
630-
InlineConstantOffset += InlineCBAttr.NumConstants;
631-
}
632-
VERIFY_EXPR(InlineConstantOffset == m_TotalInlineConstants);
633-
}
583+
ShaderResourceCacheGL::InitAttribs CacheInitAttribs{
584+
m_BindingCount,
585+
m_SRBMemAllocator.GetResourceCacheDataAllocator(0),
586+
m_pInlineConstantBuffers,
587+
m_NumInlineConstantBuffers,
588+
};
589+
CacheInitAttribs.DynamicUBOSlotMask = m_DynamicUBOMask;
590+
CacheInitAttribs.DynamicSSBOSlotMask = m_DynamicSSBOMask;
634591
#ifdef DILIGENT_DEBUG
635-
ResourceCache.DbgVerifyResourceInitialization();
592+
CacheInitAttribs.DbgTotalInlineConstants = m_TotalInlineConstants;
636593
#endif
594+
ResourceCache.Initialize(CacheInitAttribs);
637595

638596
// Initialize immutable samplers
639597
for (Uint32 r = 0; r < m_Desc.NumResources; ++r)

‎Graphics/GraphicsEngineOpenGL/src/ShaderResourceCacheGL.cpp‎

Lines changed: 47 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -54,39 +54,49 @@ size_t ShaderResourceCacheGL::GetRequiredMemorySize(const TResourceCount& ResCou
5454
return MemSize;
5555
}
5656

57-
void ShaderResourceCacheGL::Initialize(const TResourceCount& ResCount, IMemoryAllocator& MemAllocator, Uint64 DynamicUBOSlotMask, Uint64 DynamicSSBOSlotMask, Uint32 TotalInlineConstants)
57+
void ShaderResourceCacheGL::Initialize(const InitAttribs& Attribs)
5858
{
59-
m_DynamicUBOSlotMask = DynamicUBOSlotMask;
60-
m_DynamicSSBOSlotMask = DynamicSSBOSlotMask;
61-
m_HasInlineConstants = (TotalInlineConstants > 0);
62-
#ifdef DILIGENT_DEBUG
63-
m_DbgAssignedInlineConstants.resize(TotalInlineConstants);
64-
#endif
65-
6659
VERIFY(!m_pResourceData, "Cache has already been initialized");
6760

61+
m_DynamicUBOSlotMask = Attribs.DynamicUBOSlotMask;
62+
m_DynamicSSBOSlotMask = Attribs.DynamicSSBOSlotMask;
63+
64+
const TResourceCount& ResCount = Attribs.ResCount;
65+
66+
// Count the total number of inline constants in range
67+
Uint32 TotalInlineConstants = 0;
68+
for (Uint32 i = 0; i < Attribs.NumInlineConstantBuffers; ++i)
69+
{
70+
const InlineConstantBufferAttribsGL& InlineCBAttribs = Attribs.pInlineConstantBuffers[i];
71+
if (InlineCBAttribs.CacheOffset < ResCount[BINDING_RANGE_UNIFORM_BUFFER])
72+
TotalInlineConstants += InlineCBAttribs.NumConstants;
73+
}
74+
VERIFY_EXPR(TotalInlineConstants == Attribs.DbgTotalInlineConstants);
75+
76+
m_HasInlineConstants = (TotalInlineConstants > 0);
77+
6878
// clang-format off
6979
m_TexturesOffset = static_cast<Uint16>(m_UBsOffset + sizeof(CachedUB) * ResCount[BINDING_RANGE_UNIFORM_BUFFER]);
7080
m_ImagesOffset = static_cast<Uint16>(m_TexturesOffset + sizeof(CachedResourceView) * ResCount[BINDING_RANGE_TEXTURE]);
7181
m_SSBOsOffset = static_cast<Uint16>(m_ImagesOffset + sizeof(CachedResourceView) * ResCount[BINDING_RANGE_IMAGE]);
72-
m_MemoryEndOffset = static_cast<Uint16>(m_SSBOsOffset + sizeof(CachedSSBO) * ResCount[BINDING_RANGE_STORAGE_BUFFER]);
82+
m_ResourceEndOffset = static_cast<Uint16>(m_SSBOsOffset + sizeof(CachedSSBO) * ResCount[BINDING_RANGE_STORAGE_BUFFER]);
7383

7484
VERIFY_EXPR(GetUBCount() == static_cast<Uint32>(ResCount[BINDING_RANGE_UNIFORM_BUFFER]));
7585
VERIFY_EXPR(GetTextureCount() == static_cast<Uint32>(ResCount[BINDING_RANGE_TEXTURE]));
7686
VERIFY_EXPR(GetImageCount() == static_cast<Uint32>(ResCount[BINDING_RANGE_IMAGE]));
7787
VERIFY_EXPR(GetSSBOCount() == static_cast<Uint32>(ResCount[BINDING_RANGE_STORAGE_BUFFER]));
7888
// clang-format on
7989

80-
// Inline constant data tail is after m_MemoryEndOffset
81-
size_t BufferSize = m_MemoryEndOffset + TotalInlineConstants * sizeof(Uint32);
90+
// Inline constant data tail is after m_ResourceEndOffset
91+
size_t BufferSize = m_ResourceEndOffset + TotalInlineConstants * sizeof(Uint32);
8292

8393
VERIFY_EXPR(BufferSize == GetRequiredMemorySize(ResCount, TotalInlineConstants));
8494

8595
if (BufferSize > 0)
8696
{
8797
m_pResourceData = decltype(m_pResourceData){
88-
ALLOCATE(MemAllocator, "Shader resource cache data buffer", Uint8, BufferSize),
89-
STDDeleter<Uint8, IMemoryAllocator>(MemAllocator) //
98+
ALLOCATE(Attribs.MemAllocator, "Shader resource cache data buffer", Uint8, BufferSize),
99+
STDDeleter<Uint8, IMemoryAllocator>(Attribs.MemAllocator) //
90100
};
91101
memset(m_pResourceData.get(), 0, BufferSize);
92102
}
@@ -103,6 +113,26 @@ void ShaderResourceCacheGL::Initialize(const TResourceCount& ResCount, IMemoryAl
103113

104114
for (Uint32 s = 0; s < GetSSBOCount(); ++s)
105115
new (&GetSSBO(s)) CachedSSBO;
116+
117+
// Initialize inline constant buffers
118+
Uint32 InlineConstantOffset = 0;
119+
for (Uint32 i = 0; i < Attribs.NumInlineConstantBuffers; ++i)
120+
{
121+
const InlineConstantBufferAttribsGL& InlineCBAttribs = Attribs.pInlineConstantBuffers[i];
122+
if (InlineCBAttribs.CacheOffset < ResCount[BINDING_RANGE_UNIFORM_BUFFER])
123+
{
124+
CachedUB& UB = GetUB(InlineCBAttribs.CacheOffset);
125+
UB.pBuffer = InlineCBAttribs.pBuffer;
126+
UB.BaseOffset = 0;
127+
UB.RangeSize = InlineCBAttribs.NumConstants * sizeof(Uint32);
128+
UB.DynamicOffset = 0;
129+
UB.pInlineConstantData = reinterpret_cast<Uint32*>(m_pResourceData.get() + m_ResourceEndOffset) + InlineConstantOffset;
130+
131+
InlineConstantOffset += InlineCBAttribs.NumConstants;
132+
}
133+
}
134+
135+
VERIFY_EXPR(InlineConstantOffset == TotalInlineConstants);
106136
}
107137

108138
ShaderResourceCacheGL::~ShaderResourceCacheGL()
@@ -121,10 +151,10 @@ ShaderResourceCacheGL::~ShaderResourceCacheGL()
121151
for (Uint32 s = 0; s < GetSSBOCount(); ++s)
122152
GetSSBO(s).~CachedSSBO();
123153

124-
m_TexturesOffset = InvalidResourceOffset;
125-
m_ImagesOffset = InvalidResourceOffset;
126-
m_SSBOsOffset = InvalidResourceOffset;
127-
m_MemoryEndOffset = InvalidResourceOffset;
154+
m_TexturesOffset = InvalidResourceOffset;
155+
m_ImagesOffset = InvalidResourceOffset;
156+
m_SSBOsOffset = InvalidResourceOffset;
157+
m_ResourceEndOffset = InvalidResourceOffset;
128158
}
129159
m_pResourceData.reset();
130160
}
@@ -345,35 +375,6 @@ void ShaderResourceCacheGL::BindDynamicBuffers(GLContextState& GLSt
345375
}
346376
}
347377

348-
void ShaderResourceCacheGL::InitInlineConstantBuffer(Uint32 CacheOffset,
349-
RefCntAutoPtr<BufferGLImpl> pBuffer,
350-
Uint32 NumConstants,
351-
Uint32 InlineConstantOffset)
352-
{
353-
VERIFY_EXPR(pBuffer);
354-
VERIFY_EXPR(m_HasInlineConstants);
355-
VERIFY_EXPR(m_pResourceData);
356-
357-
#ifdef DILIGENT_DEBUG
358-
if (InlineConstantOffset != ~0u)
359-
{
360-
VERIFY(InlineConstantOffset + NumConstants <= m_DbgAssignedInlineConstants.size(), "Inline constant storage overflow");
361-
for (Uint32 i = 0; i < NumConstants; ++i)
362-
{
363-
VERIFY(!m_DbgAssignedInlineConstants[InlineConstantOffset + i], "Inline constant storage at offset ", InlineConstantOffset + i, " has already been assigned");
364-
m_DbgAssignedInlineConstants[InlineConstantOffset + i] = true;
365-
}
366-
}
367-
#endif
368-
369-
CachedUB& UB = GetUB(CacheOffset);
370-
UB.pBuffer = std::move(pBuffer);
371-
UB.BaseOffset = 0;
372-
UB.RangeSize = NumConstants * sizeof(Uint32);
373-
UB.DynamicOffset = 0;
374-
UB.pInlineConstantData = reinterpret_cast<Uint32*>(m_pResourceData.get() + m_MemoryEndOffset) + InlineConstantOffset;
375-
}
376-
377378
void ShaderResourceCacheGL::CopyInlineConstants(const ShaderResourceCacheGL& SrcCache,
378379
Uint32 CacheOffset,
379380
Uint32 NumConstants)
@@ -411,14 +412,6 @@ void ShaderResourceCacheGL::DbgVerifyDynamicBufferMasks() const
411412
VERIFY(((m_DynamicSSBOMask & SSBOBit) != 0) == (SSBO.IsDynamic() && (m_DynamicSSBOSlotMask & SSBOBit) != 0), "Bit ", ssbo, " in m_DynamicSSBOMask is invalid");
412413
}
413414
}
414-
415-
void ShaderResourceCacheGL::DbgVerifyResourceInitialization() const
416-
{
417-
for (bool InlineConstAssigned : m_DbgAssignedInlineConstants)
418-
{
419-
VERIFY(InlineConstAssigned, "Not all inline constant storage has been assigned. This is a bug.");
420-
}
421-
}
422415
#endif
423416

424417
} // namespace Diligent

0 commit comments

Comments
 (0)