data-structure-typed 2.4.0 → 2.4.2

package/build/_deps/benchmark-src/src/perf_counters.cc

@@ -1,282 +0,0 @@
-// Copyright 2021 Google Inc. All rights reserved.
-//
-// 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 "perf_counters.h"
-
-#include <cstring>
-#include <memory>
-#include <vector>
-
-#if defined HAVE_LIBPFM
-#include "perfmon/pfmlib.h"
-#include "perfmon/pfmlib_perf_event.h"
-#endif
-
-namespace benchmark {
-namespace internal {
-
-constexpr size_t PerfCounterValues::kMaxCounters;
-
-#if defined HAVE_LIBPFM
-
-size_t PerfCounterValues::Read(const std::vector<int>& leaders) {
-  // Create a pointer for multiple reads
-  const size_t bufsize = values_.size() * sizeof(values_[0]);
-  char* ptr = reinterpret_cast<char*>(values_.data());
-  size_t size = bufsize;
-  for (int lead : leaders) {
-    auto read_bytes = ::read(lead, ptr, size);
-    if (read_bytes >= ssize_t(sizeof(uint64_t))) {
-      // Actual data bytes are all bytes minus initial padding
-      std::size_t data_bytes = read_bytes - sizeof(uint64_t);
-      // This should be very cheap since it's in hot cache
-      std::memmove(ptr, ptr + sizeof(uint64_t), data_bytes);
-      // Increment our counters
-      ptr += data_bytes;
-      size -= data_bytes;
-    } else {
-      int err = errno;
-      GetErrorLogInstance() << "Error reading lead " << lead << " errno:" << err
-                            << " " << ::strerror(err) << "\n";
-      return 0;
-    }
-  }
-  return (bufsize - size) / sizeof(uint64_t);
-}
-
-const bool PerfCounters::kSupported = true;
-
-// Initializes libpfm only on the first call.  Returns whether that single
-// initialization was successful.
-bool PerfCounters::Initialize() {
-  // Function-scope static gets initialized only once on first call.
-  static const bool success = []() {
-    return pfm_initialize() == PFM_SUCCESS;
-  }();
-  return success;
-}
-
-bool PerfCounters::IsCounterSupported(const std::string& name) {
-  Initialize();
-  perf_event_attr_t attr;
-  std::memset(&attr, 0, sizeof(attr));
-  pfm_perf_encode_arg_t arg;
-  std::memset(&arg, 0, sizeof(arg));
-  arg.attr = &attr;
-  const int mode = PFM_PLM3;  // user mode only
-  int ret = pfm_get_os_event_encoding(name.c_str(), mode, PFM_OS_PERF_EVENT_EXT,
-                                      &arg);
-  return (ret == PFM_SUCCESS);
-}
-
-PerfCounters PerfCounters::Create(
-    const std::vector<std::string>& counter_names) {
-  if (!counter_names.empty()) {
-    Initialize();
-  }
-
-  // Valid counters will populate these arrays but we start empty
-  std::vector<std::string> valid_names;
-  std::vector<int> counter_ids;
-  std::vector<int> leader_ids;
-
-  // Resize to the maximum possible
-  valid_names.reserve(counter_names.size());
-  counter_ids.reserve(counter_names.size());
-
-  const int kCounterMode = PFM_PLM3;  // user mode only
-
-  // Group leads will be assigned on demand. The idea is that once we cannot
-  // create a counter descriptor, the reason is that this group has maxed out
-  // so we set the group_id again to -1 and retry - giving the algorithm a
-  // chance to create a new group leader to hold the next set of counters.
-  int group_id = -1;
-
-  // Loop through all performance counters
-  for (size_t i = 0; i < counter_names.size(); ++i) {
-    // we are about to push into the valid names vector
-    // check if we did not reach the maximum
-    if (valid_names.size() == PerfCounterValues::kMaxCounters) {
-      // Log a message if we maxed out and stop adding
-      GetErrorLogInstance()
-          << counter_names.size() << " counters were requested. The maximum is "
-          << PerfCounterValues::kMaxCounters << " and " << valid_names.size()
-          << " were already added. All remaining counters will be ignored\n";
-      // stop the loop and return what we have already
-      break;
-    }
-
-    // Check if this name is empty
-    const auto& name = counter_names[i];
-    if (name.empty()) {
-      GetErrorLogInstance()
-          << "A performance counter name was the empty string\n";
-      continue;
-    }
-
-    // Here first means first in group, ie the group leader
-    const bool is_first = (group_id < 0);
-
-    // This struct will be populated by libpfm from the counter string
-    // and then fed into the syscall perf_event_open
-    struct perf_event_attr attr {};
-    attr.size = sizeof(attr);
-
-    // This is the input struct to libpfm.
-    pfm_perf_encode_arg_t arg{};
-    arg.attr = &attr;
-    const int pfm_get = pfm_get_os_event_encoding(name.c_str(), kCounterMode,
-                                                  PFM_OS_PERF_EVENT, &arg);
-    if (pfm_get != PFM_SUCCESS) {
-      GetErrorLogInstance()
-          << "Unknown performance counter name: " << name << "\n";
-      continue;
-    }
-
-    // We then proceed to populate the remaining fields in our attribute struct
-    // Note: the man page for perf_event_create suggests inherit = true and
-    // read_format = PERF_FORMAT_GROUP don't work together, but that's not the
-    // case.
-    attr.disabled = is_first;
-    attr.inherit = true;
-    attr.pinned = is_first;
-    attr.exclude_kernel = true;
-    attr.exclude_user = false;
-    attr.exclude_hv = true;
-
-    // Read all counters in a group in one read.
-    attr.read_format = PERF_FORMAT_GROUP;
-
-    int id = -1;
-    while (id < 0) {
-      static constexpr size_t kNrOfSyscallRetries = 5;
-      // Retry syscall as it was interrupted often (b/64774091).
-      for (size_t num_retries = 0; num_retries < kNrOfSyscallRetries;
-           ++num_retries) {
-        id = perf_event_open(&attr, 0, -1, group_id, 0);
-        if (id >= 0 || errno != EINTR) {
-          break;
-        }
-      }
-      if (id < 0) {
-        // If the file descriptor is negative we might have reached a limit
-        // in the current group. Set the group_id to -1 and retry
-        if (group_id >= 0) {
-          // Create a new group
-          group_id = -1;
-        } else {
-          // At this point we have already retried to set a new group id and
-          // failed. We then give up.
-          break;
-        }
-      }
-    }
-
-    // We failed to get a new file descriptor. We might have reached a hard
-    // hardware limit that cannot be resolved even with group multiplexing
-    if (id < 0) {
-      GetErrorLogInstance() << "***WARNING** Failed to get a file descriptor "
-                               "for performance counter "
-                            << name << ". Ignoring\n";
-
-      // We give up on this counter but try to keep going
-      // as the others would be fine
-      continue;
-    }
-    if (group_id < 0) {
-      // This is a leader, store and assign it to the current file descriptor
-      leader_ids.push_back(id);
-      group_id = id;
-    }
-    // This is a valid counter, add it to our descriptor's list
-    counter_ids.push_back(id);
-    valid_names.push_back(name);
-  }
-
-  // Loop through all group leaders activating them
-  // There is another option of starting ALL counters in a process but
-  // that would be far reaching an intrusion. If the user is using PMCs
-  // by themselves then this would have a side effect on them. It is
-  // friendlier to loop through all groups individually.
-  for (int lead : leader_ids) {
-    if (ioctl(lead, PERF_EVENT_IOC_ENABLE) != 0) {
-      // This should never happen but if it does, we give up on the
-      // entire batch as recovery would be a mess.
-      GetErrorLogInstance() << "***WARNING*** Failed to start counters. "
-                               "Claring out all counters.\n";
-
-      // Close all peformance counters
-      for (int id : counter_ids) {
-        ::close(id);
-      }
-
-      // Return an empty object so our internal state is still good and
-      // the process can continue normally without impact
-      return NoCounters();
-    }
-  }
-
-  return PerfCounters(std::move(valid_names), std::move(counter_ids),
-                      std::move(leader_ids));
-}
-
-void PerfCounters::CloseCounters() const {
-  if (counter_ids_.empty()) {
-    return;
-  }
-  for (int lead : leader_ids_) {
-    ioctl(lead, PERF_EVENT_IOC_DISABLE);
-  }
-  for (int fd : counter_ids_) {
-    close(fd);
-  }
-}
-#else   // defined HAVE_LIBPFM
-size_t PerfCounterValues::Read(const std::vector<int>&) { return 0; }
-
-const bool PerfCounters::kSupported = false;
-
-bool PerfCounters::Initialize() { return false; }
-
-bool PerfCounters::IsCounterSupported(const std::string&) { return false; }
-
-PerfCounters PerfCounters::Create(
-    const std::vector<std::string>& counter_names) {
-  if (!counter_names.empty()) {
-    GetErrorLogInstance() << "Performance counters not supported.";
-  }
-  return NoCounters();
-}
-
-void PerfCounters::CloseCounters() const {}
-#endif  // defined HAVE_LIBPFM
-
-PerfCountersMeasurement::PerfCountersMeasurement(
-    const std::vector<std::string>& counter_names)
-    : start_values_(counter_names.size()), end_values_(counter_names.size()) {
-  counters_ = PerfCounters::Create(counter_names);
-}
-
-PerfCounters& PerfCounters::operator=(PerfCounters&& other) noexcept {
-  if (this != &other) {
-    CloseCounters();
-
-    counter_ids_ = std::move(other.counter_ids_);
-    leader_ids_ = std::move(other.leader_ids_);
-    counter_names_ = std::move(other.counter_names_);
-  }
-  return *this;
-}
-}  // namespace internal
-}  // namespace benchmark

package/build/_deps/benchmark-src/src/perf_counters.h

@@ -1,200 +0,0 @@
-// Copyright 2021 Google Inc. All rights reserved.
-//
-// 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.
-
-#ifndef BENCHMARK_PERF_COUNTERS_H
-#define BENCHMARK_PERF_COUNTERS_H
-
-#include <array>
-#include <cstdint>
-#include <cstring>
-#include <memory>
-#include <vector>
-
-#include "benchmark/benchmark.h"
-#include "check.h"
-#include "log.h"
-#include "mutex.h"
-
-#ifndef BENCHMARK_OS_WINDOWS
-#include <unistd.h>
-#endif
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-// C4251: <symbol> needs to have dll-interface to be used by clients of class
-#pragma warning(disable : 4251)
-#endif
-
-namespace benchmark {
-namespace internal {
-
-// Typically, we can only read a small number of counters. There is also a
-// padding preceding counter values, when reading multiple counters with one
-// syscall (which is desirable). PerfCounterValues abstracts these details.
-// The implementation ensures the storage is inlined, and allows 0-based
-// indexing into the counter values.
-// The object is used in conjunction with a PerfCounters object, by passing it
-// to Snapshot(). The Read() method relocates individual reads, discarding
-// the initial padding from each group leader in the values buffer such that
-// all user accesses through the [] operator are correct.
-class BENCHMARK_EXPORT PerfCounterValues {
- public:
-  explicit PerfCounterValues(size_t nr_counters) : nr_counters_(nr_counters) {
-    BM_CHECK_LE(nr_counters_, kMaxCounters);
-  }
-
-  // We are reading correctly now so the values don't need to skip padding
-  uint64_t operator[](size_t pos) const { return values_[pos]; }
-
-  // Increased the maximum to 32 only since the buffer
-  // is std::array<> backed
-  static constexpr size_t kMaxCounters = 32;
-
- private:
-  friend class PerfCounters;
-  // Get the byte buffer in which perf counters can be captured.
-  // This is used by PerfCounters::Read
-  std::pair<char*, size_t> get_data_buffer() {
-    return {reinterpret_cast<char*>(values_.data()),
-            sizeof(uint64_t) * (kPadding + nr_counters_)};
-  }
-
-  // This reading is complex and as the goal of this class is to
-  // abstract away the intrincacies of the reading process, this is
-  // a better place for it
-  size_t Read(const std::vector<int>& leaders);
-
-  // Move the padding to 2 due to the reading algorithm (1st padding plus a
-  // current read padding)
-  static constexpr size_t kPadding = 2;
-  std::array<uint64_t, kPadding + kMaxCounters> values_;
-  const size_t nr_counters_;
-};
-
-// Collect PMU counters. The object, once constructed, is ready to be used by
-// calling read(). PMU counter collection is enabled from the time create() is
-// called, to obtain the object, until the object's destructor is called.
-class BENCHMARK_EXPORT PerfCounters final {
- public:
-  // True iff this platform supports performance counters.
-  static const bool kSupported;
-
-  // Returns an empty object
-  static PerfCounters NoCounters() { return PerfCounters(); }
-
-  ~PerfCounters() { CloseCounters(); }
-  PerfCounters() = default;
-  PerfCounters(PerfCounters&&) = default;
-  PerfCounters(const PerfCounters&) = delete;
-  PerfCounters& operator=(PerfCounters&&) noexcept;
-  PerfCounters& operator=(const PerfCounters&) = delete;
-
-  // Platform-specific implementations may choose to do some library
-  // initialization here.
-  static bool Initialize();
-
-  // Check if the given counter is supported, if the app wants to
-  // check before passing
-  static bool IsCounterSupported(const std::string& name);
-
-  // Return a PerfCounters object ready to read the counters with the names
-  // specified. The values are user-mode only. The counter name format is
-  // implementation and OS specific.
-  // In case of failure, this method will in the worst case return an
-  // empty object whose state will still be valid.
-  static PerfCounters Create(const std::vector<std::string>& counter_names);
-
-  // Take a snapshot of the current value of the counters into the provided
-  // valid PerfCounterValues storage. The values are populated such that:
-  // names()[i]'s value is (*values)[i]
-  BENCHMARK_ALWAYS_INLINE bool Snapshot(PerfCounterValues* values) const {
-#ifndef BENCHMARK_OS_WINDOWS
-    assert(values != nullptr);
-    return values->Read(leader_ids_) == counter_ids_.size();
-#else
-    (void)values;
-    return false;
-#endif
-  }
-
-  const std::vector<std::string>& names() const { return counter_names_; }
-  size_t num_counters() const { return counter_names_.size(); }
-
- private:
-  PerfCounters(const std::vector<std::string>& counter_names,
-               std::vector<int>&& counter_ids, std::vector<int>&& leader_ids)
-      : counter_ids_(std::move(counter_ids)),
-        leader_ids_(std::move(leader_ids)),
-        counter_names_(counter_names) {}
-
-  void CloseCounters() const;
-
-  std::vector<int> counter_ids_;
-  std::vector<int> leader_ids_;
-  std::vector<std::string> counter_names_;
-};
-
-// Typical usage of the above primitives.
-class BENCHMARK_EXPORT PerfCountersMeasurement final {
- public:
-  PerfCountersMeasurement(const std::vector<std::string>& counter_names);
-
-  size_t num_counters() const { return counters_.num_counters(); }
-
-  std::vector<std::string> names() const { return counters_.names(); }
-
-  BENCHMARK_ALWAYS_INLINE bool Start() {
-    if (num_counters() == 0) return true;
-    // Tell the compiler to not move instructions above/below where we take
-    // the snapshot.
-    ClobberMemory();
-    valid_read_ &= counters_.Snapshot(&start_values_);
-    ClobberMemory();
-
-    return valid_read_;
-  }
-
-  BENCHMARK_ALWAYS_INLINE bool Stop(
-      std::vector<std::pair<std::string, double>>& measurements) {
-    if (num_counters() == 0) return true;
-    // Tell the compiler to not move instructions above/below where we take
-    // the snapshot.
-    ClobberMemory();
-    valid_read_ &= counters_.Snapshot(&end_values_);
-    ClobberMemory();
-
-    for (size_t i = 0; i < counters_.names().size(); ++i) {
-      double measurement = static_cast<double>(end_values_[i]) -
-                           static_cast<double>(start_values_[i]);
-      measurements.push_back({counters_.names()[i], measurement});
-    }
-
-    return valid_read_;
-  }
-
- private:
-  PerfCounters counters_;
-  bool valid_read_ = true;
-  PerfCounterValues start_values_;
-  PerfCounterValues end_values_;
-};
-
-}  // namespace internal
-}  // namespace benchmark
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-#endif  // BENCHMARK_PERF_COUNTERS_H

package/build/_deps/benchmark-src/src/re.h

@@ -1,158 +0,0 @@
-// Copyright 2015 Google Inc. All rights reserved.
-//
-// 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.
-
-#ifndef BENCHMARK_RE_H_
-#define BENCHMARK_RE_H_
-
-#include "internal_macros.h"
-
-// clang-format off
-
-#if !defined(HAVE_STD_REGEX) && \
-    !defined(HAVE_GNU_POSIX_REGEX) && \
-    !defined(HAVE_POSIX_REGEX)
-  // No explicit regex selection; detect based on builtin hints.
-  #if defined(BENCHMARK_OS_LINUX) || defined(BENCHMARK_OS_APPLE)
-    #define HAVE_POSIX_REGEX 1
-  #elif __cplusplus >= 199711L
-    #define HAVE_STD_REGEX 1
-  #endif
-#endif
-
-// Prefer C regex libraries when compiling w/o exceptions so that we can
-// correctly report errors.
-#if defined(BENCHMARK_HAS_NO_EXCEPTIONS) && \
-    defined(HAVE_STD_REGEX) && \
-    (defined(HAVE_GNU_POSIX_REGEX) || defined(HAVE_POSIX_REGEX))
-  #undef HAVE_STD_REGEX
-#endif
-
-#if defined(HAVE_STD_REGEX)
-  #include <regex>
-#elif defined(HAVE_GNU_POSIX_REGEX)
-  #include <gnuregex.h>
-#elif defined(HAVE_POSIX_REGEX)
-  #include <regex.h>
-#else
-#error No regular expression backend was found!
-#endif
-
-// clang-format on
-
-#include <string>
-
-#include "check.h"
-
-namespace benchmark {
-
-// A wrapper around the POSIX regular expression API that provides automatic
-// cleanup
-class Regex {
- public:
-  Regex() : init_(false) {}
-
-  ~Regex();
-
-  // Compile a regular expression matcher from spec.  Returns true on success.
-  //
-  // On failure (and if error is not nullptr), error is populated with a human
-  // readable error message if an error occurs.
-  bool Init(const std::string& spec, std::string* error);
-
-  // Returns whether str matches the compiled regular expression.
-  bool Match(const std::string& str);
-
- private:
-  bool init_;
-// Underlying regular expression object
-#if defined(HAVE_STD_REGEX)
-  std::regex re_;
-#elif defined(HAVE_POSIX_REGEX) || defined(HAVE_GNU_POSIX_REGEX)
-  regex_t re_;
-#else
-#error No regular expression backend implementation available
-#endif
-};
-
-#if defined(HAVE_STD_REGEX)
-
-inline bool Regex::Init(const std::string& spec, std::string* error) {
-#ifdef BENCHMARK_HAS_NO_EXCEPTIONS
-  ((void)error);  // suppress unused warning
-#else
-  try {
-#endif
-  re_ = std::regex(spec, std::regex_constants::extended);
-  init_ = true;
-#ifndef BENCHMARK_HAS_NO_EXCEPTIONS
-}
-catch (const std::regex_error& e) {
-  if (error) {
-    *error = e.what();
-  }
-}
-#endif
-return init_;
-}
-
-inline Regex::~Regex() {}
-
-inline bool Regex::Match(const std::string& str) {
-  if (!init_) {
-    return false;
-  }
-  return std::regex_search(str, re_);
-}
-
-#else
-inline bool Regex::Init(const std::string& spec, std::string* error) {
-  int ec = regcomp(&re_, spec.c_str(), REG_EXTENDED | REG_NOSUB);
-  if (ec != 0) {
-    if (error) {
-      size_t needed = regerror(ec, &re_, nullptr, 0);
-      char* errbuf = new char[needed];
-      regerror(ec, &re_, errbuf, needed);
-
-      // regerror returns the number of bytes necessary to null terminate
-      // the string, so we move that when assigning to error.
-      BM_CHECK_NE(needed, 0);
-      error->assign(errbuf, needed - 1);
-
-      delete[] errbuf;
-    }
-
-    return false;
-  }
-
-  init_ = true;
-  return true;
-}
-
-inline Regex::~Regex() {
-  if (init_) {
-    regfree(&re_);
-  }
-}
-
-inline bool Regex::Match(const std::string& str) {
-  if (!init_) {
-    return false;
-  }
-  return regexec(&re_, str.c_str(), 0, nullptr, 0) == 0;
-}
-#endif
-
-}  // end namespace benchmark
-
-#endif  // BENCHMARK_RE_H_