chromium/third_party/angle/src/libANGLE/renderer/vulkan/vk_ref_counted_event.cpp

//
// Copyright 2024 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// RefCountedEvent:
//    Manages reference count of VkEvent and its associated functions.
//

#include "libANGLE/renderer/vulkan/vk_ref_counted_event.h"
#include "libANGLE/renderer/vulkan/vk_helpers.h"
#include "libANGLE/renderer/vulkan/vk_renderer.h"

namespace rx
{
namespace vk
{
namespace
{
// Predefined VkPipelineStageFlags for RefCountedEvent
constexpr angle::PackedEnumMap<EventStage, VkPipelineStageFlags>
    kEventStageAndPipelineStageFlagsMap = …;

void DestroyRefCountedEvents(VkDevice device, RefCountedEventCollector &events)
{ … }
}  // namespace

void InitializeEventAndPipelineStagesMap(
    angle::PackedEnumMap<EventStage, VkPipelineStageFlags> *map,
    VkPipelineStageFlags supportedVulkanPipelineStageMask)
{ … }

bool RefCountedEvent::init(Context *context, EventStage eventStage)
{ … }

void RefCountedEvent::release(Context *context)
{ … }

void RefCountedEvent::release(Renderer *renderer)
{ … }

template <typename RecyclerT>
void RefCountedEvent::releaseImpl(Renderer *renderer, RecyclerT *recycler)
{ … }

void RefCountedEvent::destroy(VkDevice device)
{ … }

// RefCountedEventsGarbage implementation.
void RefCountedEventsGarbage::destroy(Renderer *renderer)
{ … }

bool RefCountedEventsGarbage::releaseIfComplete(Renderer *renderer,
                                                RefCountedEventsGarbageRecycler *recycler)
{ … }

bool RefCountedEventsGarbage::moveIfComplete(Renderer *renderer,
                                             std::deque<RefCountedEventCollector> *releasedBucket)
{ … }

// RefCountedEventRecycler implementation.
void RefCountedEventRecycler::destroy(VkDevice device)
{ … }

void RefCountedEventRecycler::resetEvents(Context *context,
                                          const QueueSerial queueSerial,
                                          PrimaryCommandBuffer *commandbuffer)
{ … }

void RefCountedEventRecycler::cleanupResettingEvents(Renderer *renderer)
{ … }

bool RefCountedEventRecycler::fetchEventsToReuse(RefCountedEventCollector *eventsToReuseOut)
{ … }

// RefCountedEventsGarbageRecycler implementation.
RefCountedEventsGarbageRecycler::~RefCountedEventsGarbageRecycler()
{ … }

void RefCountedEventsGarbageRecycler::destroy(Renderer *renderer)
{ … }

void RefCountedEventsGarbageRecycler::cleanup(Renderer *renderer)
{ … }

bool RefCountedEventsGarbageRecycler::fetch(Renderer *renderer, RefCountedEvent *outObject)
{ … }

// EventBarrier implementation.
void EventBarrier::addDiagnosticsString(std::ostringstream &out) const
{ … }

void EventBarrier::execute(PrimaryCommandBuffer *primary)
{ … }

// EventBarrierArray implementation.
void EventBarrierArray::addAdditionalStageAccess(const RefCountedEvent &waitEvent,
                                                 VkPipelineStageFlags dstStageMask,
                                                 VkAccessFlags dstAccess)
{ … }

void EventBarrierArray::addMemoryEvent(Renderer *renderer,
                                       const RefCountedEvent &waitEvent,
                                       VkPipelineStageFlags dstStageMask,
                                       VkAccessFlags dstAccess)
{ … }

void EventBarrierArray::addImageEvent(Renderer *renderer,
                                      const RefCountedEvent &waitEvent,
                                      VkPipelineStageFlags dstStageMask,
                                      const VkImageMemoryBarrier &imageMemoryBarrier)
{ … }

void EventBarrierArray::execute(Renderer *renderer, PrimaryCommandBuffer *primary)
{ … }

void EventBarrierArray::addDiagnosticsString(std::ostringstream &out) const
{ … }
}  // namespace vk
}  // namespace rx