defaults.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2022-2025, NVIDIA CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
// Enable documentation of the enum.
#pragma once
 
#include <cstddef>
#include <cstdlib>
#include <sstream>
#include <stdexcept>
#include <string>
 
#include <BS_thread_pool.hpp>
 
#include <kvikio/shim/cufile.hpp>
 
namespace kvikio {
enum class CompatMode : uint8_t {
  OFF,  
  ON,   
  AUTO,  
};
 
namespace detail {
CompatMode parse_compat_mode_str(std::string_view compat_mode_str);
 
}  // namespace detail
 
template <typename T>
T getenv_or(std::string_view env_var_name, T default_val)
{
  const auto* env_val = std::getenv(env_var_name.data());
  if (env_val == nullptr) { return default_val; }
 
  std::stringstream sstream(env_val);
  T converted_val;
  sstream >> converted_val;
  if (sstream.fail()) {
    throw std::invalid_argument("unknown config value " + std::string{env_var_name} + "=" +
                                std::string{env_val});
  }
  return converted_val;
}
 
template <>
bool getenv_or(std::string_view env_var_name, bool default_val);
 
template <>
CompatMode getenv_or(std::string_view env_var_name, CompatMode default_val);
 
class defaults {
 private:
  BS::thread_pool _thread_pool{get_num_threads_from_env()};
  CompatMode _compat_mode;
  std::size_t _task_size;
  std::size_t _gds_threshold;
  std::size_t _bounce_buffer_size;
 
  static unsigned int get_num_threads_from_env();
 
  defaults();
 
  KVIKIO_EXPORT static defaults* instance();
 
 public:
  [[nodiscard]] static CompatMode compat_mode();
 
  static void compat_mode_reset(CompatMode compat_mode);
 
  static CompatMode infer_compat_mode_if_auto(CompatMode compat_mode) noexcept;
 
  static bool is_compat_mode_preferred(CompatMode compat_mode) noexcept;
 
  static bool is_compat_mode_preferred();
 
  [[nodiscard]] static BS::thread_pool& thread_pool();
 
  [[nodiscard]] static unsigned int thread_pool_nthreads();
 
  static void thread_pool_nthreads_reset(unsigned int nthreads);
 
  [[nodiscard]] static std::size_t task_size();
 
  static void task_size_reset(std::size_t nbytes);
 
  [[nodiscard]] static std::size_t gds_threshold();
 
  static void gds_threshold_reset(std::size_t nbytes);
 
  [[nodiscard]] static std::size_t bounce_buffer_size();
 
  static void bounce_buffer_size_reset(std::size_t nbytes);
};
 
}  // namespace kvikio