defaults.hpp

/*
 * 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.
 */
 
#pragma once
 
#include <cstddef>
#include <cstdlib>
#include <sstream>
#include <stdexcept>
#include <string>
 
#include <kvikio/compat_mode.hpp>
#include <kvikio/http_status_codes.hpp>
#include <kvikio/shim/cufile.hpp>
#include <kvikio/threadpool_wrapper.hpp>
 
namespace kvikio {
 
template <typename T>
T getenv_or(std::string_view env_var_name, T default_val)
{
  auto const* 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;
  KVIKIO_EXPECT(!sstream.fail(),
                "unknown config value " + std::string{env_var_name} + "=" + std::string{env_val},
                std::invalid_argument);
  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);
 
template <>
std::vector<int> getenv_or(std::string_view env_var_name, std::vector<int> 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;
  std::size_t _http_max_attempts;
  long _http_timeout;
  std::vector<int> _http_status_codes;
 
  static unsigned int get_num_threads_from_env();
 
  defaults();
 
  KVIKIO_EXPORT static defaults* instance();
 
 public:
  [[nodiscard]] static CompatMode compat_mode();
 
  static void set_compat_mode(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 set_thread_pool_nthreads(unsigned int nthreads);
 
  [[nodiscard]] static std::size_t task_size();
 
  static void set_task_size(std::size_t nbytes);
 
  [[nodiscard]] static std::size_t gds_threshold();
 
  static void set_gds_threshold(std::size_t nbytes);
 
  [[nodiscard]] static std::size_t bounce_buffer_size();
 
  static void set_bounce_buffer_size(std::size_t nbytes);
 
  [[nodiscard]] static std::size_t http_max_attempts();
 
  static void set_http_max_attempts(std::size_t attempts);
 
  [[nodiscard]] static long http_timeout();
 
  static void set_http_timeout(long timeout_seconds);
 
  [[nodiscard]] static std::vector<int> const& http_status_codes();
 
  static void set_http_status_codes(std::vector<int> status_codes);
};
 
}  // namespace kvikio