cpython/Objects/mimalloc/stats.c

/* ----------------------------------------------------------------------------
Copyright (c) 2018-2021, Microsoft Research, Daan Leijen
This is free software; you can redistribute it and/or modify it under the
terms of the MIT license. A copy of the license can be found in the file
"LICENSE" at the root of this distribution.
-----------------------------------------------------------------------------*/
#include "mimalloc.h"
#include "mimalloc/internal.h"
#include "mimalloc/atomic.h"
#include "mimalloc/prim.h"

#include <stdio.h>  // snprintf
#include <string.h> // memset

#if defined(_MSC_VER) && (_MSC_VER < 1920)
#pragma warning(disable:4204)  // non-constant aggregate initializer
#endif

/* -----------------------------------------------------------
  Statistics operations
----------------------------------------------------------- */

static bool mi_is_in_main(void* stat) { … }

static void mi_stat_update(mi_stat_count_t* stat, int64_t amount) { … }

void _mi_stat_counter_increase(mi_stat_counter_t* stat, size_t amount) { … }

void _mi_stat_increase(mi_stat_count_t* stat, size_t amount) { … }

void _mi_stat_decrease(mi_stat_count_t* stat, size_t amount) { … }

// must be thread safe as it is called from stats_merge
static void mi_stat_add(mi_stat_count_t* stat, const mi_stat_count_t* src, int64_t unit) { … }

static void mi_stat_counter_add(mi_stat_counter_t* stat, const mi_stat_counter_t* src, int64_t unit) { … }

// must be thread safe as it is called from stats_merge
static void mi_stats_add(mi_stats_t* stats, const mi_stats_t* src) { … }

/* -----------------------------------------------------------
  Display statistics
----------------------------------------------------------- */

// unit > 0 : size in binary bytes
// unit == 0: count as decimal
// unit < 0 : count in binary
static void mi_printf_amount(int64_t n, int64_t unit, mi_output_fun* out, void* arg, const char* fmt) { … }


static void mi_print_amount(int64_t n, int64_t unit, mi_output_fun* out, void* arg) { … }

static void mi_print_count(int64_t n, int64_t unit, mi_output_fun* out, void* arg) { … }

static void mi_stat_print_ex(const mi_stat_count_t* stat, const char* msg, int64_t unit, mi_output_fun* out, void* arg, const char* notok ) { … }

static void mi_stat_print(const mi_stat_count_t* stat, const char* msg, int64_t unit, mi_output_fun* out, void* arg) { … }

static void mi_stat_peak_print(const mi_stat_count_t* stat, const char* msg, int64_t unit, mi_output_fun* out, void* arg) { … }

static void mi_stat_counter_print(const mi_stat_counter_t* stat, const char* msg, mi_output_fun* out, void* arg ) { … }


static void mi_stat_counter_print_avg(const mi_stat_counter_t* stat, const char* msg, mi_output_fun* out, void* arg) { … }


static void mi_print_header(mi_output_fun* out, void* arg ) { … }

#if MI_STAT>1
static void mi_stats_print_bins(const mi_stat_count_t* bins, size_t max, const char* fmt, mi_output_fun* out, void* arg) {
  bool found = false;
  char buf[64];
  for (size_t i = 0; i <= max; i++) {
    if (bins[i].allocated > 0) {
      found = true;
      int64_t unit = _mi_bin_size((uint8_t)i);
      snprintf(buf, 64, "%s %3lu", fmt, (long)i);
      mi_stat_print(&bins[i], buf, unit, out, arg);
    }
  }
  if (found) {
    _mi_fprintf(out, arg, "\n");
    mi_print_header(out, arg);
  }
}
#endif



//------------------------------------------------------------
// Use an output wrapper for line-buffered output
// (which is nice when using loggers etc.)
//------------------------------------------------------------
buffered_t;

static void mi_buffered_flush(buffered_t* buf) { … }

static void mi_cdecl mi_buffered_out(const char* msg, void* arg) { … }

//------------------------------------------------------------
// Print statistics
//------------------------------------------------------------

static void _mi_stats_print(mi_stats_t* stats, mi_output_fun* out0, void* arg0) mi_attr_noexcept { … }

static mi_msecs_t mi_process_start; // = 0

static mi_stats_t* mi_stats_get_default(void) { … }

static void mi_stats_merge_from(mi_stats_t* stats) { … }

void mi_stats_reset(void) mi_attr_noexcept { … }

void mi_stats_merge(void) mi_attr_noexcept { … }

void _mi_stats_done(mi_stats_t* stats) { … }

void mi_stats_print_out(mi_output_fun* out, void* arg) mi_attr_noexcept { … }

void mi_stats_print(void* out) mi_attr_noexcept { … }

void mi_thread_stats_print_out(mi_output_fun* out, void* arg) mi_attr_noexcept { … }


// ----------------------------------------------------------------
// Basic timer for convenience; use milli-seconds to avoid doubles
// ----------------------------------------------------------------

static mi_msecs_t mi_clock_diff;

mi_msecs_t _mi_clock_now(void) { … }

mi_msecs_t _mi_clock_start(void) { … }

mi_msecs_t _mi_clock_end(mi_msecs_t start) { … }


// --------------------------------------------------------
// Basic process statistics
// --------------------------------------------------------

mi_decl_export void mi_process_info(size_t* elapsed_msecs, size_t* user_msecs, size_t* system_msecs, size_t* current_rss, size_t* peak_rss, size_t* current_commit, size_t* peak_commit, size_t* page_faults) mi_attr_noexcept
{ … }