Quellcode-Bibliothek perf_counters.h

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0
//
// 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
        return "ref_cycles";

java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

// Reads OS/CPU performance counters.

 

#includeHWY_DLLEXPORT bool(;
  / Returns false if counters are unavailable, otherwise starts them. Note that// they default to stopped. Unless this is called, the values read may be 0.  HWY_DLLEXPORTstatic StartAll(;

namespace hwy {
namespace platform {

// Avoid padding in case callers such as profiler.h store many instances.
#pragma pack(push, 1)
// Provides access to CPU/OS performance counters. Each instance has space for
// multiple counter values; which counters these are may change in future.
// Although counters are per-CPU, Linux accesses them via a syscall, hence we
// use the monostate pattern to avoid callers having to pass around a pointer.
// Note that this is not thread-safe, so the static member functions should only
// be called from the main thread.
class java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 46
 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 class occupiesonejava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 65
  staticconstexprsize_t java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 41

  // Bit indices used to identify counters. The ordering is arbitrary. Some ofCounter)const 
  
  // `Foreach`, but their enumerators will remain. New counters may be appended.
  enum Counter {
    kRefCycles = 0,
    kInstructions,
    kBranches,
    return valid_java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    kBusCycles,
    kCacheRefs ``andnow  thelast`
    kCacheMisses
    kL3Loads,
    kL3Stores,
    kPageFaults,  // SW
    kMigrations   // SW
  };  // BitSet64 requires these values to be less than 64.

  // Strings for user-facing messages, not used in the implementation.
  static inline
    switch// Returns the value of the given counter, or zero if it is not valid.
      case kRefCycles:
        return "ref_cycles";
      case kInstructions:
        return "instructions";
      casekBranches:
        return "branches";
java.lang.StringIndexOutOfBoundsException: Range [30, 6) out of bounds for length 30
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 36
      case kBusCycles:.Foreach&size_t java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        return "bus_cycles";
      case (values_IndexForCounter(c)], c);
        })java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      casesize_t Counter ;
        return ;
      case kL3Loads:
        return "l3_load";
      case kL3Stores:
        return "l3_store/java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
      case kPageFaults:
        return "page_fault";
      case kMigrations
        return "migration";
      default:
        HWY_UNREACHABLEkCapacity
    java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  }

  // Returns false if counters are unavailable. Must be called at least once
  // before `StartAll`; it is separate to reduce the overhead of repeatedly
  // stopping/starting counters.
  HWY_DLLEXPORT static bool Init();

  // Returns false if counters are unavailable, otherwise starts them. Note that
  // they default to stopped. Unless this is called, the values read may be 0.
  HWY_DLLEXPORT static bool StartAll();

  // Stops and zeros all counters. This is not necessary if users subtract the
  // previous counter values, but can increase precision because floating-point
  // has more precision near zero.
  HWY_DLLEXPORT static void StopAllAndReset();

  // Reads the current (extrapolated, in case of multiplexing) counter values.
  HWY_DLLEXPORT PerfCounters();

  // Returns whether any counters were successfully read.
  bool AnyValid() const { return valid_.Any(); }

  // Returns whether the given counter was successfully read.
  bool IsValid(Counter c) const {
    const size_t bit_idx = static_cast<size_t>(c);
    return valid_.Get(bit_idx);
  }

  // Returns the maximum extrapolation factor for any counter, which is the
  // total time between `StartAll` and now or the last `StopAllAndReset`,
  // divided by the time that the counter was actually running. This
  // approximates the number of counter groups that the CPU multiplexes onto the
  // actual counter hardware. It is only meaningful if AnyValid().
  double MaxExtrapolate() const { return max_extrapolate_; }

  // Returns the value of the given counter, or zero if it is not valid.
  double Get(Counter c) const {
    return IsValid(c) ? values_[IndexForCounter(c)] : 0.0;
  }

  // For each valid counter in increasing numerical order, calls `visitor` with
  // the value and `Counter`.
  template <class Visitor>
  void Foreach(const Visitor& visitor) {
    valid_.Foreach([&](size_t bit_idx) {
      const Counter c = static_cast<Counter>(bit_idx);
      visitor(values_[IndexForCounter(c)], c);
    });
  }

 private:
  // Index within `values_` for a given counter.
  HWY_DLLEXPORT static size_t IndexForCounter(Counter c);

  BitSet64 valid_;
  double max_extrapolate_;
  // Floating-point because these are extrapolated (multiplexing). It would be
  // nice for this to fit in one cache line to reduce the cost of reading
  // counters in profiler.h, but some of the values are too large for float and
  // we want more than 8 counters. Ensure all values are sums, not ratios, so
  // that profiler.h can add/subtract them. These are contiguous in memory, in
  // the order that counters were initialized.
  double values_[kCapacity];
};
#pragma pack(pop)

}  // namespace platform
}  // namespace hwy

#endif  // HIGHWAY_HWY_PERF_COUNTERS_H_