Function ApplyBarriers

layers/sync/sync_access_state.cpp:785–824

}

void ApplyBarriers(AccessState& access_state, const std::vector<SyncBarrier>& barriers, bool layout_transition,
                   ResourceUsageTag layout_transition_tag) {
    // The common case of a single barrier.
    // The pending barrier helper is unnecessary because there are no independent barriers to track.
    // The barrier can be applied directly to the access state.
    if (barriers.size() == 1) {
        access_state.ApplyBarrier(BarrierScope(barriers[0]), barriers[0], layout_transition, vvl::kNoIndex32,
                                  layout_transition_tag);
        return;
    }

    PendingBarriers pending_barriers;
    if (layout_transition) {
        // When layout transition is bundled with multiple barriers (e.g. multiple subpass dependencies
        // can be associated with the same layout transition) we need to ensure that AddLayoutTransition()
        // is called only once (it resets write state including applied barriers). That's the reason
        // CollectPendingBarriers can't be used in this scenario.
        // NOTE: CollectPendingBarriers works correctly for a common case when layout transition is defined
        // by a single barrier
        OrderingBarrier layout_ordering_barrier;
        for (const SyncBarrier& barrier : barriers) {
            layout_ordering_barrier.exec_scope |= barrier.src_exec_scope.exec_scope;
            layout_ordering_barrier.access_scope |= barrier.src_access_scope;
        }
        pending_barriers.AddLayoutTransition(&access_state, layout_ordering_barrier, vvl::kNoIndex32);

        for (const SyncBarrier& barrier : barriers) {
            pending_barriers.AddWriteBarrier(&access_state, barrier);
        }
    } else {
        // There are multiple barriers. We can't apply them sequentially because they can form dependencies
        // between themselves (result of the previous barrier might affect application of the next barrier).
        // The APIs we are dealing require that the barriers in a set of barriers are applied independently.
        // That's the intended use case of PendingBarriers helper.
        for (const SyncBarrier& barrier : barriers) {
            access_state.CollectPendingBarriers(BarrierScope(barrier), barrier, false, vvl::kNoIndex32, pending_barriers);
        }
    }
    pending_barriers.Apply(layout_transition_tag);
}

BarrierScope::BarrierScope(const SyncBarrier& barrier, QueueId scope_queue, ResourceUsageTag scope_tag)
    : src_exec_scope(barrier.src_exec_scope.exec_scope),