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 "ParallelReduceTools.h" 
#include "BinningTools.h"        
#include "BinHisto.h"           
 
namespace ParticleBinning {

    template <typename BunchType, typename BinningSelector>
    class AdaptBins {
    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 hindex_transform_type_g = typename h_histo_type_g::hindex_transform_type;

        AdaptBins(std::shared_ptr<BunchType> bunch, BinningSelector var_selector, bin_index_type maxBins,
                  value_type binningAlpha, value_type binningBeta, value_type desiredWidth)
            : bunch_m(bunch)
            , var_selector_m(var_selector)
            , maxBins_m(maxBins)
            , binningAlpha_m(binningAlpha)
            , binningBeta_m(binningBeta)
            , desiredWidth_m(desiredWidth) {
 
            // Will be set during usage/rebinning
            currentBins_m = maxBins;
 
            initTimers();
 
            Inform msg("AdaptBins");
            msg << "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 { return currentBins_m; }

        bin_index_type getMaxBinCount() const { return maxBins_m; }

        value_type getBinWidth() const { return binWidth_m; }

        void setCurrentBinCount(bin_index_type nBins) {
            currentBins_m = (nBins > maxBins_m) ? maxBins_m : nBins; 
            binWidth_m    = (xMax_m - xMin_m) / currentBins_m; 
        }

        hash_type getHashArray() { 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();

        void instantiateHistogram(bool setToZero = false);

        void assignBinsToParticles();

        void initLocalHisto(HistoReductionMode modePreference = HistoReductionMode::Standard);

        void executeInitLocalHistoReductionTeamFor();

        template<typename ReducerType>
        void executeInitLocalHistoReduction(ReducerType& to_reduce);

        void initGlobalHistogram();

        void doFullRebin(bin_index_type nBins, bool recalculateLimits = true, HistoReductionMode modePreference = HistoReductionMode::Standard) {
            if (recalculateLimits) initLimits();
            setCurrentBinCount(nBins);
            assignBinsToParticles();
            initHistogram(modePreference);
        }

        void initHistogram(HistoReductionMode modePreference = HistoReductionMode::Standard) {
            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) {
            // 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();

        Kokkos::RangePolicy<> getBinIterationPolicy(const bin_index_type& binIndex) {
            return localBinHisto_m.getBinIterationPolicy(binIndex);
        }

        void genAdaptiveHistogram();

        void print() {
            globalBinHisto_m.printPythonArrays();
        }

        void debug() {
            Inform msg("KOKKOS DEBUG"); // , INFORM_ALL_NODES
 
            int rank = ippl::Comm->rank();
            msg << "=====================================" << endl;
            msg << " Kokkos Debug Information (Rank " << rank << ")" << endl;
            msg << "=====================================" << endl;
 
            // Check number of CPU threads (OpenMP or other CPU execution spaces)
            #ifdef KOKKOS_ENABLE_OPENMP
            int num_threads = Kokkos::OpenMP::concurrency();
            msg << "CPU Threads (OpenMP): " << num_threads << endl;
            #elif defined(KOKKOS_ENABLE_THREADS)
            int num_threads = Kokkos::Threads::concurrency();
            msg << "CPU Threads (Kokkos::Threads): " << num_threads << endl;
            #else
            msg << "CPU Threads: No multi-threaded CPU execution space enabled." << endl;
            #endif
 
            // Check number of GPUs (CUDA devices)
            #ifdef KOKKOS_ENABLE_CUDA
            int num_gpus = Kokkos::Cuda::detect_device_count();
            msg << "CUDA Enabled: Rank " << rank << " sees " << num_gpus << " GPU(s) available." << endl;
            Kokkos::Cuda cuda_instance;  
            std::stringstream ss;
            cuda_instance.print_configuration(ss);
            msg << ss.str();
            #else
            msg << "CUDA: GPU support disabled.\n";
            #endif
 
            // Additional information on concurrency in the default execution space
            int default_concurrency = Kokkos::DefaultExecutionSpace::concurrency();
            msg << "Default Execution Space Concurrency: " << default_concurrency << endl;
            msg << "Binning cost function parameters: alpha = " << binningAlpha_m << ", beta = " << binningBeta_m << ", desiredWidth = " << desiredWidth_m << endl;
 
            msg << "=====================================" << endl;
        }

        template <typename T, unsigned Dim>
        VField_t<T, Dim>& LTrans(VField_t<T, Dim>& field, const bin_index_type& currentBin); // TODO: may want to add usage of c constant when it exists...
 
    private:
        std::shared_ptr<BunchType> bunch_m;    
        BinningSelector var_selector_m;        
        const bin_index_type maxBins_m;        
        bin_index_type currentBins_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;
    };
 
}
 
#include "AdaptBins.tpp"
 
#endif  // ADAPT_BINS_H