Add logging to libcudf

conda/recipes/libcudf/meta.yaml

@@ -272,6 +272,7 @@ outputs:
  - test -f $PREFIX/include/cudf/utilities/bit.hpp
  - test -f $PREFIX/include/cudf/utilities/default_stream.hpp
  - test -f $PREFIX/include/cudf/utilities/error.hpp
+ - test -f $PREFIX/include/cudf/utilities/logger.hpp
  - test -f $PREFIX/include/cudf/utilities/span.hpp
  - test -f $PREFIX/include/cudf/utilities/traits.hpp
  - test -f $PREFIX/include/cudf/utilities/type_checks.hpp

cpp/CMakeLists.txt

@@ -579,6 +579,7 @@ add_library(
  src/unary/nan_ops.cu
  src/unary/null_ops.cu
  src/utilities/default_stream.cpp
+ src/utilities/logger.cpp
  src/utilities/traits.cpp
  src/utilities/type_checks.cpp
  src/utilities/type_dispatcher.cpp

cpp/include/cudf/utilities/logger.hpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2023, 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
+
+// If using GCC, temporary workaround for older libcudacxx defining _LIBCPP_VERSION
+// undefine it before including spdlog, due to fmtlib checking if it is defined
+// TODO: remove once libcudacxx is on Github and RAPIDS depends on it
+#ifdef __GNUG__
+#undef _LIBCPP_VERSION
+#endif
+#include <spdlog/spdlog.h>
+
+namespace cudf {
+
+/**
+ * @brief Returns the global logger
+ *
+ * This is a spdlog logger. The easiest way to log messages is to use the `CUDF_LOG_*` macros.
+ *
+ * @return spdlog::logger& The logger.
+ */
+spdlog::logger& logger();
+
+// The default is INFO, but it should be used sparingly, so that by default a log file is only
+// output if there is important information, warnings, errors, and critical failures
+// Log messages that require computation should only be used at level TRACE and DEBUG
+#define CUDF_LOG_TRACE(...) SPDLOG_LOGGER_TRACE(&cudf::logger(), __VA_ARGS__)
+#define CUDF_LOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(&cudf::logger(), __VA_ARGS__)
+#define CUDF_LOG_INFO(...) SPDLOG_LOGGER_INFO(&cudf::logger(), __VA_ARGS__)
+#define CUDF_LOG_WARN(...) SPDLOG_LOGGER_WARN(&cudf::logger(), __VA_ARGS__)
+#define CUDF_LOG_ERROR(...) SPDLOG_LOGGER_ERROR(&cudf::logger(), __VA_ARGS__)
+#define CUDF_LOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(&cudf::logger(), __VA_ARGS__)
+
+} // namespace cudf

cpp/src/io/utilities/config_utils.cpp

@@ -23,12 +23,6 @@
 
 namespace cudf::io::detail {
 
-std::string getenv_or(std::string const& env_var_name, std::string_view default_val)
-{
- auto const env_val = std::getenv(env_var_name.c_str());
- return std::string{(env_val == nullptr) ? default_val : env_val};
-}
-
 namespace cufile_integration {
 
 namespace {

cpp/src/io/utilities/config_utils.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2022, NVIDIA CORPORATION.
+ * Copyright (c) 2021-2023, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include <cudf/utilities/logger.hpp>
+
 #include <sstream>
 #include <string>
 
@@ -28,6 +30,13 @@ 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) {
+ logger().debug("Environment variable {} read as {}", env_var_name, env_val);
+ } else {
+ logger().debug(
+ "Environment variable {} is not set, using default value {}", env_var_name, default_val);
+ }
+
  if (env_val == nullptr) { return default_val; }
 
  std::stringstream sstream(env_val);

cpp/src/io/utilities/hostdevice_vector.hpp

@@ -30,6 +30,13 @@
 
 #include <variant>
 
+inline bool hostdevice_vector_uses_pageable_buffer()
+{
+ static bool const use_pageable =
+ cudf::io::detail::getenv_or("LIBCUDF_IO_PREFER_PAGEABLE_TMP_MEMORY", 0);
+ return use_pageable;
+}
+
 /**
  * @brief A helper class that wraps fixed-length device memory for the GPU, and
  * a mirror host pinned memory for the CPU.
@@ -56,9 +63,7 @@ class hostdevice_vector {
  {
  CUDF_EXPECTS(initial_size <= max_size, "initial_size cannot be larger than max_size");
 
- auto const use_pageable_buffer =
- cudf::io::detail::getenv_or("LIBCUDF_IO_PREFER_PAGEABLE_TMP_MEMORY", 0);
- if (use_pageable_buffer) {
+ if (hostdevice_vector_uses_pageable_buffer()) {
  h_data_owner = thrust::host_vector<T>();
  } else {
  h_data_owner = thrust::host_vector<T, cudf::detail::pinned_allocator<T>>();

cpp/src/utilities/logger.cpp

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2023, 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.
+ */
+
+#include <cudf/utilities/logger.hpp>
+
+#include <cudf/utilities/error.hpp>
+
+#include <spdlog/sinks/basic_file_sink.h>
+
+#include <iostream>
+#include <string>
+
+namespace cudf {
+
+/**
+ * @brief Returns the default log filename for the global logger.
+ *
+ * If the environment variable `CUDF_DEBUG_LOG_FILE` is defined, its value is used as the path and
+ * name of the log file. Otherwise, the file `cudf_log.txt` in the current working directory is
+ * used.
+ *
+ * @return std::string The default log file name.
+ */
+inline std::string default_log_filename()
+{
+ auto* filename = std::getenv("LIBCUDF_DEBUG_LOG_FILE");
+ return (filename == nullptr) ? std::string{"cudf_log.txt"} : std::string{filename};
+}
+
+/**
+ * @brief Simple wrapper around a spdlog::logger that performs cuDF-specific initialization.
+ */
+struct logger_wrapper {
+ spdlog::logger logger_;
+
+ /**
+ * @brief Converts the level name into the `spdlog` level enum.
+ */
+ spdlog::level::level_enum spdlog_level_from_string(std::string_view str)
+ {
+ if (str == "TRACE") return spdlog::level::trace;
+ if (str == "DEBUG") return spdlog::level::debug;
+ if (str == "INFO") return spdlog::level::info;
+ if (str == "WARN") return spdlog::level::warn;
+ if (str == "ERR") return spdlog::level::err;
+ if (str == "CRITICAL") return spdlog::level::critical;
+ if (str == "OFF") return spdlog::level::off;
+
+ CUDF_FAIL("Invalid value for LIBCUDF_LOGGING_LEVEL environment variable");
+ }
+
+ logger_wrapper()
+ : logger_{"CUDF",
+ std::make_shared<spdlog::sinks::basic_file_sink_mt>(
+ default_log_filename(), true // truncate file
+ )}
+ {
+ logger_.set_pattern("[%6t][%H:%M:%S:%f][%-6l] %v");
+ logger_.flush_on(spdlog::level::warn);
+
+ auto const env_level = std::getenv("LIBCUDF_LOGGING_LEVEL");
+ if (env_level != nullptr) { logger_.set_level(spdlog_level_from_string(env_level)); }
+ }
+};
+
+spdlog::logger& logger()
+{
+ static logger_wrapper wrapped{};
+ return wrapped.logger_;
+}
+
+} // namespace cudf