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
 *
 * https://apache.ac.cn/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