Metal stats (#1781)

This commit is contained in:
Tim Sylvester
2023-10-20 15:45:08 -07:00
committed by GitHub
parent 07c70fe1c8
commit 1a1c826fa4
28 changed files with 347 additions and 116 deletions

View File

@@ -103,7 +103,8 @@ protected:
public:
virtual std::unique_ptr<CommandEncoder> createCommandEncoder() = 0;
virtual const RenderingStats& renderingStats() const = 0;
gfx::RenderingStats& renderingStats() { return stats; }
const gfx::RenderingStats& renderingStats() const { return stats; }
#if !defined(NDEBUG)
public:
@@ -156,6 +157,9 @@ public:
}
#endif
protected:
gfx::RenderingStats stats;
};
} // namespace gfx

View File

@@ -1,12 +1,74 @@
#include <mbgl/gfx/rendering_stats.hpp>
#include <algorithm>
#include <initializer_list>
#include <sstream>
namespace mbgl {
namespace gfx {
bool RenderingStats::isZero() const {
return numActiveTextures == 0 && numCreatedTextures == 0 && numBuffers == 0 && numFrameBuffers == 0 &&
memTextures == 0 && memIndexBuffers == 0 && memVertexBuffers == 0;
const auto expectedZeros = {numActiveTextures,
numTextureBindings,
numBuffers,
numVertexBuffers,
numIndexBuffers,
numUniformBuffers,
numFrameBuffers,
memTextures,
memBuffers,
memIndexBuffers,
memVertexBuffers,
memUniformBuffers};
return std::all_of(expectedZeros.begin(), expectedZeros.end(), [](auto x) { return x == 0; });
}
RenderingStats& RenderingStats::operator+=(const RenderingStats& r) {
numFrames += r.numFrames;
numDrawCalls += r.numDrawCalls;
totalDrawCalls += r.totalDrawCalls;
numCreatedTextures += r.numCreatedTextures;
numActiveTextures += r.numActiveTextures;
numTextureBindings += r.numTextureBindings;
numTextureUpdates += r.numTextureUpdates;
textureUpdateBytes += r.textureUpdateBytes;
numBuffers += r.numBuffers;
numFrameBuffers += r.numFrameBuffers;
numIndexBuffers += r.numIndexBuffers;
indexUpdateBytes += r.indexUpdateBytes;
numVertexBuffers += r.numVertexBuffers;
vertexUpdateBytes += r.vertexUpdateBytes;
numUniformBuffers += r.numUniformBuffers;
numUniformUpdates += r.numUniformUpdates;
uniformUpdateBytes += r.uniformUpdateBytes;
memTextures += r.memTextures;
memBuffers += r.memBuffers;
memIndexBuffers += r.memIndexBuffers;
memVertexBuffers += r.memVertexBuffers;
memUniformBuffers += r.memUniformBuffers;
stencilClears += r.stencilClears;
stencilUpdates += r.stencilUpdates;
return *this;
}
#if !defined(NDEBUG)
std::string RenderingStats::toString(std::string_view sep) const {
std::stringstream ss;
ss << "numFrames = " << numFrames << sep << "numDrawCalls = " << numDrawCalls << sep
<< "totalDrawCalls = " << totalDrawCalls << sep << "numCreatedTextures = " << numCreatedTextures << sep
<< "numActiveTextures = " << numActiveTextures << sep << "numTextureBindings = " << numTextureBindings << sep
<< "numTextureUpdates = " << numTextureUpdates << sep << "textureUpdateBytes = " << textureUpdateBytes << sep
<< "numBuffers = " << numBuffers << sep << "numFrameBuffers = " << numFrameBuffers << sep
<< "numIndexBuffers = " << numIndexBuffers << sep << "indexUpdateBytes = " << indexUpdateBytes << sep
<< "numVertexBuffers = " << numVertexBuffers << sep << "vertexUpdateBytes = " << vertexUpdateBytes << sep
<< "numUniformBuffers = " << numUniformBuffers << sep << "numUniformUpdates = " << numUniformUpdates << sep
<< "uniformUpdateBytes = " << uniformUpdateBytes << sep << "memTextures = " << memTextures << sep
<< "memBuffers = " << memBuffers << sep << "memIndexBuffers = " << memIndexBuffers << sep
<< "memVertexBuffers = " << memVertexBuffers << sep << "memUniformBuffers = " << memUniformBuffers << sep
<< "stencilClears = " << stencilClears << sep << "stencilUpdates = " << stencilUpdates << sep;
return ss.str();
}
#endif
} // namespace gfx
} // namespace mbgl
} // namespace mbgl

View File

@@ -63,14 +63,17 @@ static_assert(underlying_type(UniformDataType::FloatMat4) == GL_FLOAT_MAT4, "Ope
static_assert(underlying_type(UniformDataType::Sampler2D) == GL_SAMPLER_2D, "OpenGL type mismatch");
static_assert(underlying_type(UniformDataType::SamplerCube) == GL_SAMPLER_CUBE, "OpenGL type mismatch");
namespace {
GLint getMaxVertexAttribs() {
GLint value = 0;
MBGL_CHECK_ERROR(glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &value));
return value;
}
} // namespace
Context::Context(RendererBackend& backend_)
: gfx::Context([] {
GLint value;
MBGL_CHECK_ERROR(glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &value));
return value;
}()),
backend(backend_),
stats() {}
: gfx::Context(/*maximumVertexBindingCount=*/getMaxVertexAttribs()),
backend(backend_) {}
Context::~Context() noexcept {
if (cleanupOnDestruction) {
@@ -616,14 +619,6 @@ std::unique_ptr<gfx::CommandEncoder> Context::createCommandEncoder() {
return std::make_unique<gl::CommandEncoder>(*this);
}
gfx::RenderingStats& Context::renderingStats() {
return stats;
}
const gfx::RenderingStats& Context::renderingStats() const {
return stats;
}
void Context::finish() {
MBGL_CHECK_ERROR(glFinish());
}

View File

@@ -44,9 +44,6 @@ public:
std::unique_ptr<gfx::CommandEncoder> createCommandEncoder() override;
gfx::RenderingStats& renderingStats();
const gfx::RenderingStats& renderingStats() const override;
void initializeExtensions(const std::function<gl::ProcAddress(const char*)>&);
void enableDebugging();
@@ -131,7 +128,6 @@ private:
RendererBackend& backend;
bool cleanupOnDestruction = true;
gfx::RenderingStats stats;
std::unique_ptr<extension::Debugging> debugging;
public:

View File

@@ -20,6 +20,16 @@ UniformBufferGL::UniformBufferGL(const void* data_, std::size_t size_)
MBGL_CHECK_ERROR(glBindBuffer(GL_UNIFORM_BUFFER, 0));
}
UniformBufferGL::UniformBufferGL(const UniformBufferGL& other)
: UniformBuffer(other),
hash(other.hash) {
MBGL_CHECK_ERROR(glGenBuffers(1, &id));
MBGL_CHECK_ERROR(glCopyBufferSubData(other.id, id, 0, 0, size));
MBGL_CHECK_ERROR(glBindBuffer(GL_COPY_READ_BUFFER, other.id));
MBGL_CHECK_ERROR(glBindBuffer(GL_COPY_WRITE_BUFFER, id));
MBGL_CHECK_ERROR(glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, size));
}
UniformBufferGL::~UniformBufferGL() {
if (id) {
MBGL_CHECK_ERROR(glDeleteBuffers(1, &id));

View File

@@ -1,37 +1,52 @@
#include <mbgl/mtl/buffer_resource.hpp>
#include <mbgl/mtl/context.hpp>
#include <mbgl/mtl/renderer_backend.hpp>
#include <Metal/MTLDevice.hpp>
#include <algorithm>
namespace mbgl {
namespace mtl {
BufferResource::BufferResource(MTLDevicePtr device_, const void* data, std::size_t size, MTL::ResourceOptions usage_)
: device(std::move(device_)),
BufferResource::BufferResource(Context& context_, const void* data, std::size_t size_, MTL::ResourceOptions usage_)
: context(context_),
size(static_cast<NS::UInteger>(size_)),
usage(usage_) {
if (data && size) {
buffer = NS::TransferPtr(device->newBuffer(data, static_cast<NS::UInteger>(size), usage));
} else {
buffer = NS::TransferPtr(device->newBuffer(static_cast<NS::UInteger>(size), usage));
}
}
BufferResource::BufferResource(const BufferResource& other)
: device(other.device),
usage(other.usage) {
if (other.buffer) {
buffer = NS::TransferPtr(device->newBuffer(other.buffer->contents(), other.buffer->length(), other.usage));
auto& device = context.getBackend().getDevice();
buffer = NS::TransferPtr((data && size) ? device->newBuffer(data, size, usage) : device->newBuffer(size, usage));
if (buffer) {
context.renderingStats().numBuffers++;
context.renderingStats().memBuffers += size;
}
}
BufferResource::BufferResource(BufferResource&& other)
: device(std::move(other.device)),
: context(other.context),
buffer(std::move(other.buffer)),
size(other.size),
usage(other.usage) {}
BufferResource::~BufferResource() {
if (buffer) {
context.renderingStats().numBuffers--;
context.renderingStats().memBuffers -= size;
}
}
BufferResource BufferResource::clone() const {
return {context, buffer->contents(), size, usage};
}
BufferResource& BufferResource::operator=(BufferResource&& other) {
device = std::move(other.device);
assert(&context == &other.context);
if (buffer) {
context.renderingStats().numBuffers--;
context.renderingStats().memBuffers -= size;
}
buffer = std::move(other.buffer);
size = other.size;
usage = other.usage;
return *this;
}

View File

@@ -12,6 +12,7 @@
#include <mbgl/mtl/render_pass.hpp>
#include <mbgl/mtl/uniform_buffer.hpp>
#include <mbgl/mtl/upload_pass.hpp>
#include <mbgl/mtl/vertex_buffer_resource.hpp>
#include <mbgl/programs/program_parameters.hpp>
#include <mbgl/renderer/paint_parameters.hpp>
#include <mbgl/renderer/render_static_data.hpp>
@@ -37,12 +38,24 @@ constexpr uint32_t maximumVertexBindingCount = 31;
Context::Context(RendererBackend& backend_)
: gfx::Context(mtl::maximumVertexBindingCount),
backend(backend_),
stats() {}
backend(backend_) {}
Context::~Context() noexcept {
if (cleanupOnDestruction) {
performCleanup();
emptyVertexBuffer.reset();
tileVertexBuffer.reset();
tileIndexBuffer.reset();
clipMaskShader.reset();
clipMaskDepthStencilState.reset();
clipMaskPipelineState.reset();
clipMaskUniformsBuffer.reset();
stencilStateRenderable = nullptr;
#if !defined(NDEBUG)
Log::Debug(Event::General, "Rendering Stats:\n" + stats.toString("\n"));
#endif
assert(stats.isZero());
}
}
@@ -52,7 +65,7 @@ std::unique_ptr<gfx::CommandEncoder> Context::createCommandEncoder() {
}
BufferResource Context::createBuffer(const void* data, std::size_t size, gfx::BufferUsageType) const {
return {backend.getDevice(), data, size, MTL::ResourceStorageModeShared};
return {const_cast<Context&>(*this), data, size, MTL::ResourceStorageModeShared};
}
UniqueShaderProgram Context::createProgram(std::string name,
@@ -144,6 +157,11 @@ MTLSamplerStatePtr Context::createMetalSamplerState(MTLSamplerDescriptorPtr samp
return NS::TransferPtr(backend.getDevice()->newSamplerState(samplerDescriptor.get()));
}
void Context::clear() {
stats.numDrawCalls = 0;
stats.numFrames++;
}
void Context::performCleanup() {
clipMaskUniformsBufferUsed = false;
}
@@ -207,6 +225,20 @@ const BufferResource& Context::getTileIndexBuffer() {
return *tileIndexBuffer;
}
const gfx::UniqueVertexBufferResource& Context::getEmptyVertexBuffer() {
if (!emptyVertexBuffer) {
// This buffer is bound to vertex attribtue indexes when the uniforms are used instead and
// shaders are expected not to access the attribute values, but Metal requires a binding.
// This buffer could also hold a single default value applied for all vertices, in which case
// it could not be shared (See `MTL::VertexStepFunctionConstant` in the vertex attribute
// descriptors, but that isn't currently being used.
constexpr std::size_t size = 32;
constexpr auto usage = gfx::BufferUsageType::StaticDraw;
emptyVertexBuffer = std::make_unique<VertexBufferResource>(createBuffer(nullptr, size, usage));
}
return emptyVertexBuffer;
}
namespace {
const auto clipMaskStencilMode = gfx::StencilMode{
/*.test=*/gfx::StencilMode::Always(),
@@ -316,16 +348,16 @@ bool Context::renderTileClippingMasks(gfx::RenderPass& renderPass,
constexpr auto uboSize = sizeof(shaders::ClipUBO);
const auto bufferSize = tileUBOs.size() * uboSize;
BufferResource tempBuffer;
std::optional<BufferResource> tempBuffer;
auto& uboBuffer = clipMaskUniformsBufferUsed ? tempBuffer : clipMaskUniformsBuffer;
clipMaskUniformsBufferUsed = true;
if (!uboBuffer || uboBuffer.getSizeInBytes() < bufferSize) {
if (!uboBuffer || !*uboBuffer || uboBuffer->getSizeInBytes() < bufferSize) {
uboBuffer = createBuffer(tileUBOs.data(), bufferSize, gfx::BufferUsageType::StaticDraw);
if (!uboBuffer) {
return false;
}
} else {
uboBuffer.update(tileUBOs.data(), bufferSize, /*offset=*/0);
uboBuffer->update(tileUBOs.data(), bufferSize, /*offset=*/0);
}
encoder->setCullMode(MTL::CullModeNone);
@@ -350,7 +382,7 @@ bool Context::renderTileClippingMasks(gfx::RenderPass& renderPass,
for (std::size_t ii = 0; ii < tileUBOs.size(); ++ii) {
encoder->setStencilReferenceValue(tileUBOs[ii].stencil_ref);
encoder->setVertexBuffer(
uboBuffer.getMetalBuffer().get(), /*offset=*/ii * uboSize, ShaderClass::uniforms[0].index);
uboBuffer->getMetalBuffer().get(), /*offset=*/ii * uboSize, ShaderClass::uniforms[0].index);
encoder->drawIndexedPrimitives(MTL::PrimitiveType::PrimitiveTypeTriangle,
indexCount,
MTL::IndexType::IndexTypeUInt16,
@@ -362,6 +394,8 @@ bool Context::renderTileClippingMasks(gfx::RenderPass& renderPass,
}
#endif
stats.numDrawCalls++;
stats.totalDrawCalls++;
return true;
}

View File

@@ -157,7 +157,7 @@ void Drawable::draw(PaintParameters& parameters) const {
return;
}
const auto& context = static_cast<Context&>(parameters.context);
auto& context = static_cast<Context&>(parameters.context);
const auto& renderPass = static_cast<RenderPass&>(*parameters.renderPass);
const auto& encoder = renderPass.getMetalEncoder();
if (!encoder) {
@@ -289,8 +289,8 @@ void Drawable::draw(PaintParameters& parameters) const {
if (binding) {
if (const auto buffer = getMetalBuffer(binding ? binding->vertexBufferResource : nullptr)) {
assert((maxIndex + mlSegment.vertexOffset) * binding->vertexStride <= buffer->length());
} else if (const auto buffer = getMetalBuffer(impl->noBindingBuffer.get())) {
assert(binding->vertexStride <= buffer->length());
} else if (impl->noBindingBuffer) {
assert(binding->vertexStride <= impl->noBindingBuffer->length());
}
}
}
@@ -304,6 +304,7 @@ void Drawable::draw(PaintParameters& parameters) const {
instanceCount,
baseVertex,
baseInstance);
context.renderingStats().numDrawCalls++;
}
}
@@ -371,8 +372,8 @@ void Drawable::bindAttributes(const RenderPass& renderPass) const {
if (const auto buffer = getMetalBuffer(binding ? binding->vertexBufferResource : nullptr)) {
assert(binding->vertexStride * impl->vertexCount <= getBufferSize(binding->vertexBufferResource));
encoder->setVertexBuffer(buffer, /*offset=*/0, attributeIndex);
} else if (const auto buffer = getMetalBuffer(impl->noBindingBuffer.get())) {
encoder->setVertexBuffer(buffer, /*offset=*/0, attributeIndex);
} else if (impl->noBindingBuffer) {
encoder->setVertexBuffer(impl->noBindingBuffer, /*offset=*/0, attributeIndex);
}
attributeIndex += 1;
}
@@ -593,8 +594,9 @@ void Drawable::upload(gfx::UploadPass& uploadPass_) {
}
if (!binding->vertexBufferResource && !impl->noBindingBuffer) {
impl->noBindingBuffer = uploadPass.createVertexBufferResource(
nullptr, 64, gfx::BufferUsageType::StaticDraw);
if (const auto& buf = context.getEmptyVertexBuffer()) {
impl->noBindingBuffer = getMetalBuffer(buf.get());
}
}
auto attribDesc = NS::TransferPtr(MTL::VertexAttributeDescriptor::alloc()->init());

View File

@@ -55,7 +55,7 @@ public:
// GLfloat pointSize = 0.0f;
StringIdentity idVertexAttrName = stringIndexer().get("a_pos");
gfx::UniqueVertexBufferResource noBindingBuffer;
MTL::Buffer* noBindingBuffer = nullptr;
gfx::AttributeBindingArray attributeBindings;

View File

@@ -0,0 +1,24 @@
#include <mbgl/mtl/index_buffer_resource.hpp>
#include <mbgl/mtl/context.hpp>
namespace mbgl {
namespace mtl {
IndexBufferResource::IndexBufferResource(BufferResource&& ptr)
: buffer(std::move(ptr)) {
if (buffer) {
buffer.getContext().renderingStats().numIndexBuffers++;
buffer.getContext().renderingStats().memIndexBuffers += buffer.getSizeInBytes();
}
}
IndexBufferResource::~IndexBufferResource() {
if (buffer) {
buffer.getContext().renderingStats().numIndexBuffers--;
buffer.getContext().renderingStats().memIndexBuffers -= buffer.getSizeInBytes();
}
}
} // namespace mtl
} // namespace mbgl

View File

@@ -44,9 +44,10 @@ public:
static_cast<Texture2D*>(stencilTexture.get())
->setUsage(MTL::TextureUsageShaderRead | MTL::TextureUsageShaderWrite | MTL::TextureUsageRenderTarget);
}
context.renderingStats().numFrameBuffers++;
}
~OffscreenTextureResource() noexcept override = default;
~OffscreenTextureResource() noexcept override { context.renderingStats().numFrameBuffers--; }
void bind() override {
assert(context.getBackend().getCommandQueue());

View File

@@ -47,6 +47,8 @@ RenderPass::RenderPass(CommandEncoder& commandEncoder_, const char* name, const
// Let the encoder pass along any groups pushed to it after this
commandEncoder.trackRenderPass(this);
commandEncoder.context.clear();
}
RenderPass::~RenderPass() {

View File

@@ -13,7 +13,12 @@ namespace mtl {
Texture2D::Texture2D(Context& context_)
: context(context_) {}
Texture2D::~Texture2D() {}
Texture2D::~Texture2D() {
if (metalTexture) {
context.renderingStats().numActiveTextures--;
context.renderingStats().memTextures -= getDataSize();
}
}
gfx::Texture2D& Texture2D::setSamplerConfiguration(const SamplerState& samplerState_) noexcept {
samplerState = samplerState_;
@@ -138,6 +143,8 @@ void Texture2D::createMetalTexture() noexcept {
if (metalTexture) {
textureDirty = false;
context.renderingStats().numCreatedTextures++;
context.renderingStats().numActiveTextures++;
context.renderingStats().memTextures += getDataSize();
}
}
@@ -190,12 +197,16 @@ void Texture2D::bind(const RenderPass& renderPass, int32_t location) noexcept {
encoder->setFragmentTexture(metalTexture.get(), location);
encoder->setFragmentSamplerState(metalSamplerState.get(), location);
context.renderingStats().numTextureBindings++;
}
void Texture2D::unbind(const RenderPass& renderPass, int32_t location) noexcept {
const auto& encoder = renderPass.getMetalEncoder();
encoder->setFragmentTexture(nullptr, location);
encoder->setFragmentSamplerState(nullptr, location);
context.renderingStats().numTextureBindings--;
}
void Texture2D::upload(const void* pixelData, const Size& size_) noexcept {
@@ -215,9 +226,11 @@ void Texture2D::uploadSubRegion(const void* pixelData, const Size& size_, uint16
assert(metalTexture.get());
assert(!textureDirty);
MTL::Region region = MTL::Region::Make2D(xOffset, yOffset, size_.width, size_.height);
NS::UInteger bytesPerRow = size_.width * getPixelStride();
const MTL::Region region = MTL::Region::Make2D(xOffset, yOffset, size_.width, size_.height);
const NS::UInteger bytesPerRow = size_.width * getPixelStride();
metalTexture->replaceRegion(region, 0, pixelData, bytesPerRow);
context.renderingStats().numTextureUpdates++;
context.renderingStats().textureUpdateBytes += bytesPerRow * size_.height;
}
void Texture2D::upload() noexcept {

View File

@@ -1,5 +1,6 @@
#include <mbgl/mtl/uniform_buffer.hpp>
#include <mbgl/mtl/context.hpp>
#include <mbgl/util/logging.hpp>
#include <cassert>
@@ -9,11 +10,20 @@ namespace mtl {
UniformBuffer::UniformBuffer(BufferResource&& buffer_)
: gfx::UniformBuffer(buffer_.getSizeInBytes()),
buffer(std::move(buffer_)) {}
buffer(std::move(buffer_)) {
buffer.getContext().renderingStats().numUniformBuffers++;
buffer.getContext().renderingStats().memUniformBuffers += size;
}
UniformBuffer::UniformBuffer(UniformBuffer&& other)
: gfx::UniformBuffer(std::move(other)),
buffer(std::move(other.buffer)) {}
UniformBuffer::~UniformBuffer() {
buffer.getContext().renderingStats().numUniformBuffers--;
buffer.getContext().renderingStats().memUniformBuffers -= size;
}
void UniformBuffer::update(const void* data, std::size_t size_) {
assert(size == size_);
if (size != size_ || size != buffer.getSizeInBytes()) {
@@ -23,6 +33,8 @@ void UniformBuffer::update(const void* data, std::size_t size_) {
return;
}
buffer.getContext().renderingStats().numUniformUpdates++;
buffer.getContext().renderingStats().uniformUpdateBytes += size_;
buffer.update(data, size, /*offset=*/0);
}

View File

@@ -0,0 +1,24 @@
#include <mbgl/mtl/vertex_buffer_resource.hpp>
#include <mbgl/mtl/context.hpp>
namespace mbgl {
namespace mtl {
VertexBufferResource::VertexBufferResource(BufferResource&& ptr)
: buffer(std::move(ptr)) {
if (buffer) {
buffer.getContext().renderingStats().numVertexBuffers++;
buffer.getContext().renderingStats().memVertexBuffers += buffer.getSizeInBytes();
}
}
VertexBufferResource::~VertexBufferResource() {
if (buffer) {
buffer.getContext().renderingStats().numVertexBuffers--;
buffer.getContext().renderingStats().memVertexBuffers -= buffer.getSizeInBytes();
}
}
} // namespace mtl
} // namespace mbgl

View File

@@ -158,6 +158,7 @@ void PaintParameters::clearStencil() {
0,
0}};
mtlContext.renderTileClippingMasks(*renderPass, staticData, tileUBO);
context.renderingStats().stencilClears++;
#else // !MLN_RENDER_BACKEND_METAL
context.clearStencilBuffer(0b00000000);
#endif
@@ -231,6 +232,8 @@ void PaintParameters::renderTileClippingMasks(TIter beg, TIter end, GetTileIDFun
auto& mtlContext = static_cast<mtl::Context&>(context);
mtlContext.renderTileClippingMasks(*renderPass, staticData, tileUBOs);
mtlContext.renderingStats().stencilUpdates++;
}
#else // !MLN_RENDER_BACKEND_METAL

View File

@@ -136,7 +136,7 @@ RenderOrchestrator::~RenderOrchestrator() {
layer.markContextDestroyed();
}
}
};
}
void RenderOrchestrator::setObserver(RendererObserver* observer_) {
observer = observer_ ? observer_ : &nullObserver();