optimize CacheLocality load-time init from sysfs on aarch64

Summary:
There are a few tricks we can do to optimize reading from the sysfs tree.
* `openat` vs `open` to reduce the cost of path-walking.
* `read` each file fully into a big-enough stack buffer v.s. going through `ifstream` and `getline`. The files are single-line and tiny.
* When we need two files together, only read the second one if reading from the first one succeeded. We use failed reads as sentinels.

Reduces cold init cost from >=5ms to >=4ms on one dev server.

Reviewed By: dmm-fb

Differential Revision: D78570201

fbshipit-source-id: c946e9fdffe654b5f47b8c41200810314b0ec809

Author: yfeldblum

folly/concurrency/BUCK

@@ -119,8 +119,10 @@ non_fbcode_target(
         "//third-party/glog:glog",
         "//xplat/folly:hash_hash",
         "//xplat/folly:optional",
+        "//xplat/folly:portability_fcntl",
         "//xplat/folly:portability_unistd",
         "//xplat/folly:system_thread_id",
+        "//xplat/folly/container:reserve",
         "//xplat/folly/lang:exception",
     ],
     exported_deps = [
@@ -227,9 +229,11 @@ fbcode_target(
         "//folly:indestructible",
         "//folly:memory",
         "//folly:scope_guard",
+        "//folly/container:reserve",
         "//folly/detail:static_singleton_manager",
         "//folly/hash:hash",
         "//folly/lang:exception",
+        "//folly/portability:fcntl",
         "//folly/portability:unistd",
         "//folly/system:thread_id",
     ],

folly/concurrency/CacheLocality.cpp

@@ -20,6 +20,7 @@
 #define _GNU_SOURCE 1 // for RTLD_NOLOAD
 #include <dlfcn.h>
 #endif
+#include <filesystem>
 #include <fstream>
 #include <mutex>
 #include <numeric>
@@ -31,9 +32,11 @@
 #include <folly/Indestructible.h>
 #include <folly/Memory.h>
 #include <folly/ScopeGuard.h>
+#include <folly/container/Reserve.h>
 #include <folly/detail/StaticSingletonManager.h>
 #include <folly/hash/Hash.h>
 #include <folly/lang/Exception.h>
+#include <folly/portability/Fcntl.h>
 #include <folly/portability/Unistd.h>
 #include <folly/system/ThreadId.h>
 
@@ -179,30 +182,67 @@ static size_t parseLeadingNumber(const std::string& line) {
   return val;
 }
 
-CacheLocality CacheLocality::readFromSysfsTree(
-    const std::function<std::string(std::string const&)>& mapping) {
+CacheLocality CacheLocality::readFromSysfsTree(std::string_view root) {
+#if defined(_WIN32)
+  // windows does not have openat and open flag constants
+  return CacheLocality::uniform(0);
+#else
+
   // the list of cache equivalence classes, where equivalence classes
   // are named by the smallest cpu in the class
   std::vector<std::vector<size_t>> equivClassesByCpu;
 
+  auto rdfile = [&](auto dirfd, auto name) {
+    auto fd = ::openat(dirfd, name.c_str(), O_CLOEXEC, O_RDONLY);
+    if (fd < 0) {
+      return std::string(); // stop condition for the inner loop below
+    }
+    auto fdg = makeGuard([=] { ::close(fd); });
+    alignas(64) char buf[64];
+    int ret = 0;
+    do {
+      ret = ::pread(fd, buf, sizeof(buf), 0);
+    } while (ret < 0 && errno == EINVAL);
+    if (ret < 0) {
+      return std::string();
+    }
+    return std::string(buf, to_unsigned(ret));
+  };
+
+  auto subroot = std::filesystem::path(root) / "sys/devices/system/cpu";
+  int allfd = ::open(subroot.c_str(), O_DIRECTORY | O_CLOEXEC, O_RDONLY);
+  assert(allfd >= 0);
+  size_t maxindex = 0;
   for (size_t cpu = 0;; ++cpu) {
+    auto cpuroot = fmt::format("cpu{}/cache", cpu);
+    int cpufd =
+        ::openat(allfd, cpuroot.c_str(), O_DIRECTORY | O_CLOEXEC, O_RDONLY);
+    if (cpufd < 0) {
+      break;
+    }
     std::vector<size_t> levels;
+    grow_capacity_by(levels, maxindex);
     for (size_t index = 0;; ++index) {
-      auto dir = fmt::format(
-          "/sys/devices/system/cpu/cpu{}/cache/index{}/", cpu, index);
-      auto cacheType = mapping(dir + "type");
-      auto equivStr = mapping(dir + "shared_cpu_list");
-      if (cacheType.empty() || equivStr.empty()) {
+      auto dir = fmt::format("index{}/", index);
+      auto cacheType = rdfile(cpufd, dir + "type");
+      if (cacheType.empty()) {
         // no more caches
         break;
       }
       if (cacheType[0] == 'I') {
         // cacheType in { "Data", "Instruction", "Unified" }. skip icache
         continue;
       }
+      // only try to read the second file once we know we will need it
+      auto equivStr = rdfile(cpufd, dir + "shared_cpu_list");
+      if (equivStr.empty()) {
+        // no more caches
+        break;
+      }
       auto equiv = parseLeadingNumber(equivStr);
       levels.push_back(equiv);
     }
+    maxindex = std::max(maxindex, levels.size());
 
     if (levels.empty()) {
       // no levels at all for this cpu, we must be done
@@ -216,15 +256,12 @@ CacheLocality CacheLocality::readFromSysfsTree(
   }
 
   return CacheLocality{std::move(equivClassesByCpu)};
+
+#endif
 }
 
 CacheLocality CacheLocality::readFromSysfs() {
-  return readFromSysfsTree([](std::string const& name) {
-    std::ifstream xi(name.c_str());
-    std::string rv;
-    std::getline(xi, rv);
-    return rv;
-  });
+  return readFromSysfsTree();
 }
 
 namespace {

folly/concurrency/CacheLocality.h

@@ -23,6 +23,7 @@
 #include <functional>
 #include <limits>
 #include <string>
+#include <string_view>
 #include <type_traits>
 #include <vector>
 
@@ -106,8 +107,7 @@ struct CacheLocality {
   /// not exist.  The function will be called with paths of the form
   /// /sys/devices/system/cpu/cpu*/cache/index*/{type,shared_cpu_list} .
   /// Throws an exception if no caches can be parsed at all.
-  static CacheLocality readFromSysfsTree(
-      const std::function<std::string(std::string const&)>& mapping);
+  static CacheLocality readFromSysfsTree(std::string_view root = "/");
 
   /// Reads CacheLocality information from the real sysfs filesystem.
   /// Throws an exception if no cache information can be loaded.

folly/concurrency/test/BUCK

@@ -63,6 +63,7 @@ fbcode_target(
         "//folly/portability:sys_resource",
         "//folly/portability:unistd",
         "//folly/test:test_utils",
+        "//folly/testing:test_util",
     ],
     external_deps = [
         "glog",

folly/concurrency/test/CacheLocalityTest.cpp

@@ -26,11 +26,14 @@
 #include <folly/portability/SysResource.h>
 #include <folly/portability/Unistd.h>
 #include <folly/test/TestUtils.h>
+#include <folly/testing/TestUtil.h>
 
 #include <glog/logging.h>
 
 using namespace folly;
 
+#if !defined(_WIN32)
+
 /// This is the relevant nodes from a production box's sysfs tree.  If you
 /// think this map is ugly you should see the version of this test that
 /// used a real directory tree.  To reduce the chance of testing error
@@ -309,10 +312,14 @@ static std::unordered_map<std::string, std::string> fakeSysfsTree = {
     {"/sys/devices/system/cpu/cpu31/cache/index3/type", "Unified"}};
 
 TEST(CacheLocality, FakeSysfs) {
-  auto parsed = CacheLocality::readFromSysfsTree([](std::string name) {
-    auto iter = fakeSysfsTree.find(name);
-    return iter == fakeSysfsTree.end() ? std::string() : iter->second;
-  });
+  folly::test::TemporaryDirectory tmpdir;
+  for (const auto& [k, v] : fakeSysfsTree) {
+    auto path = tmpdir.path() / k;
+    fs::create_directories(path.parent_path());
+    std::ofstream(path.string()) << v << std::endl;
+  }
+  auto root = tmpdir.path();
+  auto parsed = CacheLocality::readFromSysfsTree(tmpdir.path().string());
 
   size_t expectedNumCpus = 32;
   std::vector<size_t> expectedNumCachesByLevel = {16, 16, 2};
@@ -325,6 +332,8 @@ TEST(CacheLocality, FakeSysfs) {
   EXPECT_EQ(expectedLocalityIndexByCpu, parsed.localityIndexByCpu);
 }
 
+#endif
+
 static const std::vector<std::string> fakeProcCpuinfo = {
     "processor	: 0",
     "vendor_id	: GenuineIntel",