mirror of
https://github.com/git/git
synced 2024-08-24 18:26:02 +00:00
![Jeff Hostetler](/assets/img/avatar_default.png)
Add stopwatch timer mechanism to Trace2. Timers are an alternative to Trace2 Regions. Regions are useful for measuring the time spent in various computation phases, such as the time to read the index, time to scan for unstaged files, time to scan for untracked files, and etc. However, regions are not appropriate in all places. For example, during a checkout, it would be very inefficient to use regions to measure the total time spent inflating objects from the ODB from across the entire lifetime of the process; a per-unzip() region would flood the output and significantly slow the command; and some form of post-processing would be requried to compute the time spent in unzip(). Timers can be used to measure a series of timer intervals and emit a single summary event (at thread and/or process exit). Signed-off-by: Jeff Hostetler <jeffhost@microsoft.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
141 lines
4 KiB
C
141 lines
4 KiB
C
#ifndef TR2_TMR_H
|
|
#define TR2_TMR_H
|
|
|
|
#include "trace2.h"
|
|
#include "trace2/tr2_tgt.h"
|
|
|
|
/*
|
|
* Define a mechanism to allow "stopwatch" timers.
|
|
*
|
|
* Timers can be used to measure "interesting" activity that does not
|
|
* fit the "region" model, such as code called from many different
|
|
* regions (like zlib) and/or where data for individual calls are not
|
|
* interesting or are too numerous to be efficiently logged.
|
|
*
|
|
* Timer values are accumulated during program execution and emitted
|
|
* to the Trace2 logs at program exit.
|
|
*
|
|
* To make this model efficient, we define a compile-time fixed set of
|
|
* timers and timer ids using a "timer block" array in thread-local
|
|
* storage. This gives us constant time access to each timer within
|
|
* each thread, since we want start/stop operations to be as fast as
|
|
* possible. This lets us avoid the complexities of dynamically
|
|
* allocating a timer on the first use by a thread and/or possibly
|
|
* sharing that timer definition with other concurrent threads.
|
|
* However, this does require that we define time the set of timers at
|
|
* compile time.
|
|
*
|
|
* Each thread uses the timer block in its thread-local storage to
|
|
* compute partial sums for each timer (without locking). When a
|
|
* thread exits, those partial sums are (under lock) added to the
|
|
* global final sum.
|
|
*
|
|
* Using this "timer block" model costs ~48 bytes per timer per thread
|
|
* (we have about six uint64 fields per timer). This does increase
|
|
* the size of the thread-local storage block, but it is allocated (at
|
|
* thread create time) and not on the thread stack, so I'm not worried
|
|
* about the size.
|
|
*
|
|
* Partial sums for each timer are optionally emitted when a thread
|
|
* exits.
|
|
*
|
|
* Final sums for each timer are emitted between the "exit" and
|
|
* "atexit" events.
|
|
*
|
|
* A parallel "timer metadata" table contains the "category" and "name"
|
|
* fields for each timer. This eliminates the need to include those
|
|
* args in the various timer APIs.
|
|
*/
|
|
|
|
/*
|
|
* The definition of an individual timer and used by an individual
|
|
* thread.
|
|
*/
|
|
struct tr2_timer {
|
|
/*
|
|
* Total elapsed time for this timer in this thread in nanoseconds.
|
|
*/
|
|
uint64_t total_ns;
|
|
|
|
/*
|
|
* The maximum and minimum interval values observed for this
|
|
* timer in this thread.
|
|
*/
|
|
uint64_t min_ns;
|
|
uint64_t max_ns;
|
|
|
|
/*
|
|
* The value of the clock when this timer was started in this
|
|
* thread. (Undefined when the timer is not active in this
|
|
* thread.)
|
|
*/
|
|
uint64_t start_ns;
|
|
|
|
/*
|
|
* Number of times that this timer has been started and stopped
|
|
* in this thread. (Recursive starts are ignored.)
|
|
*/
|
|
uint64_t interval_count;
|
|
|
|
/*
|
|
* Number of nested starts on the stack in this thread. (We
|
|
* ignore recursive starts and use this to track the recursive
|
|
* calls.)
|
|
*/
|
|
unsigned int recursion_count;
|
|
};
|
|
|
|
/*
|
|
* Metadata for a timer.
|
|
*/
|
|
struct tr2_timer_metadata {
|
|
const char *category;
|
|
const char *name;
|
|
|
|
/*
|
|
* True if we should emit per-thread events for this timer
|
|
* when individual threads exit.
|
|
*/
|
|
unsigned int want_per_thread_events:1;
|
|
};
|
|
|
|
/*
|
|
* A compile-time fixed-size block of timers to insert into
|
|
* thread-local storage. This wrapper is used to avoid quirks
|
|
* of C and the usual need to pass an array size argument.
|
|
*/
|
|
struct tr2_timer_block {
|
|
struct tr2_timer timer[TRACE2_NUMBER_OF_TIMERS];
|
|
};
|
|
|
|
/*
|
|
* Private routines used by trace2.c to actually start/stop an
|
|
* individual timer in the current thread.
|
|
*/
|
|
void tr2_start_timer(enum trace2_timer_id tid);
|
|
void tr2_stop_timer(enum trace2_timer_id tid);
|
|
|
|
/*
|
|
* Add the current thread's timer data to the global totals.
|
|
* This is called during thread-exit.
|
|
*
|
|
* Caller must be holding the tr2tls_mutex.
|
|
*/
|
|
void tr2_update_final_timers(void);
|
|
|
|
/*
|
|
* Emit per-thread timer data for the current thread.
|
|
* This is called during thread-exit.
|
|
*/
|
|
void tr2_emit_per_thread_timers(tr2_tgt_evt_timer_t *fn_apply);
|
|
|
|
/*
|
|
* Emit global total timer values.
|
|
* This is called during atexit handling.
|
|
*
|
|
* Caller must be holding the tr2tls_mutex.
|
|
*/
|
|
void tr2_emit_final_timers(tr2_tgt_evt_timer_t *fn_apply);
|
|
|
|
#endif /* TR2_TMR_H */
|