Kernel.h

Go to the documentation of this file.

 
#ifndef KIDS_Kernel_H
#define KIDS_Kernel_H
 
#include <memory>
 
#include "kids/DataSet.h"
#include "kids/Param.h"
#include "kids/RuleSet.h"
#include "kids/Status.h"
 
namespace PROJECT_NS {
 
class Kernel : public std::enable_shared_from_this<Kernel> {
   public:
    inline virtual const std::string getName() { return utils::concat("Kernel__", kernel_name); }
 
    static int dump(Kernel* ker) { return 0; }
 
    static int report(Kernel* ker) { return 0; }
 
    static int mpi_reduce_info(Kernel* ker) { return 0; }
 
    Kernel(const std::string& customized_name = "");
 
    virtual ~Kernel();
 
    void setInputParam(std::shared_ptr<Param>& PM);
 
    void setInputDataSet(std::shared_ptr<DataSet>& DS);
 
    std::shared_ptr<Param> getParam() const;
 
    std::shared_ptr<DataSet> getDataSet() const;
 
    Status& initializeKernel(Status& stat);
 
    Status& executeKernel(Status& stat);
 
    Status& finalizeKernel(Status& stat);
 
    virtual int getType() const;
 
    int getID() const;
 
    bool operator==(const Kernel& ker);
 
    Kernel& appendChild(std::shared_ptr<Kernel> ker);
 
    Kernel& insertAt(std::vector<std::size_t> indexes, std::shared_ptr<Kernel> ker);
 
    Kernel& removeAt(std::vector<std::size_t> indexes);
 
    Kernel& updateAt(std::vector<std::size_t> indexes, std::shared_ptr<Kernel> ker);
 
    std::tuple<Kernel*, std::size_t> getLastParentKernelAndChildOrder();
 
    std::shared_ptr<RuleSet> getRuleSet();
 
    static const std::string serializeKernel(const Kernel& ker);
 
    static std::shared_ptr<Kernel> deserializeKernel(const std::string& str);
 
    const std::string generateInformationString(double total_time       = -1.0f,  //
                                                int    current_layer    = 0,      //
                                                int    total_depth      = 0,      //
                                                int    total_align_size = 0);
 
 
   protected:
    bool        is_timing      = false;  
    bool        has_parent     = false;  
    int         count_calc     = 0;      
    int         count_exec     = 0;      
    int         kernel_id      = 0;      
    int         kernel_type    = 0;      
    double      exec_time      = 0.0f;   
    int         depth          = 0;      
    int         max_align_size = 0;      
    std::string kernel_name;             
 
    std::shared_ptr<Param> _param;
 
    std::shared_ptr<DataSet> _dataset;
 
    std::shared_ptr<RuleSet> _ruleset;
 
    Kernel* _parent_kernel;
 
    std::size_t _order_in_parent;
 
    std::vector<std::shared_ptr<Kernel>> _child_kernels;
 
    std::vector<std::shared_ptr<Kernel>> _all_kernels;
 
    virtual void setInputParam_impl(std::shared_ptr<Param>& PM);
 
    virtual void setInputDataSet_impl(std::shared_ptr<DataSet>& DS);
 
    virtual Status& initializeKernel_impl(Status& stat);
 
    virtual Status& executeKernel_impl(Status& stat);
 
    virtual Status& finalizeKernel_impl(Status& stat);
 
   private:
    void connectRelatedKernels(std::shared_ptr<Kernel>& ker);
 
    static std::map<std::string, Kernel*>& getDictOfKernels();
 
    static std::vector<Kernel*>& getKernels();
};
 
};  // namespace PROJECT_NS
 
#endif  // KIDS_Kernel_H