mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-08-04 19:25:47 +00:00
d8b3d99038
1. Validate the buffer range for both vertex step mode and instance step mode vertex buffers in Draw, 2. Validate the buffer range for instance step mode vertex buffers and the range of index buffer in DrawIndexed, and 3. Add related validation unit tests DrawVertexAndIndexBufferOOBValidationTests, and remove out-of-date vertex buffer robustness tests. Bug: dawn:808 Change-Id: Ic27a95138cb1e21b72a1da392b7828368bfe2010 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/56361 Commit-Queue: Zhaoming Jiang <zhaoming.jiang@intel.com> Reviewed-by: Austin Eng <enga@chromium.org>
299 lines
13 KiB
C++
299 lines
13 KiB
C++
// Copyright 2017 The Dawn Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "dawn_native/CommandBufferStateTracker.h"
|
|
|
|
#include "common/Assert.h"
|
|
#include "common/BitSetIterator.h"
|
|
#include "dawn_native/BindGroup.h"
|
|
#include "dawn_native/ComputePipeline.h"
|
|
#include "dawn_native/Forward.h"
|
|
#include "dawn_native/PipelineLayout.h"
|
|
#include "dawn_native/RenderPipeline.h"
|
|
|
|
namespace dawn_native {
|
|
|
|
namespace {
|
|
bool BufferSizesAtLeastAsBig(const ityp::span<uint32_t, uint64_t> unverifiedBufferSizes,
|
|
const std::vector<uint64_t>& pipelineMinBufferSizes) {
|
|
ASSERT(unverifiedBufferSizes.size() == pipelineMinBufferSizes.size());
|
|
|
|
for (uint32_t i = 0; i < unverifiedBufferSizes.size(); ++i) {
|
|
if (unverifiedBufferSizes[i] < pipelineMinBufferSizes[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
} // namespace
|
|
|
|
enum ValidationAspect {
|
|
VALIDATION_ASPECT_PIPELINE,
|
|
VALIDATION_ASPECT_BIND_GROUPS,
|
|
VALIDATION_ASPECT_VERTEX_BUFFERS,
|
|
VALIDATION_ASPECT_INDEX_BUFFER,
|
|
|
|
VALIDATION_ASPECT_COUNT
|
|
};
|
|
static_assert(VALIDATION_ASPECT_COUNT == CommandBufferStateTracker::kNumAspects, "");
|
|
|
|
static constexpr CommandBufferStateTracker::ValidationAspects kDispatchAspects =
|
|
1 << VALIDATION_ASPECT_PIPELINE | 1 << VALIDATION_ASPECT_BIND_GROUPS;
|
|
|
|
static constexpr CommandBufferStateTracker::ValidationAspects kDrawAspects =
|
|
1 << VALIDATION_ASPECT_PIPELINE | 1 << VALIDATION_ASPECT_BIND_GROUPS |
|
|
1 << VALIDATION_ASPECT_VERTEX_BUFFERS;
|
|
|
|
static constexpr CommandBufferStateTracker::ValidationAspects kDrawIndexedAspects =
|
|
1 << VALIDATION_ASPECT_PIPELINE | 1 << VALIDATION_ASPECT_BIND_GROUPS |
|
|
1 << VALIDATION_ASPECT_VERTEX_BUFFERS | 1 << VALIDATION_ASPECT_INDEX_BUFFER;
|
|
|
|
static constexpr CommandBufferStateTracker::ValidationAspects kLazyAspects =
|
|
1 << VALIDATION_ASPECT_BIND_GROUPS | 1 << VALIDATION_ASPECT_VERTEX_BUFFERS |
|
|
1 << VALIDATION_ASPECT_INDEX_BUFFER;
|
|
|
|
MaybeError CommandBufferStateTracker::ValidateCanDispatch() {
|
|
return ValidateOperation(kDispatchAspects);
|
|
}
|
|
|
|
MaybeError CommandBufferStateTracker::ValidateCanDraw() {
|
|
return ValidateOperation(kDrawAspects);
|
|
}
|
|
|
|
MaybeError CommandBufferStateTracker::ValidateCanDrawIndexed() {
|
|
return ValidateOperation(kDrawIndexedAspects);
|
|
}
|
|
|
|
MaybeError CommandBufferStateTracker::ValidateBufferInRangeForVertexBuffer(
|
|
uint32_t vertexCount,
|
|
uint32_t firstVertex) {
|
|
const ityp::bitset<VertexBufferSlot, kMaxVertexBuffers>&
|
|
vertexBufferSlotsUsedAsVertexBuffer =
|
|
mLastRenderPipeline->GetVertexBufferSlotsUsedAsVertexBuffer();
|
|
|
|
for (auto usedSlotVertex : IterateBitSet(vertexBufferSlotsUsedAsVertexBuffer)) {
|
|
const VertexBufferInfo& vertexBuffer =
|
|
mLastRenderPipeline->GetVertexBuffer(usedSlotVertex);
|
|
uint64_t arrayStride = vertexBuffer.arrayStride;
|
|
uint64_t bufferSize = mVertexBufferSizes[usedSlotVertex];
|
|
// firstVertex and vertexCount are in uint32_t, and arrayStride must not
|
|
// be larger than kMaxVertexBufferArrayStride, which is currently 2048. So by
|
|
// doing checks in uint64_t we avoid overflows.
|
|
if ((static_cast<uint64_t>(firstVertex) + vertexCount) * arrayStride > bufferSize) {
|
|
return DAWN_VALIDATION_ERROR("Vertex buffer out of bound");
|
|
}
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
MaybeError CommandBufferStateTracker::ValidateBufferInRangeForInstanceBuffer(
|
|
uint32_t instanceCount,
|
|
uint32_t firstInstance) {
|
|
const ityp::bitset<VertexBufferSlot, kMaxVertexBuffers>&
|
|
vertexBufferSlotsUsedAsInstanceBuffer =
|
|
mLastRenderPipeline->GetVertexBufferSlotsUsedAsInstanceBuffer();
|
|
|
|
for (auto usedSlotInstance : IterateBitSet(vertexBufferSlotsUsedAsInstanceBuffer)) {
|
|
const VertexBufferInfo& vertexBuffer =
|
|
mLastRenderPipeline->GetVertexBuffer(usedSlotInstance);
|
|
uint64_t arrayStride = vertexBuffer.arrayStride;
|
|
uint64_t bufferSize = mVertexBufferSizes[usedSlotInstance];
|
|
// firstInstance and instanceCount are in uint32_t, and arrayStride must
|
|
// not be larger than kMaxVertexBufferArrayStride, which is currently 2048.
|
|
// So by doing checks in uint64_t we avoid overflows.
|
|
if ((static_cast<uint64_t>(firstInstance) + instanceCount) * arrayStride > bufferSize) {
|
|
return DAWN_VALIDATION_ERROR("Vertex buffer out of bound");
|
|
}
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
MaybeError CommandBufferStateTracker::ValidateIndexBufferInRange(uint32_t indexCount,
|
|
uint32_t firstIndex) {
|
|
// Validate the range of index buffer
|
|
// firstIndex and indexCount are in uint32_t, while IndexFormatSize is 2 (for
|
|
// wgpu::IndexFormat::Uint16) or 4 (for wgpu::IndexFormat::Uint32), so by doing checks in
|
|
// uint64_t we avoid overflows.
|
|
if ((static_cast<uint64_t>(firstIndex) + indexCount) * IndexFormatSize(mIndexFormat) >
|
|
mIndexBufferSize) {
|
|
// Index range is out of bounds
|
|
return DAWN_VALIDATION_ERROR("Index buffer out of bound");
|
|
}
|
|
return {};
|
|
}
|
|
|
|
MaybeError CommandBufferStateTracker::ValidateOperation(ValidationAspects requiredAspects) {
|
|
// Fast return-true path if everything is good
|
|
ValidationAspects missingAspects = requiredAspects & ~mAspects;
|
|
if (missingAspects.none()) {
|
|
return {};
|
|
}
|
|
|
|
// Generate an error immediately if a non-lazy aspect is missing as computing lazy aspects
|
|
// requires the pipeline to be set.
|
|
DAWN_TRY(CheckMissingAspects(missingAspects & ~kLazyAspects));
|
|
|
|
RecomputeLazyAspects(missingAspects);
|
|
|
|
DAWN_TRY(CheckMissingAspects(requiredAspects & ~mAspects));
|
|
|
|
return {};
|
|
}
|
|
|
|
void CommandBufferStateTracker::RecomputeLazyAspects(ValidationAspects aspects) {
|
|
ASSERT(mAspects[VALIDATION_ASPECT_PIPELINE]);
|
|
ASSERT((aspects & ~kLazyAspects).none());
|
|
|
|
if (aspects[VALIDATION_ASPECT_BIND_GROUPS]) {
|
|
bool matches = true;
|
|
|
|
for (BindGroupIndex i : IterateBitSet(mLastPipelineLayout->GetBindGroupLayoutsMask())) {
|
|
if (mBindgroups[i] == nullptr ||
|
|
mLastPipelineLayout->GetBindGroupLayout(i) != mBindgroups[i]->GetLayout() ||
|
|
!BufferSizesAtLeastAsBig(mBindgroups[i]->GetUnverifiedBufferSizes(),
|
|
(*mMinBufferSizes)[i])) {
|
|
matches = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (matches) {
|
|
mAspects.set(VALIDATION_ASPECT_BIND_GROUPS);
|
|
}
|
|
}
|
|
|
|
if (aspects[VALIDATION_ASPECT_VERTEX_BUFFERS]) {
|
|
ASSERT(mLastRenderPipeline != nullptr);
|
|
|
|
const ityp::bitset<VertexBufferSlot, kMaxVertexBuffers>& requiredVertexBuffers =
|
|
mLastRenderPipeline->GetVertexBufferSlotsUsed();
|
|
if (IsSubset(requiredVertexBuffers, mVertexBufferSlotsUsed)) {
|
|
mAspects.set(VALIDATION_ASPECT_VERTEX_BUFFERS);
|
|
}
|
|
}
|
|
|
|
if (aspects[VALIDATION_ASPECT_INDEX_BUFFER] && mIndexBufferSet) {
|
|
if (!IsStripPrimitiveTopology(mLastRenderPipeline->GetPrimitiveTopology()) ||
|
|
mIndexFormat == mLastRenderPipeline->GetStripIndexFormat()) {
|
|
mAspects.set(VALIDATION_ASPECT_INDEX_BUFFER);
|
|
}
|
|
}
|
|
}
|
|
|
|
MaybeError CommandBufferStateTracker::CheckMissingAspects(ValidationAspects aspects) {
|
|
if (!aspects.any()) {
|
|
return {};
|
|
}
|
|
|
|
if (aspects[VALIDATION_ASPECT_INDEX_BUFFER]) {
|
|
wgpu::IndexFormat pipelineIndexFormat = mLastRenderPipeline->GetStripIndexFormat();
|
|
if (!mIndexBufferSet) {
|
|
return DAWN_VALIDATION_ERROR("Missing index buffer");
|
|
} else if (IsStripPrimitiveTopology(mLastRenderPipeline->GetPrimitiveTopology()) &&
|
|
mIndexFormat != pipelineIndexFormat) {
|
|
return DAWN_VALIDATION_ERROR(
|
|
"Pipeline strip index format does not match index buffer format");
|
|
}
|
|
|
|
// The chunk of code above should be similar to the one in |RecomputeLazyAspects|.
|
|
// It returns the first invalid state found. We shouldn't be able to reach this line
|
|
// because to have invalid aspects one of the above conditions must have failed earlier.
|
|
// If this is reached, make sure lazy aspects and the error checks above are consistent.
|
|
UNREACHABLE();
|
|
return DAWN_VALIDATION_ERROR("Index buffer invalid");
|
|
}
|
|
|
|
if (aspects[VALIDATION_ASPECT_VERTEX_BUFFERS]) {
|
|
return DAWN_VALIDATION_ERROR("Missing vertex buffer");
|
|
}
|
|
|
|
if (aspects[VALIDATION_ASPECT_BIND_GROUPS]) {
|
|
for (BindGroupIndex i : IterateBitSet(mLastPipelineLayout->GetBindGroupLayoutsMask())) {
|
|
if (mBindgroups[i] == nullptr) {
|
|
return DAWN_VALIDATION_ERROR("Missing bind group " +
|
|
std::to_string(static_cast<uint32_t>(i)));
|
|
} else if (mLastPipelineLayout->GetBindGroupLayout(i) !=
|
|
mBindgroups[i]->GetLayout()) {
|
|
return DAWN_VALIDATION_ERROR(
|
|
"Pipeline and bind group layout doesn't match for bind group " +
|
|
std::to_string(static_cast<uint32_t>(i)));
|
|
} else if (!BufferSizesAtLeastAsBig(mBindgroups[i]->GetUnverifiedBufferSizes(),
|
|
(*mMinBufferSizes)[i])) {
|
|
return DAWN_VALIDATION_ERROR("Binding sizes too small for bind group " +
|
|
std::to_string(static_cast<uint32_t>(i)));
|
|
}
|
|
}
|
|
|
|
// The chunk of code above should be similar to the one in |RecomputeLazyAspects|.
|
|
// It returns the first invalid state found. We shouldn't be able to reach this line
|
|
// because to have invalid aspects one of the above conditions must have failed earlier.
|
|
// If this is reached, make sure lazy aspects and the error checks above are consistent.
|
|
UNREACHABLE();
|
|
return DAWN_VALIDATION_ERROR("Bind groups invalid");
|
|
}
|
|
|
|
if (aspects[VALIDATION_ASPECT_PIPELINE]) {
|
|
return DAWN_VALIDATION_ERROR("Missing pipeline");
|
|
}
|
|
|
|
UNREACHABLE();
|
|
}
|
|
|
|
void CommandBufferStateTracker::SetComputePipeline(ComputePipelineBase* pipeline) {
|
|
SetPipelineCommon(pipeline);
|
|
}
|
|
|
|
void CommandBufferStateTracker::SetRenderPipeline(RenderPipelineBase* pipeline) {
|
|
mLastRenderPipeline = pipeline;
|
|
SetPipelineCommon(pipeline);
|
|
}
|
|
|
|
void CommandBufferStateTracker::SetBindGroup(BindGroupIndex index, BindGroupBase* bindgroup) {
|
|
mBindgroups[index] = bindgroup;
|
|
mAspects.reset(VALIDATION_ASPECT_BIND_GROUPS);
|
|
}
|
|
|
|
void CommandBufferStateTracker::SetIndexBuffer(wgpu::IndexFormat format, uint64_t size) {
|
|
mIndexBufferSet = true;
|
|
mIndexFormat = format;
|
|
mIndexBufferSize = size;
|
|
}
|
|
|
|
void CommandBufferStateTracker::SetVertexBuffer(VertexBufferSlot slot, uint64_t size) {
|
|
mVertexBufferSlotsUsed.set(slot);
|
|
mVertexBufferSizes[slot] = size;
|
|
}
|
|
|
|
void CommandBufferStateTracker::SetPipelineCommon(PipelineBase* pipeline) {
|
|
mLastPipelineLayout = pipeline->GetLayout();
|
|
mMinBufferSizes = &pipeline->GetMinBufferSizes();
|
|
|
|
mAspects.set(VALIDATION_ASPECT_PIPELINE);
|
|
|
|
// Reset lazy aspects so they get recomputed on the next operation.
|
|
mAspects &= ~kLazyAspects;
|
|
}
|
|
|
|
BindGroupBase* CommandBufferStateTracker::GetBindGroup(BindGroupIndex index) const {
|
|
return mBindgroups[index];
|
|
}
|
|
|
|
PipelineLayoutBase* CommandBufferStateTracker::GetPipelineLayout() const {
|
|
return mLastPipelineLayout;
|
|
}
|
|
} // namespace dawn_native
|