chromium/third_party/skia/src/gpu/graphite/BufferManager.cpp

/*
 * Copyright 2021 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "src/gpu/graphite/BufferManager.h"

#include "include/gpu/graphite/Recording.h"
#include "src/gpu/graphite/Caps.h"
#include "src/gpu/graphite/ContextPriv.h"
#include "src/gpu/graphite/Log.h"
#include "src/gpu/graphite/QueueManager.h"
#include "src/gpu/graphite/RecordingPriv.h"
#include "src/gpu/graphite/ResourceProvider.h"
#include "src/gpu/graphite/SharedContext.h"
#include "src/gpu/graphite/UploadBufferManager.h"
#include "src/gpu/graphite/task/ClearBuffersTask.h"
#include "src/gpu/graphite/task/CopyTask.h"
#include "src/gpu/graphite/task/TaskList.h"

#include <limits>

namespace skgpu::graphite {

namespace {

// TODO: Tune these values on real world data
static constexpr uint32_t kVertexBufferSize = …; // 16 KB
static constexpr uint32_t kIndexBufferSize   = …; //  2 KB
static constexpr uint32_t kUniformBufferSize = …; //  2 KB
static constexpr uint32_t kStorageBufferSize = …; //  2 KB

// The limit for all data created by the StaticBufferManager. This data remains alive for
// the entire SharedContext so we want to keep it small and give a concrete upper bound to
// clients for our steady-state memory usage.
// FIXME The current usage is 4732 bytes across static vertex and index buffers, but that includes
// multiple copies of tessellation data, and an unoptimized AnalyticRRect mesh. Once those issues
// are addressed, we can tighten this and decide on the transfer buffer sizing as well.
[[maybe_unused]] static constexpr uint32_t kMaxStaticDataSize = …;

uint32_t validate_count_and_stride(size_t count, size_t stride) { … }

uint32_t validate_size(size_t requiredBytes) { … }

uint32_t sufficient_block_size(uint32_t requiredBytes, uint32_t blockSize) { … }

bool can_fit(uint32_t requestedSize,
             uint32_t allocatedSize,
             uint32_t currentOffset,
             uint32_t alignment) { … }

uint32_t starting_alignment(BufferType type, bool useTransferBuffers, const Caps* caps) { … }

} // anonymous namespace

// ------------------------------------------------------------------------------------------------
// ScratchBuffer

ScratchBuffer::ScratchBuffer(uint32_t size, uint32_t alignment,
                             sk_sp<Buffer> buffer, DrawBufferManager* owner)
        : … { … }

ScratchBuffer::~ScratchBuffer() { … }

BindBufferInfo ScratchBuffer::suballocate(size_t requiredBytes) { … }

void ScratchBuffer::returnToPool() { … }

// ------------------------------------------------------------------------------------------------
// DrawBufferManager

DrawBufferManager::DrawBufferManager(ResourceProvider* resourceProvider,
                                     const Caps* caps,
                                     UploadBufferManager* uploadManager)
        : … { … }

DrawBufferManager::~DrawBufferManager() { … }

// For simplicity, if transfer buffers are being used, we align the data to the max alignment of
// either the final buffer type or cpu->gpu transfer alignment so that the buffers are laid out
// the same in memory.
DrawBufferManager::BufferInfo::BufferInfo(BufferType type, uint32_t blockSize, const Caps* caps)
        : … { … }

std::pair<VertexWriter, BindBufferInfo> DrawBufferManager::getVertexWriter(size_t count,
                                                                           size_t stride) { … }

void DrawBufferManager::returnVertexBytes(size_t unusedBytes) { … }

std::pair<IndexWriter, BindBufferInfo> DrawBufferManager::getIndexWriter(size_t count,
                                                                         size_t stride) { … }

std::pair<UniformWriter, BindBufferInfo> DrawBufferManager::getUniformWriter(size_t count,
                                                                             size_t stride) { … }

std::pair<UniformWriter, BindBufferInfo> DrawBufferManager::getSsboWriter(size_t count,
                                                                          size_t stride) { … }

std::pair<void* /*mappedPtr*/, BindBufferInfo> DrawBufferManager::getUniformPointer(
            size_t requiredBytes) { … }

std::pair<void* /*mappedPtr*/, BindBufferInfo> DrawBufferManager::getStoragePointer(
        size_t requiredBytes) { … }

BindBufferInfo DrawBufferManager::getStorage(size_t requiredBytes, ClearBuffer cleared) { … }

BindBufferInfo DrawBufferManager::getVertexStorage(size_t requiredBytes) { … }

BindBufferInfo DrawBufferManager::getIndexStorage(size_t requiredBytes) { … }

BindBufferInfo DrawBufferManager::getIndirectStorage(size_t requiredBytes, ClearBuffer cleared) { … }

ScratchBuffer DrawBufferManager::getScratchStorage(size_t requiredBytes) { … }

void DrawBufferManager::onFailedBuffer() { … }

bool DrawBufferManager::transferToRecording(Recording* recording) { … }

std::pair<void*, BindBufferInfo> DrawBufferManager::prepareMappedBindBuffer(
        BufferInfo* info,
        uint32_t requiredBytes,
        std::string_view label) { … }

BindBufferInfo DrawBufferManager::prepareBindBuffer(BufferInfo* info,
                                                    uint32_t requiredBytes,
                                                    std::string_view label,
                                                    bool supportCpuUpload,
                                                    ClearBuffer cleared) { … }

sk_sp<Buffer> DrawBufferManager::findReusableSbo(size_t bufferSize) { … }

// ------------------------------------------------------------------------------------------------
// StaticBufferManager

StaticBufferManager::StaticBufferManager(ResourceProvider* resourceProvider,
                                         const Caps* caps)
        : … { … }
StaticBufferManager::~StaticBufferManager() = default;

StaticBufferManager::BufferInfo::BufferInfo(BufferType type, const Caps* caps)
        : … { … }

VertexWriter StaticBufferManager::getVertexWriter(size_t size, BindBufferInfo* binding) { … }

VertexWriter StaticBufferManager::getIndexWriter(size_t size, BindBufferInfo* binding) { … }

void* StaticBufferManager::prepareStaticData(BufferInfo* info,
                                             size_t size,
                                             BindBufferInfo* target) { … }

bool StaticBufferManager::BufferInfo::createAndUpdateBindings(
        ResourceProvider* resourceProvider,
        Context* context,
        QueueManager* queueManager,
        GlobalCache* globalCache,
        std::string_view label) const { … }

StaticBufferManager::FinishResult StaticBufferManager::finalize(Context* context,
                                                                QueueManager* queueManager,
                                                                GlobalCache* globalCache) { … }

} // namespace skgpu::graphite