metrics.h

// Copyright 2023 The Pigweed Authors
//
// 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
//
//     https://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.
#pragma once
 
#include <cstddef>
#include <cstdint>
 
#include "pw_allocator/allocator.h"
#include "pw_metric/metric.h"
#include "pw_status/status_with_size.h"
 
namespace pw::allocator {
 
 
#define PW_ALLOCATOR_METRICS_FOREACH(fn) \
  fn(requested_bytes);                   \
  fn(peak_requested_bytes);              \
  fn(cumulative_requested_bytes);        \
  fn(allocated_bytes);                   \
  fn(peak_allocated_bytes);              \
  fn(cumulative_allocated_bytes);        \
  fn(num_allocations);                   \
  fn(num_deallocations);                 \
  fn(num_resizes);                       \
  fn(num_reallocations);                 \
  fn(num_free_blocks);                   \
  fn(smallest_free_block_size);          \
  fn(largest_free_block_size);           \
  fn(num_failures);                      \
  fn(unfulfilled_bytes)
 
#define PW_ALLOCATOR_ABSORB_SEMICOLON() static_assert(true)
 
#define PW_ALLOCATOR_METRICS_DECLARE(metric_name)                 \
  static constexpr bool has_##metric_name() { return false; }     \
  ::pw::StatusWithSize get_##metric_name() const {                \
    return ::pw::StatusWithSize::NotFound();                      \
  }                                                               \
  static constexpr bool metric_name##_enabled() { return false; } \
  PW_ALLOCATOR_ABSORB_SEMICOLON()
 
struct NoMetrics {
  PW_ALLOCATOR_METRICS_FOREACH(PW_ALLOCATOR_METRICS_DECLARE);
 
  void UpdateDeferred(Allocator&) {}
};
 
#undef PW_ALLOCATOR_METRICS_DECLARE
 
#define PW_ALLOCATOR_METRICS_INCLUDE(metric_name)                  \
  static_assert(!::pw::allocator::NoMetrics::has_##metric_name()); \
  static constexpr bool has_##metric_name() { return true; }       \
  inline ::pw::StatusWithSize get_##metric_name() const {          \
    return ::pw::StatusWithSize(metric_name.value());              \
  }                                                                \
  PW_METRIC(metric_name, #metric_name, 0U)
 
#define PW_ALLOCATOR_METRICS_ENABLE(metric_name)                 \
  static constexpr bool metric_name##_enabled() { return true; } \
  PW_ALLOCATOR_METRICS_INCLUDE(metric_name)
 
namespace internal {
 
struct AllMetrics : public NoMetrics {
  PW_ALLOCATOR_METRICS_FOREACH(PW_ALLOCATOR_METRICS_ENABLE);
};
 
template <typename MetricsType>
constexpr bool AnyEnabled();
 
template <typename MetricsType>
void CopyMetrics(const MetricsType& src, MetricsType& dst);
 
template <typename MetricsType>
class Metrics final {
 public:
  Metrics(metric::Token token);
  ~Metrics() = default;
 
  const metric::Group& group() const { return group_; }
  metric::Group& group() { return group_; }
 
  const MetricsType& metrics() const { return metrics_; }
 
  void ModifyRequested(size_t increase, size_t decrease);
 
  void ModifyAllocated(size_t increase, size_t decrease);
 
  void IncrementAllocations();
 
  void IncrementDeallocations();
 
  void IncrementResizes();
 
  void IncrementReallocations();
 
  void RecordFailure(size_t requested);
 
  void UpdateDeferred(Allocator& allocator) {
    metrics_.UpdateDeferred(allocator);
  }
 
 private:
  metric::Group group_;
  MetricsType metrics_;
};
 
inline uint32_t ClampU32(size_t size) {
  return static_cast<uint32_t>(std::min(
      size, static_cast<size_t>(std::numeric_limits<uint32_t>::max())));
}
 
 
// Template method implementations.
 
template <typename MetricsType>
constexpr bool AnyEnabled() {
#define PW_ALLOCATOR_RETURN_IF_ENABLED(metric_name) \
  if (MetricsType::metric_name##_enabled()) {       \
    return true;                                    \
  }                                                 \
  PW_ALLOCATOR_ABSORB_SEMICOLON()
 
  PW_ALLOCATOR_METRICS_FOREACH(PW_ALLOCATOR_RETURN_IF_ENABLED);
  return false;
 
#undef PW_ALLOCATOR_RETURN_IF_ENABLED
}
 
template <typename MetricsType>
void CopyMetrics(const MetricsType& src, MetricsType& dst) {
#define PW_ALLOCATOR_COPY_METRIC(metric_name)       \
  if constexpr (MetricsType::has_##metric_name()) { \
    dst.metric_name.Set(src.metric_name.value());   \
  }                                                 \
  PW_ALLOCATOR_ABSORB_SEMICOLON()
 
  PW_ALLOCATOR_METRICS_FOREACH(PW_ALLOCATOR_COPY_METRIC);
 
#undef PW_ALLOCATOR_COPY_METRIC
}
 
template <typename MetricsType>
Metrics<MetricsType>::Metrics(metric::Token token) : group_(token) {
#define PW_ALLOCATOR_ADD_TO_GROUP(metric_name)      \
  if constexpr (MetricsType::has_##metric_name()) { \
    group_.Add(metrics_.metric_name);               \
  }                                                 \
  PW_ALLOCATOR_ABSORB_SEMICOLON()
 
  PW_ALLOCATOR_METRICS_FOREACH(PW_ALLOCATOR_ADD_TO_GROUP);
 
#undef PW_ALLOCATOR_ADD_TO_GROUP
}
 
template <typename MetricsType>
void Metrics<MetricsType>::ModifyRequested(size_t increase, size_t decrease) {
  if constexpr (MetricsType::requested_bytes_enabled()) {
    metrics_.requested_bytes.Increment(internal::ClampU32(increase));
    metrics_.requested_bytes.Decrement(internal::ClampU32(decrease));
    if constexpr (MetricsType::peak_requested_bytes_enabled()) {
      uint32_t requested_bytes = metrics_.requested_bytes.value();
      if (metrics_.peak_requested_bytes.value() < requested_bytes) {
        metrics_.peak_requested_bytes.Set(requested_bytes);
      }
    }
    if constexpr (MetricsType::cumulative_requested_bytes_enabled()) {
      if (increase > decrease) {
        metrics_.cumulative_requested_bytes.Increment(
            internal::ClampU32(increase - decrease));
      }
    }
  }
}
 
template <typename MetricsType>
void Metrics<MetricsType>::ModifyAllocated(size_t increase, size_t decrease) {
  if constexpr (MetricsType::allocated_bytes_enabled()) {
    metrics_.allocated_bytes.Increment(internal::ClampU32(increase));
    metrics_.allocated_bytes.Decrement(internal::ClampU32(decrease));
    if constexpr (MetricsType::peak_allocated_bytes_enabled()) {
      uint32_t allocated_bytes = metrics_.allocated_bytes.value();
      if (metrics_.peak_allocated_bytes.value() < allocated_bytes) {
        metrics_.peak_allocated_bytes.Set(allocated_bytes);
      }
    }
    if constexpr (MetricsType::cumulative_allocated_bytes_enabled()) {
      if (increase > decrease) {
        metrics_.cumulative_allocated_bytes.Increment(
            internal::ClampU32(increase - decrease));
      }
    }
  }
}
 
template <typename MetricsType>
void Metrics<MetricsType>::IncrementAllocations() {
  if constexpr (MetricsType::num_allocations_enabled()) {
    metrics_.num_allocations.Increment();
  }
}
 
template <typename MetricsType>
void Metrics<MetricsType>::IncrementDeallocations() {
  if constexpr (MetricsType::num_deallocations_enabled()) {
    metrics_.num_deallocations.Increment();
  }
}
 
template <typename MetricsType>
void Metrics<MetricsType>::IncrementResizes() {
  if constexpr (MetricsType::num_resizes_enabled()) {
    metrics_.num_resizes.Increment();
  }
}
 
template <typename MetricsType>
void Metrics<MetricsType>::IncrementReallocations() {
  if constexpr (MetricsType::num_reallocations_enabled()) {
    metrics_.num_reallocations.Increment();
  }
}
 
template <typename MetricsType>
void Metrics<MetricsType>::RecordFailure(size_t requested) {
  if constexpr (MetricsType::num_failures_enabled()) {
    metrics_.num_failures.Increment();
  }
  if constexpr (MetricsType::unfulfilled_bytes_enabled()) {
    metrics_.unfulfilled_bytes.Increment(internal::ClampU32(requested));
  }
}
 
#undef PW_ALLOCATOR_ABSORB_SEMICOLON
 
}  // namespace internal
}  // namespace pw::allocator