sort_implementation()

Datum< Kakshya::RegionGroup > MayaFlux::Yantra::Granular::SortOp::sort_implementation ( const Datum< Kakshya::RegionGroup > &  input )

overrideprotected

Pad element count to next power of two for bitonic correctness. Out-of-range threads early-exit in the shader via element_count.

Total bitonic passes: sum of (stage+1) for stage in [0, stage_count).

Recover (stage, step) from the flat pass index. Passes enumerate: stage=0 step=0, stage=1 step=0,1, stage=2 step=0,1,2, ...

Definition at line 617 of file GranularWorkflow.cpp.

{
    const auto feature_key = this->template get_parameter_or_default<std::string>("feature_key", std::string("feature"));
    const bool ascending = this->template get_parameter_or_default<bool>("ascending", true);
    const auto gpu_thresh = this->template get_parameter_or_default<uint32_t>("gpu_sort_threshold", 0U);
    const auto n = static_cast<uint32_t>(input.data.regions.size());
 
    Datum<Kakshya::RegionGroup> out = input;
 
    if (n == 0)
        return out;
 
    if (gpu_thresh > 0 && n >= gpu_thresh) {
        struct SortPC {
            uint32_t element_count;
            uint32_t step;
            uint32_t stage;
            uint32_t ascending;
        };
 
        std::vector<float> values(n);
        for (uint32_t i = 0; i < n; ++i) {
            auto attr = out.data.regions[i].get_attribute<double>(feature_key);
            values[i] = attr ? static_cast<float>(*attr) : 0.0F;
        }
 
        std::vector<uint32_t> indices(n);
        std::iota(indices.begin(), indices.end(), 0U);
 
        /// @brief Pad element count to next power of two for bitonic correctness.
        ///        Out-of-range threads early-exit in the shader via element_count.
        uint32_t n_padded = 1U;
        while (n_padded < n)
            n_padded <<= 1U;
 
        /// @brief Total bitonic passes: sum of (stage+1) for stage in [0, stage_count).
        uint32_t stage_count = 0U;
        {
            uint32_t tmp = n_padded;
            while (tmp > 1U) {
                ++stage_count;
                tmp >>= 1U;
            }
        }
        const uint32_t n_passes = stage_count * (stage_count + 1U) / 2U;
 
        auto executor = std::make_shared<ShaderExecutionContext<>>(
            GpuComputeConfig {
                .shader_path = "sort_by_attribute.comp",
                .workgroup_size = { 256, 1, 1 },
                .push_constant_size = sizeof(SortPC) });
 
        executor->in_out(0, values, GpuBufferBinding::ElementType::FLOAT32)
            .in_out(1, indices, GpuBufferBinding::ElementType::UINT32)
            .set_output_size(1, n * sizeof(uint32_t));
 
        executor->set_multipass(n_passes,
            [n, ascending](uint32_t pass, void* pc_data) {
                /// @brief Recover (stage, step) from the flat pass index.
                ///        Passes enumerate: stage=0 step=0,
                ///                          stage=1 step=0,1,
                ///                          stage=2 step=0,1,2, ...
                uint32_t stage = 0U;
                uint32_t remaining = pass;
                while (remaining >= stage + 1U) {
                    remaining -= stage + 1U;
                    ++stage;
                }
                const uint32_t step = stage - remaining;
 
                const SortPC pc {
                    .element_count = n,
                    .step = step,
                    .stage = stage,
                    .ascending = ascending ? 1U : 0U,
                };
                std::memcpy(pc_data, &pc, sizeof(SortPC));
            });
 
        auto gpu_sorter = std::make_shared<GpuSorter<>>(executor);
 
        Datum<std::vector<Kakshya::DataVariant>> sort_input {
            { Kakshya::DataVariant(std::vector<double>(values.begin(), values.end())) }
        };
 
        auto result = gpu_sorter->apply_operation(sort_input);
        const auto sorted_indices = ShaderExecutionContext<>::read_output<uint32_t>(result, 1);
 
        std::vector<Kakshya::Region> reordered(n);
        for (uint32_t i = 0; i < n; ++i)
            reordered[i] = out.data.regions[sorted_indices[i]];
 
        out.data.regions = std::move(reordered);
        out.data.current_region_index = 0;
        out.data.active_indices.clear();
        return out;
    }
 
    out.data.sort_by_attribute(feature_key);
 
    if (!ascending)
        std::ranges::reverse(out.data.regions);
 
    out.data.current_region_index = 0;
    out.data.active_indices.clear();
 
    return out;
}

References MayaFlux::Yantra::Datum< T >::data, MayaFlux::Portal::Graphics::GpuBufferBinding::FLOAT32, input, pass, MayaFlux::Portal::Graphics::GpuComputeConfig::shader_path, and MayaFlux::Portal::Graphics::GpuBufferBinding::UINT32.