mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-06-11 22:31:12 +02:00
Code Activity

Basic stats records latency readings in a histogram, prints p95

Browse source
This commit is contained in:
Andy Wingo 2023-12-10 21:23:44 +01:00
parent 4b51376447
commit 1267f77de3
2 changed files with 104 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

16
api/gc-basic-stats.h
View file

@ -2,6 +2,7 @@
#define GC_BASIC_STATS_H
#include "gc-event-listener.h"
#include "gc-histogram.h"
#include <inttypes.h>
#include <stdint.h>
@ -9,6 +10,8 @@
#include <string.h>
#include <sys/time.h>
GC_DEFINE_HISTOGRAM(gc_latency, 25, 4);
struct gc_basic_stats {
uint64_t major_collection_count;
uint64_t minor_collection_count;
@ -18,6 +21,7 @@ struct gc_basic_stats {
size_t heap_size;
size_t max_heap_size;
size_t max_live_data_size;
struct gc_latency pause_times;
};
static inline uint64_t gc_basic_stats_now(void) {
@ -58,7 +62,9 @@ static inline void gc_basic_stats_ephemerons_traced(void *data) {}
static inline void gc_basic_stats_restarting_mutators(void *data) {
struct gc_basic_stats *stats = data;
uint64_t now = gc_basic_stats_now();
stats->elapsed_collector_usec += now - stats->last_time_usec;
uint64_t pause_time = now - stats->last_time_usec;
stats->elapsed_collector_usec += pause_time;
gc_latency_record(&stats->pause_times, pause_time);
stats->last_time_usec = now;
}
@ -120,6 +126,14 @@ static inline void gc_basic_stats_print(struct gc_basic_stats *stats, FILE *f) {
fprintf(f, "%" PRIu64 ".%.3" PRIu64 " ms total time "
"(%" PRIu64 ".%.3" PRIu64 " stopped).\n",
elapsed / ms, elapsed % ms, stopped / ms, stopped % ms);
uint64_t pause_median = gc_latency_median(&stats->pause_times);
uint64_t pause_p95 = gc_latency_percentile(&stats->pause_times, 0.95);
uint64_t pause_max = gc_latency_max(&stats->pause_times);
fprintf(f, "%" PRIu64 ".%.3" PRIu64 " ms median pause time, "
"%" PRIu64 ".%.3" PRIu64 " p95, "
"%" PRIu64 ".%.3" PRIu64 " max.\n",
pause_median / ms, pause_median % ms, pause_p95 / ms, pause_p95 % ms,
pause_max / ms, pause_max % ms);
double MB = 1e6;
fprintf(f, "Heap size is %.3f MB (max %.3f MB); peak live data %.3f MB.\n",
stats->heap_size / MB, stats->max_heap_size / MB,

89
api/gc-histogram.h Normal file
View file

@ -0,0 +1,89 @@
#ifndef GC_HISTOGRAM_H
#define GC_HISTOGRAM_H
#include "gc-assert.h"
#include <stdint.h>
static inline size_t gc_histogram_bucket(uint64_t max_value_bits,
uint64_t precision,
uint64_t val) {
uint64_t major = val < (1ULL << precision)
? 0ULL
: 64ULL - __builtin_clzl(val) - precision;
uint64_t minor = val < (1 << precision)
? val
: (val >> (major - 1ULL)) & ((1ULL << precision) - 1ULL);
uint64_t idx = (major << precision) | minor;
if (idx >= (max_value_bits << precision))
idx = max_value_bits << precision;
return idx;
}
static inline uint64_t gc_histogram_bucket_min_val(uint64_t precision,
size_t idx) {
uint64_t major = idx >> precision;
uint64_t minor = idx & ((1ULL << precision) - 1ULL);
uint64_t min_val = major
? ((1ULL << precision) | minor) << (major - 1ULL)
: minor;
return min_val;
}
static inline void gc_histogram_record(uint32_t *buckets,
uint64_t max_value_bits,
uint64_t precision,
uint64_t val) {
buckets[gc_histogram_bucket(max_value_bits, precision, val)]++;
}
#define GC_DEFINE_HISTOGRAM(name, max_value_bits, precision) \
struct name { uint32_t buckets[((max_value_bits) << (precision)) + 1]; }; \
static inline size_t name##_size(void) { \
return ((max_value_bits) << (precision)) + 1; \
} \
static inline uint64_t name##_bucket_min_val(size_t idx) { \
GC_ASSERT(idx < name##_size()); \
return gc_histogram_bucket_min_val((precision), idx); \
} \
static inline struct name make_##name(void) { \
return (struct name) { { 0, }}; \
} \
static inline void name##_record(struct name *h, uint64_t val) { \
h->buckets[gc_histogram_bucket((max_value_bits), (precision), val)]++; \
} \
static inline uint64_t name##_ref(struct name *h, size_t idx) { \
GC_ASSERT(idx < name##_size()); \
return h->buckets[idx]; \
} \
static inline uint64_t name##_min(struct name *h) { \
for (size_t bucket = 0; bucket < name##_size(); bucket++) \
if (h->buckets[bucket]) return name##_bucket_min_val(bucket); \
return -1; \
} \
static inline uint64_t name##_max(struct name *h) { \
if (h->buckets[name##_size()-1]) return -1LL; \
for (ssize_t bucket = name##_size() - 1; bucket >= 0; bucket--) \
if (h->buckets[bucket]) return name##_bucket_min_val(bucket+1); \
return 0; \
} \
static inline uint64_t name##_count(struct name *h) { \
uint64_t sum = 0; \
for (size_t bucket = 0; bucket < name##_size(); bucket++) \
sum += h->buckets[bucket]; \
return sum; \
} \
static inline uint64_t name##_percentile(struct name *h, double p) { \
uint64_t n = name##_count(h) * p; \
uint64_t sum = 0; \
for (size_t bucket = 0; bucket + 1 < name##_size(); bucket++) { \
sum += h->buckets[bucket]; \
if (sum >= n) return name##_bucket_min_val(bucket+1); \
} \
return -1ULL; \
} \
static inline uint64_t name##_median(struct name *h) { \
return name##_percentile(h, 0.5); \
}
#endif // GC_HISTOGRAM_H