reduction_workunit.h

// -*-c++-*-
#ifndef STORMM_REDUCTION_WORKUNIT_H
#define STORMM_REDUCTION_WORKUNIT_H
 
#include <cmath>
#include <vector>
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "Accelerator/gpu_details.h"
#include "DataTypes/common_types.h"
 
namespace stormm {
namespace stmath {
 
using card::GpuDetails;
using card::Hybrid;
  
constexpr int maximum_gathering_results = 1024;

constexpr int rdwu_abstract_length = 8;

class ReductionWorkUnit {
public:

  ReductionWorkUnit(int atom_start_in, int atom_end_in, int result_index_in,
                    int dependency_start_in, int dependency_end_in, int system_index_in);

  ReductionWorkUnit(const ReductionWorkUnit &original) = default;
  ReductionWorkUnit(ReductionWorkUnit &&original) = default;
  ReductionWorkUnit& operator=(const ReductionWorkUnit &other) = default;
  ReductionWorkUnit& operator=(ReductionWorkUnit &&other) = default;
  
  int getAtomStart() const;

  int getAtomEnd() const;

  int getResultIndex() const;

  int getDependencyStart() const;

  int getDependencyEnd() const;

  int getSystemIndex() const;

  std::vector<int> getAbstract() const;
  
private:
  int atom_start;        
  int atom_end;          
  int result_index;      
  int dependency_start;  
  int dependency_end;    
  int system_index;      
};

int optReductionKernelSubdivision(const int* atom_counts, int n_systems, const GpuDetails &gpu);
int optReductionKernelSubdivision(const std::vector<int> &atom_counts, const GpuDetails &gpu);
int optReductionKernelSubdivision(const Hybrid<int> &atom_counts, const GpuDetails &gpu);

std::vector<ReductionWorkUnit> buildReductionWorkUnits(const std::vector<int> &atom_starts,
                                                       const std::vector<int> &atom_counts,
                                                       const GpuDetails &gpu,
                                                       int tasks_per_atom = 1);
 
} // namespace stmath
} // namespace stormm
 
#endif