Revert "[Environment Variable][6/N] Use thread-safe getenv functions (pytorch#140200)"

This reverts commit 7d4f5f7.

Reverted pytorch#140200 on behalf of https://github.com/ezyang due to One of these diffs had incorrect downstream optional handling, we must reaudit all of these diffs ([comment](pytorch#140200 (comment)))

Author: pytorchmergebot

aten/src/ATen/core/type.cpp

@@ -7,7 +7,6 @@
 #include <ATen/core/grad_mode.h>
 #include <ATen/core/jit_type.h>
 #include <c10/macros/Macros.h>
-#include <c10/util/env.h>
 #include <c10/util/flat_hash_map.h>
 #include <c10/util/irange.h>
 #include <array>
@@ -46,9 +45,9 @@ static_assert(
     "getTypePtr<std::tuple<int64_t, int64_t>> not returning const ref!");
 
 TypeVerbosity type_verbosity() {
-  static const auto c_verbosity = c10::utils::get_env("PYTORCH_JIT_TYPE_VERBOSITY");
+  static const char* c_verbosity = std::getenv("PYTORCH_JIT_TYPE_VERBOSITY");
   static TypeVerbosity verbosity = c_verbosity ?
-    static_cast<TypeVerbosity>(std::stoi(c_verbosity.value())) : TypeVerbosity::Default;
+    static_cast<TypeVerbosity>(std::stoi(c_verbosity)) : TypeVerbosity::Default;
   return verbosity;
 }
 

aten/src/ATen/native/DispatchStub.cpp

@@ -3,7 +3,6 @@
 
 #include <c10/core/DeviceType.h>
 #include <c10/util/Exception.h>
-#include <c10/util/env.h>
 
 #if !defined(__s390x__) && !defined(__powerpc__)
 #include <cpuinfo.h>
@@ -25,20 +24,20 @@ static inline bool cpu_has_vxe()
 #endif
 
 static CPUCapability compute_cpu_capability() {
-  const auto envar = c10::utils::get_env("ATEN_CPU_CAPABILITY");
-  if (envar.has_value()) {
+  auto envar = std::getenv("ATEN_CPU_CAPABILITY");
+  if (envar) {
 #if defined(HAVE_VSX_CPU_DEFINITION)
-    if (envar == "vsx") {
+    if (strcmp(envar, "vsx") == 0) {
       return CPUCapability::VSX;
     }
 #elif defined(HAVE_ZVECTOR_CPU_DEFINITION)
-    if (envar == "zvector") {
+    if (strcmp(envar, "zvector") == 0) {
       return CPUCapability::ZVECTOR;
     }
 #elif defined(HAVE_SVE_CPU_DEFINITION)
     int sve_vl = cpuinfo_get_max_arm_sve_length(); //Returns maximum SVE VL supported by your HW.
 #ifdef HAVE_SVE256_CPU_DEFINITION
-    if (envar == "sve256") {
+    if (strcmp(envar, "sve256") == 0) {
       if (sve_vl == 256) {
         return CPUCapability::SVE256;
       }
@@ -48,20 +47,20 @@ static CPUCapability compute_cpu_capability() {
 #endif
 #else
 #ifdef HAVE_AVX512_CPU_DEFINITION
-    if (envar == "avx512") {
+    if (strcmp(envar, "avx512") == 0) {
       return CPUCapability::AVX512;
     }
 #endif
 #ifdef HAVE_AVX2_CPU_DEFINITION
-    if (envar == "avx2") {
+    if (strcmp(envar, "avx2") == 0) {
       return CPUCapability::AVX2;
     }
 #endif
 #endif
-    if (envar == "default") {
+    if (strcmp(envar, "default") == 0) {
       return CPUCapability::DEFAULT;
     }
-    TORCH_WARN("ignoring invalid value for ATEN_CPU_CAPABILITY: ", envar.value());
+    TORCH_WARN("ignoring invalid value for ATEN_CPU_CAPABILITY: ", envar);
   }
 
 #if !defined(__powerpc__) && !defined(__s390x__) && !defined(HAVE_SVE_CPU_DEFINITION)

aten/src/ATen/native/Linear.cpp

@@ -40,8 +40,16 @@ namespace at::native {
 // Parse environment variable "TORCH_LINEAR_FLATTEN_3D"
 static inline bool parseLinearFlatten3d() {
   // Uninitialized value
-  static auto value = c10::utils::check_env("TORCH_LINEAR_FLATTEN_3D");
-  return value.has_value() && value.value();
+  static int value = -1;
+  if (value == -1) {
+    const char* env_str = std::getenv("TORCH_LINEAR_FLATTEN_3D");
+    if (env_str != nullptr && strcmp(env_str, "1") == 0) {
+      value = 1;
+    } else {
+      value = 0;
+    }
+  }
+  return bool(value);
 }
 
 // `_flatten_nd_linear` flattens all but the last dimension of the input tensor

aten/src/ATen/native/cuda/Blas.cpp

@@ -179,8 +179,8 @@ cuda::blas::GEMMAndBiasActivationEpilogue activation_to_gemm_and_blas_arg(Activa
 }
 
 static bool getDisableAddmmCudaLt() {
-    static const auto env_value = c10::utils::get_env("DISABLE_ADDMM_CUDA_LT");
-    if (env_value == "1") {
+    static const char* env_value = std::getenv("DISABLE_ADDMM_CUDA_LT");
+    if (env_value != nullptr && strcmp(env_value, "1") == 0) {
       return true;
     }
     return false;

aten/src/ATen/native/cuda/jit_utils.cpp

@@ -1395,40 +1395,40 @@ std::string generate_reduction_code(
 // Acquires (possibly creating) the kernel cache directory
 std::optional<std::string> get_cache_dir() {
   // If the environment variable USE_TORCH_KERNEL_CACHE is set to "0" then no persistent cache is used
-  const auto uptkc = c10::utils::get_env("USE_PYTORCH_KERNEL_CACHE");
-  const bool use_kernel_cache = (uptkc != "0");
+  const char* uptkc = std::getenv("USE_PYTORCH_KERNEL_CACHE");
+  const bool use_kernel_cache = (uptkc == nullptr) ? true : std::strcmp(uptkc, "0");
 
   if (!use_kernel_cache) {
     return {};
   }
 
   // Cache path comes from PYTORCH_KERNEL_CACHE_PATH, then TEMP (Windows) or XDG_CACHE_HOME (Linux), then HOME environment variables
   std::string cache_dir;
-  auto ptkcp = c10::utils::get_env("PYTORCH_KERNEL_CACHE_PATH");
+  char* ptkcp = std::getenv("PYTORCH_KERNEL_CACHE_PATH");
   // Create kernel_cache_dir if needed as we do not want to create the base directory passed by the user
   std::string kernels_cache_dir = "";
-  if (ptkcp.has_value()) {
-    cache_dir = ptkcp.value();
+  if (ptkcp != nullptr) {
+    cache_dir = std::string(ptkcp);
   } else {
 #ifdef _WIN32
-    ptkcp = c10::utils::get_env("TEMP");
+    ptkcp = std::getenv("TEMP");
 #else
     // USES XDG_CACHE_HOME if it's set
-    ptkcp = c10::utils::get_env("XDG_CACHE_HOME");
+    ptkcp = std::getenv("XDG_CACHE_HOME");
 #endif
-    if (ptkcp.has_value()) {
+    if (ptkcp != nullptr) {
       kernels_cache_dir = "/torch/kernels";
-      cache_dir = ptkcp.value() + kernels_cache_dir;
+      cache_dir = std::string(ptkcp) + kernels_cache_dir;
     } else {
       // Falls back to HOME/.cache
-      ptkcp = c10::utils::get_env("HOME");
-      if (ptkcp.has_value()) {
+      ptkcp = std::getenv("HOME");
+      if (ptkcp == nullptr) {
         TORCH_WARN_ONCE("No PYTORCH_KERNEL_CACHE_PATH or HOME environment variable set!",
                         " This disables kernel caching.");
         return {};
       } else {
         kernels_cache_dir = "/.cache/torch/kernels";
-        cache_dir = ptkcp.value() + kernels_cache_dir;
+        cache_dir = std::string(ptkcp) + kernels_cache_dir;
       }
     }
   }
@@ -1437,7 +1437,7 @@ std::optional<std::string> get_cache_dir() {
   const char* p_cache_dir = cache_dir.c_str();
   const bool cache_dir_exists = (access(p_cache_dir, F_OK) == 0);
   if (!cache_dir_exists) {
-    std::string s_ptkcp = ptkcp.value();
+    std::string s_ptkcp = std::string(ptkcp);
     if (!r_mkdir_with_base(s_ptkcp, kernels_cache_dir)) {
       TORCH_WARN_ONCE("Specified kernel cache directory could not be created! This disables kernel caching.",
                       " Specified directory is ", cache_dir, ".",

c10/util/env.cpp

@@ -77,10 +77,10 @@ bool has_env(const char* name) noexcept {
 std::optional<bool> check_env(const char* name) {
   auto env_opt = get_env(name);
   if (env_opt.has_value()) {
-    if (env_opt == "0") {
+    if (*env_opt == "0") {
       return false;
     }
-    if (env_opt == "1") {
+    if (*env_opt == "1") {
       return true;
     }
     TORCH_WARN(

torch/csrc/distributed/c10d/Utils.hpp

@@ -128,15 +128,15 @@ inline int getCvarInt(const std::vector<std::string>& env, int def) {
    * versions of a variable get higher priority than the latter
    * versions of the same variable */
   for (ssize_t i = static_cast<ssize_t>(env.size()) - 1; i >= 0; i--) {
-    const auto val = c10::utils::get_env(env[i].c_str());
-    if (!val.has_value()) {
+    char* val = std::getenv(env[i].c_str());
+    if (val == nullptr) {
       continue;
     } else if (i) {
       WARN_ENV_VAR_ONCE(env[i], env[0]);
     }
 
     try {
-      ret = std::stoi(val.value());
+      ret = std::stoi(val);
     } catch (std::exception&) {
       TORCH_CHECK(false, "Invalid value for environment variable: " + env[i]);
     }

torch/csrc/jit/frontend/ir_emitter.cpp

@@ -3,7 +3,6 @@
 
 #include <c10/util/Exception.h>
 #include <c10/util/StringUtil.h>
-#include <c10/util/env.h>
 #include <c10/util/irange.h>
 #include <caffe2/serialize/versions.h>
 #include <torch/csrc/jit/api/function_impl.h>
@@ -48,11 +47,12 @@ bool reportSourceLocation(size_t file_size) {
   if (file_size < 512ull * 1024) {
     return true;
   }
-  const auto enable_env =
-      c10::utils::get_env("PYTORCH_JIT_ENABLE_LARGE_SOURCE_LOCATION");
+  const char* enable_env =
+      std::getenv("PYTORCH_JIT_ENABLE_LARGE_SOURCE_LOCATION");
   bool flag = true;
-  if (!enable_env.has_value() || enable_env == "0" || enable_env == "FALSE" ||
-      enable_env == "false") {
+  if (enable_env == nullptr || std::strcmp(enable_env, "0") == 0 ||
+      std::strcmp(enable_env, "FALSE") == 0 ||
+      std::strcmp(enable_env, "false") == 0) {
     flag = false;
   }
   return flag;

torch/csrc/jit/jit_log.cpp

@@ -9,7 +9,6 @@
 #include <ATen/core/function.h>
 #include <c10/util/Exception.h>
 #include <c10/util/StringUtil.h>
-#include <c10/util/env.h>
 #include <torch/csrc/jit/api/function_impl.h>
 #include <torch/csrc/jit/frontend/error_report.h>
 #include <torch/csrc/jit/ir/ir.h>
@@ -33,10 +32,8 @@ class JitLoggingConfig {
   std::ostream* out;
 
   JitLoggingConfig() : out(&std::cerr) {
-    const auto jit_log_level = c10::utils::get_env("PYTORCH_JIT_LOG_LEVEL");
-    if (jit_log_level.has_value()) {
-      logging_levels = jit_log_level.value();
-    }
+    const char* jit_log_level = std::getenv("PYTORCH_JIT_LOG_LEVEL");
+    logging_levels.assign(jit_log_level == nullptr ? "" : jit_log_level);
 
     parse();
   }

torch/csrc/jit/jit_opt_limit.cpp

@@ -1,12 +1,13 @@
 #include <cstdlib>
+#include <iomanip>
 #include <sstream>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include <ATen/core/function.h>
 #include <c10/util/Exception.h>
 #include <c10/util/StringUtil.h>
-#include <c10/util/env.h>
 #include <torch/csrc/jit/api/function_impl.h>
 #include <torch/csrc/jit/jit_opt_limit.h>
 
@@ -48,14 +49,14 @@ static std::unordered_map<std::string, int64_t> parseJITOptLimitOption(
 }
 
 bool opt_limit(const char* pass_name) {
-  static const auto opt_limit = c10::utils::get_env("PYTORCH_JIT_OPT_LIMIT");
+  static const char* opt_limit = std::getenv("PYTORCH_JIT_OPT_LIMIT");
   // if nothing is provided, let's allow everything
-  if (!opt_limit.has_value()) {
+  if (!opt_limit) {
     return true;
   }
 
   static const std::unordered_map<std::string, int64_t> passes_to_opt_limits =
-      parseJITOptLimitOption(opt_limit->c_str());
+      parseJITOptLimitOption(opt_limit);
   std::string pass{pass_name};
   pass = c10::detail::StripBasename(pass);
   pass = c10::detail::ExcludeFileExtension(pass);

torch/csrc/jit/passes/tensorexpr_fuser.cpp

@@ -155,11 +155,11 @@ void setTensorExprFuserEnabled(bool val) {
 }
 
 bool tensorExprFuserEnabled() {
-  static const auto enable_opt = c10::utils::get_env("PYTORCH_TENSOREXPR");
-  if (!enable_opt.has_value()) {
+  static const char* enable_c_str = std::getenv("PYTORCH_TENSOREXPR");
+  if (!enable_c_str) {
     return texpr_fuser_enabled_;
   }
-  if (enable_opt == "0") {
+  if (std::string(enable_c_str) == "0") {
     return false;
   }
   return true;
@@ -1293,10 +1293,10 @@ class TensorExprFuser {
   // 'PYTORCH_TENSOREXPR_DONT_FUSE="clamp:mul:add"' disables fusion on
   // aten::clamp, aten::mul and aten::add.
   void parseTENotFuseOption() {
-    const auto option = c10::utils::get_env("PYTORCH_TENSOREXPR_DONT_FUSE");
+    const char* option = std::getenv("PYTORCH_TENSOREXPR_DONT_FUSE");
     std::stringstream in_ss;
-    if (option.has_value()) {
-      in_ss << option.value();
+    if (option) {
+      in_ss << option;
     }
 
     std::string line;

torch/csrc/jit/runtime/graph_executor.cpp

@@ -864,7 +864,7 @@ bool GraphExecutor::isOptimized() const {
 
 TORCH_API bool IsNewExecutorEnabled() {
   static const auto disable_new_executor =
-      c10::utils::has_env("TORCH_JIT_DISABLE_NEW_EXECUTOR");
+      std::getenv("TORCH_JIT_DISABLE_NEW_EXECUTOR");
   return getExecutorMode() && FLAGS_torch_jit_enable_new_executor &&
       !disable_new_executor;
 }

torch/csrc/jit/tensorexpr/kernel.cpp

@@ -54,49 +54,47 @@ bool setFallbackAllowed(bool value) {
 }
 
 bool fallbackAllowed() {
-  static const auto enable_opt =
-      c10::utils::get_env("PYTORCH_TENSOREXPR_FALLBACK");
-  if (!enable_opt.has_value()) {
+  static const char* enable_c_str = std::getenv("PYTORCH_TENSOREXPR_FALLBACK");
+  if (!enable_c_str) {
     return fallback_allowed;
   }
-  if (enable_opt == "0") {
+  if (std::string(enable_c_str) == "0") {
     return false;
   }
   return true;
 }
 
 static bool fallbackEnforced() {
-  static const auto enable_opt =
-      c10::utils::get_env("PYTORCH_TENSOREXPR_FALLBACK");
+  static const char* enable_c_str = std::getenv("PYTORCH_TENSOREXPR_FALLBACK");
   if (tensorexpr::getTEGenerateBlockCode()) {
     return false;
   }
-  if (!enable_opt.has_value()) {
+  if (!enable_c_str) {
     return fallback_allowed;
   }
-  if (enable_opt == "2") {
+  if (std::string(enable_c_str) == "2") {
     return true;
   }
   return false;
 }
 
 static int64_t randomTransformsRequested() {
-  const auto enable_opt =
-      c10::utils::get_env("PYTORCH_TENSOREXPR_RANDOM_TRANSFORM_SEED");
-  if (!enable_opt.has_value()) {
+  const char* enable_c_str =
+      std::getenv("PYTORCH_TENSOREXPR_RANDOM_TRANSFORM_SEED");
+  if (!enable_c_str) {
     return 0;
   }
-  return std::stoi(enable_opt.value());
+  return std::stoi(std::string(enable_c_str));
 }
 
 #ifdef TORCH_ENABLE_LLVM
 static bool dontUseLLVMFlag() {
-  static const auto enable_opt =
-      c10::utils::get_env("PYTORCH_TENSOREXPR_DONT_USE_LLVM");
-  if (!enable_opt) {
+  static const char* enable_c_str =
+      std::getenv("PYTORCH_TENSOREXPR_DONT_USE_LLVM");
+  if (!enable_c_str) {
     return false;
   }
-  return enable_opt == "1";
+  return std::string(enable_c_str) == "1";
 }
 #endif