Method DoValidate

layers/sync/sync_op.cpp:654–715

}

bool SyncOpWaitEvents::DoValidate(const CommandExecutionContext& exec_context, const ResourceUsageTag base_tag) const {
    bool skip = false;
    const auto& sync_state = exec_context.GetSyncState();
    const QueueId queue_id = exec_context.GetQueueId();

    const SyncEventsContext& events_context = exec_context.GetEventsContext();
    size_t barrier_set_index = 0;
    size_t barrier_set_incr = (barrier_sets_.size() == 1) ? 0 : 1;
    const Location loc(command_);
    for (const auto& event : events_) {
        const auto* sync_event = events_context.Get(event);
        const auto& barrier_set = barrier_sets_[barrier_set_index];
        if (!sync_event || !sync_event->first_scope) {
            barrier_set_index += barrier_set_incr;
            continue;  // Core, Lifetimes, or Param check needs to catch invalid events.
        }

        // For replay calls, don't revalidate "same command buffer" events
        if (sync_event->last_command_tag >= base_tag) {
            continue;
        }

        const VkEvent event_handle = sync_event->event->VkHandle();

        // TODO: Cleanup this error message
        if (sync_event->unsynchronized_set != vvl::Func::Empty) {
            // Issue error message that Wait is waiting on an signal subject to race condition, and is thus ignored for
            // this event
            const char* const vuid = "SYNC-vkCmdWaitEvents-unsynchronized-setops";
            const char* const message = "%s Unsychronized %s calls result in race conditions w.r.t. event signalling, %s %s";
            const char* const reason = "First synchronization scope is undefined.";
            skip |= sync_state.LogError(vuid, event_handle, loc, message, sync_state.FormatHandle(event_handle).c_str(),
                                        vvl::String(sync_event->last_command), reason, kIgnored);
        }
        if (barrier_set.image_barriers.size()) {
            const auto& image_memory_barriers = barrier_set.image_barriers;
            const AccessContext& context = exec_context.GetCurrentAccessContext();
            for (const auto& image_memory_barrier : image_memory_barriers) {
                if (!image_memory_barrier.layout_transition) continue;
                const auto* image_state = image_memory_barrier.image.get();
                if (!image_state) continue;
                const auto& subresource_range = image_memory_barrier.subresource_range;
                const auto& src_access_scope = image_memory_barrier.barrier.src_access_scope;
                const auto hazard = context.DetectImageBarrierHazard(
                    *image_state, subresource_range, sync_event->scope.exec_scope, src_access_scope, queue_id,
                    sync_event->FirstScope(), sync_event->first_scope_tag, AccessContext::DetectOptions::kDetectAll);
                if (hazard.IsHazard()) {
                    LogObjectList objlist(exec_context.Handle(), image_state->Handle());
                    const std::string resource_description = sync_state.FormatHandle(image_state->Handle());
                    const std::string error = sync_state.error_messages_.ImageBarrierError(
                        hazard, exec_context, command_, resource_description, image_memory_barrier);
                    skip |= sync_state.SyncError(hazard.Hazard(), image_state->Handle(), loc, error);
                    break;
                }
            }
        }
        // TODO:  Add infrastructure for checking pDependencyInfo's vs. CmdSetEvent2 VUID - vkCmdWaitEvents2KHR - pEvents -
        // 03839