default_params.h

/*
 *  Copyright (C) 2004-2024 Edward F. Valeev
 *
 *  This file is part of Libint compiler.
 *
 *  Libint compiler is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Libint compiler is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Libint compiler.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef _libint2_src_bin_libint_defaultparams_h_
#define _libint2_src_bin_libint_defaultparams_h_
 
#include <smart_ptr.h>
 
#include <climits>
#include <map>
#include <ostream>
#include <string>
#include <vector>
 
namespace libint2 {
 
class CompilationParameters {
  std::string default_task_name_;
 
 public:
  CompilationParameters();
  ~CompilationParameters();
 
  unsigned int max_am(std::string t = "", unsigned int c = 0) const;
  unsigned int max_am_opt(std::string t = "") const;
  unsigned int num_bf(std::string t = "") const;
  unsigned int max_vector_length() const { return max_vector_length_; }
  bool vectorize_by_line() const { return vectorize_by_line_; }
  unsigned int unroll_threshold() const { return unroll_threshold_; }
  unsigned int align_size() const { return align_size_; }
  const std::string& source_directory() const { return source_directory_; }
  const std::string& api_prefix() const { return api_prefix_; }
  bool single_evaltype() const { return single_evaltype_; }
  bool use_C_linking() const { return use_C_linking_; }
  bool count_flops() const { return count_flops_; }
  bool profile() const { return profile_; }
  bool accumulate_targets() const { return accumulate_targets_; }
  const std::string& realtype() const { return realtype_; }
  bool contracted_targets() const { return contracted_targets_; }
  const std::string& default_task_name() const { return default_task_name_; }
 
  void max_am(const std::string& t, unsigned int a, unsigned int c = 0);
  void max_am_opt(const std::string& t, unsigned int a);
  void num_bf(const std::string& t, unsigned int a);
  void max_vector_length(unsigned int a) { max_vector_length_ = a; }
  void vectorize_by_line(bool flag) { vectorize_by_line_ = flag; }
  void align_size(unsigned int a) { align_size_ = a; }
  void unroll_threshold(unsigned int a) { unroll_threshold_ = a; }
  void source_directory(const std::string& a) { source_directory_ = a; }
  void api_prefix(const std::string& a) { api_prefix_ = a; }
  void single_evaltype(bool se) { single_evaltype_ = se; }
  void use_C_linking(bool a) { use_C_linking_ = a; }
  void count_flops(bool a) { count_flops_ = a; }
  void profile(bool a) { profile_ = a; }
  void accumulate_targets(bool a) { accumulate_targets_ = a; }
  void realtype(const std::string& realtype) { realtype_ = realtype; }
  void contracted_targets(bool c) { contracted_targets_ = c; }
  void default_task_name(const std::string& s) { default_task_name_ = s; }
 
  void print(std::ostream& os) const;
 
 private:
  struct Defaults {
    static const unsigned int max_am = 1;
    static const unsigned int max_am_opt = 1;
    static const unsigned int num_bf = 4;
    static const unsigned int max_vector_length = 1;
    static const bool vectorize_by_line = false;
    static const unsigned int align_size = 0;
    static const unsigned int unroll_threshold = 0;
    static const std::string source_directory;
    static const std::string api_prefix;
    static const bool single_evaltype = true;
    static const bool use_C_linking = true;
    static const bool count_flops = false;
    static const bool profile = false;
    static const bool accumulate_targets = false;
    static const std::string realtype;
    static const bool contracted_targets = false;
    static const std::string task_name;
  };
 
  struct TaskParameters {
    std::vector<unsigned int> max_am;
    unsigned int max_am_opt;
    unsigned int num_bf;
 
    TaskParameters() : max_am(1, 0u), max_am_opt(0u), num_bf(0u) {}
  };
  std::map<std::string, TaskParameters> task_params_;
  void task_exists(const std::string& t) const;
  void add_task(const std::string& t);
 
  unsigned int max_vector_length_;
  bool vectorize_by_line_;
  unsigned int align_size_;
  unsigned int unroll_threshold_;
  std::string source_directory_;
  std::string api_prefix_;
  bool single_evaltype_;
  bool use_C_linking_;
  bool count_flops_;
  bool profile_;
  bool accumulate_targets_;
  std::string realtype_;
  bool contracted_targets_;
};
 
class TaskParameters {
 public:
  TaskParameters();
  ~TaskParameters() {}
 
  unsigned int max_ntarget() const { return max_ntarget_; }
  unsigned int max_am() const { return max_stack_size_.size() - 1; }
  unsigned int max_stack_size(unsigned int am) const {
    return max_stack_size_.at(am);
  }
  unsigned int max_vector_stack_size(unsigned int am) const {
    if (am + 1 > max_vector_stack_size_.size())
      return 0;
    else
      return max_vector_stack_size_[am];
  }
  unsigned int max_hrr_hsrank(unsigned int am) const {
    if (am + 1 > max_hrr_hsrank_.size())
      return 0;
    else
      return max_hrr_hsrank_[am];
  }
  unsigned int max_hrr_lsrank(unsigned int am) const {
    if (am + 1 > max_hrr_lsrank_.size())
      return 0;
    else
      return max_hrr_lsrank_[am];
  }
 
  void max_ntarget(unsigned int ntarget) {
    if (max_ntarget_ < ntarget) max_ntarget_ = ntarget;
  }
 
  void max_stack_size(unsigned int am, unsigned int size) {
    extend_max_size(max_stack_size_, am, size);
  }
 
  void max_vector_stack_size(unsigned int am, unsigned int size) {
    extend_max_size(max_vector_stack_size_, am, size);
  }
 
  void max_hrr_hsrank(unsigned int am, unsigned int rank) {
    extend_max_size(max_hrr_hsrank_, am, rank);
  }
 
  void max_hrr_lsrank(unsigned int am, unsigned int rank) {
    extend_max_size(max_hrr_lsrank_, am, rank);
  }
 
 private:
  unsigned int max_ntarget_;
  std::vector<unsigned int>
      max_stack_size_;  //< keeps track of stack size needed to compute
                        // integrals up to a given quantum number
  std::vector<unsigned int> max_vector_stack_size_;
  std::vector<unsigned int> max_hrr_hsrank_;
  std::vector<unsigned int> max_hrr_lsrank_;
 
  static void extend_max_size(std::vector<unsigned int>& max_size,
                              unsigned int am, unsigned int size) {
    const int max_am = (int)max_size.size() - 1u;
    if (max_am < (int)am) {
      max_size.resize(am + 1);
      for (int l = std::max(max_am + 1, 1); l <= (int)am; ++l)
        max_size[l] = max_size[l - 1];
    }
    if (max_size[am] < size) max_size[am] = size;
  }
};
 
std::string label_to_funcname(const std::string& label);
 
bool condense_expr(unsigned int unroll_threshold, bool vectorize);
};  // namespace libint2
 
#endif