collect_gpu_outputs()

template<ComputeData InputType = std::vector<Kakshya::DataVariant>, ComputeData OutputType = InputType>

virtual output_type MayaFlux::Yantra::GpuExecutionContext< InputType, OutputType >::collect_gpu_outputs ( const GpuChannelResult &  raw, const std::vector< std::vector< double > > &  channels, const DataStructureInfo &  structure_info  )

inlineprotectedvirtual

Reconstruct Datum<OutputType> from a GpuChannelResult.

Branches on structure_info.original_type:

• Non-double native types (float, uint8_t, uint16_t, uint32_t): reads raw bytes directly from the first OUTPUT binding via download_binding rather than the float readback path, then packs them into a DataVariant in the correct native type. No float reinterpretation of pixel bytes.
• Double / complex / other: reads raw.primary as float, widens to double per channel, delegates to reconstruct_from_double. Unchanged from previous behaviour.

Override to perform custom readback interpretation (e.g. image containers).

Reimplemented in MayaFlux::Yantra::TextureExecutionContext.

Definition at line 172 of file GpuExecutionContext.hpp.

    {
        output_type result;
 
        const auto& ot = structure_info.original_type;
        const bool is_native_non_double = ot == std::type_index(typeid(std::vector<float>)) || ot == std::type_index(typeid(std::vector<uint8_t>)) || ot == std::type_index(typeid(std::vector<uint16_t>)) || ot == std::type_index(typeid(std::vector<uint32_t>));
 
        if (is_native_non_double) {
            const size_t out_idx = find_first_output_index();
            const size_t allocated = m_resources.buffer_allocated_bytes(dispatch_key(), out_idx);
            if (allocated > 0) {
                std::vector<uint8_t> raw_bytes(allocated);
                download_binding(out_idx, raw_bytes.data(), allocated);
 
                auto native_variant = OperationHelper::reconstruct_from_double<Kakshya::DataVariant>(
                    { std::vector<double>(allocated / sizeof(double), 0.0) },
                    structure_info);
                std::visit([&](auto& vec) {
                    using V = typename std::decay_t<decltype(vec)>::value_type;
                    vec.resize(allocated / sizeof(V));
                    std::memcpy(vec.data(), raw_bytes.data(), allocated);
                },
                    native_variant);
 
                if constexpr (std::is_same_v<OutputType, std::vector<Kakshya::DataVariant>>) {
                    result.data = { std::move(native_variant) };
                } else if constexpr (std::is_same_v<OutputType, Kakshya::DataVariant>) {
                    result.data = std::move(native_variant);
                }
            }
            for (const auto& [idx, bytes] : raw.aux)
                result.metadata["gpu_output_" + std::to_string(idx)] = bytes;
            return result;
        }
 
        const size_t total = std::accumulate(channels.begin(), channels.end(), size_t { 0 },
            [](size_t s, const auto& ch) { return s + ch.size(); });
        if (!raw.primary.empty() && !channels.empty() && raw.primary.size() >= total) {
            size_t offset = 0;
            std::vector<std::vector<double>> result_ch(channels.size());
            for (size_t c = 0; c < channels.size(); ++c) {
                result_ch[c].resize(channels[c].size());
                for (size_t i = 0; i < channels[c].size(); ++i)
                    result_ch[c][i] = static_cast<double>(raw.primary[offset++]);
            }
            result = Datum<OutputType>(
                OperationHelper::reconstruct_from_double<OutputType>(result_ch, structure_info));
        }
        for (const auto& [idx, bytes] : raw.aux)
            result.metadata["gpu_output_" + std::to_string(idx)] = bytes;
        return result;
    }

References MayaFlux::Yantra::GpuChannelResult::aux, MayaFlux::Yantra::GpuResourceManager::buffer_allocated_bytes(), MayaFlux::Yantra::Datum< T >::data, MayaFlux::Yantra::GpuDispatchCore::dispatch_key(), MayaFlux::Yantra::GpuDispatchCore::download_binding(), MayaFlux::Yantra::GpuDispatchCore::find_first_output_index(), MayaFlux::Yantra::GpuDispatchCore::m_resources, MayaFlux::Yantra::Datum< T >::metadata, offset, MayaFlux::Yantra::DataStructureInfo::original_type, and MayaFlux::Yantra::GpuChannelResult::primary.

Referenced by MayaFlux::Yantra::GpuExecutionContext< InputType, OutputType >::execute().

Here is the call graph for this function:

Here is the caller graph for this function: