Method execute

src/utils/impl_task_graph.cpp:3319–4014

    }

    void TaskGraph::execute([[maybe_unused]] ExecutionInfo const & info)
    {
        auto & impl = *r_cast<ImplTaskGraph *>(this->object);
        DAXA_DBG_ASSERT_TRUE_M(impl.compiled, "ERROR: TaskGraph must be completed before execution!");

        std::array<u8, 1u << 16u> tmp_stack_mem;
        MemoryArena tmp_memory = MemoryArena{"TaskGraph::execute tmp memory", tmp_stack_mem};

        /// =============================================================================
        /// ==== VALIDATE, PATCH AND GENERATE CONNECTING SYNC FOR EXTERNAL RESOURCES ====
        /// =============================================================================

        // External resources can be changed outside of the taskgraph.
        // Calculate required sync from the pre graph access to the first access of external resources here.
        // Validate all external resources: Are the ids valid? Do the resources match the access requirements?
        // Update ids and data of the external resource inside taskgraph.
        // If the id changed, patch attachment blobs and recreate image views for tasks accessing the resource.
        // All image views and attachment blobs are pre-created and kept between executions.
        // Only patch the outdated parts of attachment blobs and image view arrays when a external resource changed.

        // Memory and exeuction dependencies are done via semaphores.
        // Only image initializations require additional pipeline barriers.
        // Image initialization is inserted in the first submit for the queue that uses the image, before all other commands.
        auto image_initializations = tmp_memory.allocate_trivial_span<std::array<ArenaDynamicArray8k<TaskBarrier>, DAXA_QUEUE_COUNT>>(impl.submits.size());
        for (u32 s = 0; s < impl.submits.size(); ++s)
        {
            for (u32 q = 0; q < DAXA_QUEUE_COUNT; ++q)
            {
                image_initializations[s][q] = ArenaDynamicArray8k<TaskBarrier>(&tmp_memory);
            }
        }

        // Taskgraph performs a full barrier between all queues it uses at every submit.
        // Task graph finds all queues exterbal resources were used on prior to its exection.
        // It then constructs a dependency which synchronizes all queues found in the previous step with all queues used by this taskgraph.
        // This synchronization waits on all previously recorded commands to finish before any commands from this taskgraph are executed.
        u32 external_resource_queue_bits = {};

        // Validate the swapchain image we use was not yet presented to
        if (impl.swapchain_image)
        {
            bool const swapchain_image_unused = impl.swapchain_image->access_timeline.size() == 0 && !impl.present.has_value();
            DAXA_DBG_ASSERT_TRUE_M(!impl.swapchain_image->external->was_presented || swapchain_image_unused, "ERROR: The swapchain image was already presented to and can not be used in actions of this graph!");
        }

        // Validate and patch external resources
        for (u32 er = 0; er < impl.external_resources.size(); ++er)
        {
            auto [resource, resource_i] = impl.external_resources[er];

            DAXA_DBG_ASSERT_TRUE_M(resource->external != nullptr, "IMPOSSIBLE CASE, POSSIBLY CAUSED BY DATA CORRUPTION!");

            // Skip unused resources
            if (resource->access_timeline.size() == 0)
            {
                continue;
            }