AdaptBins.h

Go to the documentation of this file.

 
#ifndef ADAPT_BINS_H
#define ADAPT_BINS_H
 
#include "Ippl.h"
 
#include <Kokkos_DualView.hpp>
#include <algorithm>
#include <string>
#include <vector>
 
#include "BinHisto.h"
#include "BinningTools.h"
#include "ParallelReduceTools.h"
 
namespace ParticleBinning {
 
    template <typename BunchType>
    class AdaptBinsBase {
    public:
        using value_type     = typename BunchType::Layout_t::value_type;
        using size_type      = typename BunchType::size_type;
        using bin_index_type = typename BunchType::bin_index_type;
        using hash_type      = ippl::detail::hash_type<Kokkos::DefaultExecutionSpace::memory_space>;
 
        virtual ~AdaptBinsBase() = default;
 
        virtual bin_index_type getCurrentBinCount() const         = 0;
        virtual const std::string& getBinningCmdName() const      = 0;
        virtual bin_index_type getMaxBinCount() const             = 0;
        virtual value_type getBinWidth() const                    = 0;
        virtual value_type getXMin() const                        = 0;
        virtual hash_type getHashArray()                          = 0;
        virtual void initLimits()                                 = 0;
        virtual void instantiateHistogram(bool setToZero = false) = 0;
        virtual void assignBinsToParticles()                      = 0;
        virtual void initLocalHisto(
                HistoReductionMode modePreference = HistoReductionMode::Standard) = 0;
        virtual void executeInitLocalHistoReductionTeamFor()                      = 0;
        virtual void initGlobalHistogram()                                        = 0;
        virtual void doFullRebin(
                bin_index_type nBins, bool recalculateLimits = true,
                HistoReductionMode modePreference = HistoReductionMode::Standard) = 0;
        virtual void initHistogram(
                HistoReductionMode modePreference = HistoReductionMode::Standard)           = 0;
        virtual size_type getNPartInBin(bin_index_type binIndex, bool global = false)       = 0;
        virtual void sortContainerByBin()                                                   = 0;
        virtual Kokkos::RangePolicy<> getBinIterationPolicy(const bin_index_type& binIndex) = 0;
        virtual void genAdaptiveHistogram()                                                 = 0;
        virtual value_type getBinConfigHost(
                std::vector<size_type>& binCounts, std::vector<value_type>& binWidths) const = 0;
        virtual void print()                                                                 = 0;
        virtual void debug()                                                                 = 0;
    };
 
    template <typename BunchType, typename BinningSelector>
    class AdaptBins : public AdaptBinsBase<BunchType> {
    public:
        // Variable type definitions
        using value_type             = typename BinningSelector::value_type;
        using particle_position_type = typename BunchType::particle_position_type;
        using position_view_type     = typename particle_position_type::view_type;
        using size_type              = typename BunchType::size_type;
        using bin_index_type         = typename BunchType::bin_index_type;
        using bin_type               = typename ippl::ParticleAttrib<bin_index_type>;
        using bin_view_type          = typename bin_type::view_type;
        using hash_type = ippl::detail::hash_type<Kokkos::DefaultExecutionSpace::memory_space>;
 
        // Types from BinHisto.h to manage histogram structures without "auto"
        using d_histo_type          = Histogram<size_type, bin_index_type, value_type, true>;
        using dview_type            = typename d_histo_type::dview_type;
        using hview_type            = typename d_histo_type::hview_type;
        using dwidth_view_type      = typename d_histo_type::dwidth_view_type;
        using hindex_transform_type = typename d_histo_type::hindex_transform_type;
        using dindex_transform_type = typename d_histo_type::dindex_transform_type;
 
        using h_histo_type_g =
                Histogram<size_type, bin_index_type, value_type, false, Kokkos::HostSpace>;
        using hview_type_g            = typename h_histo_type_g::hview_type;
        using hwidth_view_type_g      = typename h_histo_type_g::hwidth_view_type;
        using hindex_transform_type_g = typename h_histo_type_g::hindex_transform_type;
 
        AdaptBins(
                BunchType& bunch, BinningSelector var_selector, bin_index_type maxBins,
                value_type binningAlpha, value_type binningBeta, value_type desiredWidth,
                const std::string& binningCmdName)
            : bunch_m(bunch),
              var_selector_m(var_selector),
              maxBins_m(maxBins),
              binningCmdName_m(binningCmdName),
              binningAlpha_m(binningAlpha),
              binningBeta_m(binningBeta),
              desiredWidth_m(desiredWidth) {
            // Will be set during usage/rebinning
            currentBins_m = maxBins;
 
            initTimers();
 
            Inform msg("AdaptBins");
            msg << level4 << "AdaptBins initialized with maxBins = " << maxBins_m
                << ", alpha = " << binningAlpha_m << ", beta = " << binningBeta_m
                << ", desiredWidth = " << desiredWidth_m << endl;
        }
 
        void initTimers() {
            bInitLimitsT            = IpplTimings::getTimer("bInitLimits");
            bAllReduceLimitsT       = IpplTimings::getTimer("bAllReduceLimits");
            bAllReduceGlobalHistoT  = IpplTimings::getTimer("bAllReduceGlobalHisto");
            bAssignUniformBinsT     = IpplTimings::getTimer("bAssignUniformBins");
            bExecuteHistoReductionT = IpplTimings::getTimer("bExecuteHistoReduction");
            bSortContainerByBinT    = IpplTimings::getTimer("bSortContainerByBin");
            bVerifySortingT         = IpplTimings::getTimer("bVerifySorting");
        }
 
        bin_view_type getBinView() { return bunch_m.Bin.getView(); }
 
        bin_index_type getCurrentBinCount() const override { return currentBins_m; }
 
        const std::string& getBinningCmdName() const override { return binningCmdName_m; }
 
        bin_index_type getMaxBinCount() const override { return maxBins_m; }
 
        value_type getBinWidth() const override { return binWidth_m; }
 
        value_type getXMin() const override { return xMin_m; }
 
        void setCurrentBinCount(bin_index_type nBins) {
            // Hard safety: never allow 0 bins (would break reducers and cause div-by-zero).
            const bin_index_type clampedUpper = (nBins > maxBins_m) ? maxBins_m : nBins;
            currentBins_m                     = std::max<bin_index_type>(1, clampedUpper);
            binWidth_m                        = (xMax_m - xMin_m) / currentBins_m;
        }
 
        hash_type getHashArray() override { return sortedIndexArr_m; }
 
        KOKKOS_INLINE_FUNCTION
        static bin_index_type getBin(
                value_type x, value_type xMin, value_type xMax, value_type binWidthInv,
                bin_index_type numBins);
 
        void initLimits() override;
 
        void instantiateHistogram(bool setToZero = false) override;
 
        void assignBinsToParticles() override;
 
        void initLocalHisto(
                HistoReductionMode modePreference = HistoReductionMode::Standard) override;
 
        void executeInitLocalHistoReductionTeamFor() override;
 
        template <typename ReducerType>
        void executeInitLocalHistoReduction(ReducerType& to_reduce);
 
        void initGlobalHistogram() override;
 
        void doFullRebin(
                bin_index_type nBins, bool recalculateLimits = true,
                HistoReductionMode modePreference = HistoReductionMode::Standard) override {
            if (recalculateLimits) initLimits();
            setCurrentBinCount(nBins);
            assignBinsToParticles();
            initHistogram(modePreference);
        }
 
        void initHistogram(
                HistoReductionMode modePreference = HistoReductionMode::Standard) override {
            instantiateHistogram(true);
            initLocalHisto(modePreference);
            initGlobalHistogram();
 
            // Init both histograms --> buils postSums and widths arrays
            localBinHisto_m.init();
            globalBinHisto_m.init();
        }
 
        size_type getNPartInBin(bin_index_type binIndex, bool global = false) override {
            // shouldn't happen..., "binIndex < 0" unnecessary, since binIndex is usually unsigned;
            // but just in case the type is changed
            if (binIndex < 0 || binIndex >= getCurrentBinCount()) {
                return bunch_m.getTotalNum();
            }
 
            if (global) {
                return globalBinHisto_m.getNPartInBin(binIndex);
            } else {
                return localBinHisto_m.getNPartInBin(binIndex);
            }
        }
 
        void sortContainerByBin() override;
 
        Kokkos::RangePolicy<> getBinIterationPolicy(const bin_index_type& binIndex) override {
            return localBinHisto_m.getBinIterationPolicy(binIndex);
        }
 
        void genAdaptiveHistogram() override;
 
        value_type getBinConfigHost(
                std::vector<size_type>& binCounts,
                std::vector<value_type>& binWidths) const override;
 
        void print() override { globalBinHisto_m.printPythonArrays(); }
 
        void debug() override {
            Inform msg("KOKKOS DEBUG");  // , INFORM_ALL_NODES
 
            int rank = ippl::Comm->rank();
            msg << level2 << "=====================================" << endl;
            msg << level2 << " Kokkos Debug Information (Rank " << rank << ")" << endl;
            msg << level2 << "=====================================" << endl;
 
// Check number of CPU threads (OpenMP or other CPU execution spaces)
#ifdef KOKKOS_ENABLE_OPENMP
            int num_threads = Kokkos::OpenMP().concurrency();
            msg << level2 << "CPU Threads (OpenMP): " << num_threads << endl;
#elif defined(KOKKOS_ENABLE_THREADS)
            int num_threads = Kokkos::Threads().concurrency();
            msg << level2 << "CPU Threads (Kokkos::Threads): " << num_threads << endl;
#else
            msg << level2 << "CPU Threads: No multi-threaded CPU execution space enabled." << endl;
#endif
 
// Check number of GPUs (CUDA/HIP devices)
#if defined(KOKKOS_ENABLE_CUDA)
            int num_gpus = Kokkos::num_devices();
            msg << level2 << "CUDA Enabled: Rank " << rank << " sees " << num_gpus
                << " GPU(s) available." << endl;
            Kokkos::Cuda cuda_instance;
            std::stringstream ss;
            cuda_instance.print_configuration(ss);
            msg << level2 << ss.str();
#elif defined(KOKKOS_ENABLE_HIP)
            int num_gpus = Kokkos::num_devices();
            msg << level2 << "HIP Enabled: Rank " << rank << " sees " << num_gpus
                << " GPU(s) available." << endl;
            Kokkos::Experimental::HIP hip_instance;
            std::stringstream ss;
            hip_instance.print_configuration(ss);
            msg << level2 << ss.str();
#else
            msg << level2 << "CUDA/HIP: GPU support disabled.\n";
#endif
 
            // Additional information on concurrency in the default execution space
            int default_concurrency = Kokkos::DefaultExecutionSpace().concurrency();
            msg << level2 << "Default Execution Space Concurrency: " << default_concurrency << endl;
            msg << level2 << "Binning cost function parameters: alpha = " << binningAlpha_m
                << ", beta = " << binningBeta_m << ", desiredWidth = " << desiredWidth_m << endl;
 
            msg << level2 << "=====================================" << endl;
        }
 
    private:
        BunchType& bunch_m;              
        BinningSelector var_selector_m;  
        const bin_index_type maxBins_m;  
        bin_index_type currentBins_m;    
        std::string binningCmdName_m;    
        value_type xMin_m;               
        value_type xMax_m;               
        value_type binWidth_m;           
 
        // Merging cost function parameters
        value_type binningAlpha_m;  
        value_type binningBeta_m;   
        value_type desiredWidth_m;  
 
        // Histograms
        d_histo_type localBinHisto_m;  
        h_histo_type_g
                globalBinHisto_m;  
 
        hash_type sortedIndexArr_m;  
 
        // Timers...
        IpplTimings::TimerRef bInitLimitsT;
        IpplTimings::TimerRef bAllReduceLimitsT;
        IpplTimings::TimerRef bAllReduceGlobalHistoT;
        IpplTimings::TimerRef bAssignUniformBinsT;
        IpplTimings::TimerRef bExecuteHistoReductionT;
        IpplTimings::TimerRef bSortContainerByBinT;
        IpplTimings::TimerRef bVerifySortingT;
    };
 
}  // namespace ParticleBinning
 
#include "AdaptBins.tpp"
 
#endif  // ADAPT_BINS_H