Method ApplyMultipleBarriers

layers/sync/sync_op.cpp:453–529

}

void SyncOpPipelineBarrier::ApplyMultipleBarriers(CommandExecutionContext& exec_context, ResourceUsageTag exec_tag) const {
    AccessContext& access_context = exec_context.GetCurrentAccessContext();
    const QueueId queue_id = exec_context.GetQueueId();

    // Apply markup action.
    // The markup action does not change any access state but it can trim the access map according to the
    // provided range and creates infill ranges if necessary (for layout transitions). The purpose of all
    // this is to ensure that after markup action the topology of access map ranges is finalized so we can
    // safely cache pointers to specific access states with a goal to apply pending barriers in the end.
    //
    // NOTE: it is enough to apply markup action to buffer and image barriers. The global barriers
    // do not use infill operations (no layout transitions) and also do not split access map ranges
    // because global barriers are applied to the full range.
    for (const SyncBufferBarrier& barrier : barrier_set_.buffer_barriers) {
        if (SimpleBinding(*barrier.buffer)) {
            const VkDeviceSize base_address = ResourceBaseAddress(*barrier.buffer);
            const AccessRange range = barrier.range + base_address;
            ApplyMarkupFunctor markup_action(false);
            access_context.UpdateMemoryAccessState(markup_action, range);
        }
    }
    for (const SyncImageBarrier& barrier : barrier_set_.image_barriers) {
        const auto& sub_state = SubState(*barrier.image);
        const bool can_transition_depth_slices = CanTransitionDepthSlices(
            exec_context.GetSyncState().extensions, sub_state.base.GetImageType(), sub_state.base.create_flags);
        auto range_gen = sub_state.MakeImageRangeGen(barrier.subresource_range, can_transition_depth_slices);
        // TODO: check if we need: barrier.layout_transition && (queue_id == kQueueIdInvalid)
        ApplyMarkupFunctor markup_action(barrier.layout_transition);
        access_context.UpdateMemoryAccessState(markup_action, range_gen);
    }

    // Use PendingBarriers to collect barriers that must be applied independently
    PendingBarriers pending_barriers;
    for (const SyncBufferBarrier& barrier : barrier_set_.buffer_barriers) {
        if (SimpleBinding(*barrier.buffer)) {
            const BarrierScope barrier_scope(barrier.barrier, queue_id);
            CollectBarriersFunctor collect_barriers(access_context, barrier_scope, barrier.barrier, false, vvl::kNoIndex32,
                                                    pending_barriers);

            const VkDeviceSize base_address = ResourceBaseAddress(*barrier.buffer);
            const AccessRange range = barrier.range + base_address;

            access_context.UpdateMemoryAccessState(collect_barriers, range);
        }
    }
    for (const SyncImageBarrier& barrier : barrier_set_.image_barriers) {
        const BarrierScope barrier_scope(barrier.barrier, queue_id);
        CollectBarriersFunctor collect_barriers(access_context, barrier_scope, barrier.barrier, barrier.layout_transition,
                                                barrier.handle_index, pending_barriers);

        const auto& sub_state = SubState(*barrier.image);
        const bool can_transition_depth_slices = CanTransitionDepthSlices(
            exec_context.GetSyncState().extensions, sub_state.base.GetImageType(), sub_state.base.create_flags);
        auto range_gen = sub_state.MakeImageRangeGen(barrier.subresource_range, can_transition_depth_slices);

        access_context.UpdateMemoryAccessState(collect_barriers, range_gen);
    }