Add FOLLY_AVAILABLE_CONCURRENCY_MAX env var

Summary:
Allow overriding folly::available_concurrency() via the
FOLLY_AVAILABLE_CONCURRENCY_MAX environment variable. When set to a valid
positive integer, the returned value is capped to the minimum of the env
var and the OS-reported count (sched_getaffinity on Linux). This ensures
the value is never higher than either signal.

This is needed to support removing CPU pinning for overcommitted
Tupperware tasks. Without pinning, sched_getaffinity returns all host
CPUs, causing massive over-threading in Thrift servers, GlobalExecutor,
ServiceRouter, etc. The env var lets TW Agent set the correct concurrency
for unpinned containers.

Reviewed By: yfeldblum

Differential Revision: D94916141

fbshipit-source-id: fa1c916a9a06a9dcc71cc04271d83d00b15fdc66

Author: Dan Schatzberg

third-party/folly/src/folly/system/CMakeLists.txt

@@ -62,9 +62,12 @@ folly_add_library(
   HEADERS
     HardwareConcurrency.h
   DEPS
+    folly_conv
     folly_lang_safe_assert
     folly_portability_sched
     folly_utility
+  EXPORTED_DEPS
+    folly_lang_cstring_view
 )
 
 folly_add_library(

third-party/folly/src/folly/system/HardwareConcurrency.cpp

@@ -16,9 +16,12 @@
 
 #include <folly/system/HardwareConcurrency.h>
 
+#include <algorithm>
 #include <atomic>
+#include <cstdlib>
 #include <thread>
 
+#include <folly/Conv.h>
 #include <folly/Utility.h>
 #include <folly/lang/SafeAssert.h>
 #include <folly/portability/Sched.h>
@@ -124,12 +127,24 @@ cpu_set_state::~cpu_set_state() {
 #endif
 
 unsigned int available_concurrency() noexcept {
+  unsigned int count;
 #if defined(__linux__) && !defined(__ANDROID__)
   cpu_set_t stackset;
-  return to_narrow(cpu_set_state::ask(&stackset).cpu_count());
+  count = to_narrow(cpu_set_state::ask(&stackset).cpu_count());
+#else
+  count = std::thread::hardware_concurrency();
 #endif
 
-  return std::thread::hardware_concurrency();
+  // Allow overriding via environment variable. The returned value is capped to
+  // the smaller of the env var and the OS-reported count.
+  if (auto const* env = std::getenv(available_concurrency_max_env.c_str())) {
+    auto val = folly::tryTo<unsigned int>(env).value_or(0);
+    if (val > 0) {
+      count = std::min(count, val);
+    }
+  }
+
+  return count;
 }
 
 } // namespace folly

third-party/folly/src/folly/system/HardwareConcurrency.h

@@ -18,8 +18,14 @@
 
 #include <utility>
 
+#include <folly/lang/cstring_view.h>
+
 namespace folly {
 
+/// The environment variable name used to cap available_concurrency().
+inline constexpr cstring_view available_concurrency_max_env =
+    "FOLLY_AVAILABLE_CONCURRENCY_MAX";
+
 /// available_concurrency
 ///
 /// Returns a number suitable for use as a size for thread-pools or as a size
@@ -50,6 +56,9 @@ namespace folly {
 /// * The result of std::thread::hardware_concurrency (all).
 /// * The result of get_nprocs, get_nprocs_conf, or sysconf as noted above.
 /// * The result of sched_getaffinity (linux but not android).
+/// * The FOLLY_AVAILABLE_CONCURRENCY_MAX environment variable, if set to a
+///   valid positive integer. The returned value is capped to the minimum of
+///   this and the OS-reported count.
 /// * Unspecified others....
 ///
 /// mimic: std::thread::hardware_concurrency

third-party/folly/src/folly/system/test/HardwareConcurrencyTest.cpp

@@ -16,9 +16,36 @@
 
 #include <folly/system/HardwareConcurrency.h>
 
+#include <cstdlib>
+
 #include <folly/portability/GTest.h>
+#include <folly/system/EnvUtil.h>
 
 TEST(HardwareConcurrency, ReturnsNonzero) {
   auto concurrency = folly::available_concurrency();
   EXPECT_GT(concurrency, 0u);
 }
+
+TEST(HardwareConcurrency, EnvVarOverride) {
+  folly::test::EnvVarSaver saver;
+  ::setenv(folly::available_concurrency_max_env.c_str(), "1", 1);
+  EXPECT_EQ(folly::available_concurrency(), 1u);
+}
+
+TEST(HardwareConcurrency, EnvVarInvalidIgnored) {
+  folly::test::EnvVarSaver saver;
+  ::setenv(folly::available_concurrency_max_env.c_str(), "garbage", 1);
+  EXPECT_GT(folly::available_concurrency(), 0u);
+}
+
+TEST(HardwareConcurrency, EnvVarZeroIgnored) {
+  folly::test::EnvVarSaver saver;
+  ::setenv(folly::available_concurrency_max_env.c_str(), "0", 1);
+  EXPECT_GT(folly::available_concurrency(), 0u);
+}
+
+TEST(HardwareConcurrency, EnvVarUnsetNormalBehavior) {
+  folly::test::EnvVarSaver saver;
+  ::unsetenv(folly::available_concurrency_max_env.c_str());
+  EXPECT_GT(folly::available_concurrency(), 0u);
+}