<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/share/systemtap/runtime/stat.c</h2><form method='post'><textarea name='content' class='file-edit'>/* -*- linux-c -*-
 * Statistics Aggregation
 * Copyright (C) 2005-2016 Red Hat Inc.
 * Copyright (C) 2006 Intel Corporation
 *
 * This file is part of systemtap, and is free software.  You can
 * redistribute it and/or modify it under the terms of the GNU General
 * Public License (GPL); either version 2, or (at your option) any
 * later version.
 */
#ifndef _STAT_C_
#define _STAT_C_

/** @file stat.c
 * @brief Statistics Aggregation
 */
/** @addtogroup stat Statistics Aggregation
 * The Statistics aggregations keep per-cpu statistics. You
 * must create all aggregations at probe initialization and it is
 * best to not read them until probe exit. If you must read them
 * while probes are running, the values may be slightly off due
 * to a probe updating the statistics of one cpu while another cpu attempts
 * to read the same data. This will also negatively impact performance.
 *
 * Stats keep track of count, sum, min, max, avg, and variance.  Bit-shift
 * can be optionally specified, scaling the numbers, in order to improve the
 * accuracy of the integer arithmetics.
 *
 * Histograms are optional. If you want a histogram, you must set &quot;type&quot;
 * to HIST_LOG or HIST_LINEAR when you call _stp_stat_init().
 *
 * @{
 */

#include &quot;stat-common.c&quot;


/** Initialize a Stat.
 * Call this during probe initialization to create a Stat.
 *
 * @param type (KEY_HIST_TYPE and associated parameters) 
 *
 * For HIST_LOG, the following additional parametrs are required:
 * @param buckets - An integer specifying the number of buckets.
 *
 * For HIST_LINEAR, the following additional parametrs are required:
 * @param start - An integer. The start of the histogram.
 * @param stop - An integer. The stopping value. Should be &gt; start.
 * @param interval - An integer. The interval.
 *
 * @param stat_ops (STAT_OP_* and associated parameter bit_shift for STAT_OP_VARIANCE)
 */
static Stat _stp_stat_init (int first_arg, ...)
{
	int size, buckets=0, start=0, stop=0, interval=0, bit_shift=0;
	int stat_ops=0, htype=0;
	int arg = first_arg;
	Stat st;
	va_list ap;

	va_start (ap, first_arg);
	do {
		switch (arg) {
		case KEY_HIST_TYPE:
			htype = va_arg(ap, int);
			if (htype == HIST_LINEAR) {
				start = va_arg(ap, int);
				stop = va_arg(ap, int);
				interval = va_arg(ap, int);

				buckets = _stp_stat_calc_buckets(stop, start, interval);
				if (!buckets) {
					va_end (ap);
					return NULL;
				}
			}
			if (htype == HIST_LOG)
				buckets = HIST_LOG_BUCKETS;
                        break;
		case STAT_OP_COUNT:
			stat_ops |= STAT_OP_COUNT;
			break;
		case STAT_OP_SUM:
			stat_ops |= STAT_OP_SUM;
			break;
		case STAT_OP_MIN:
			stat_ops |= STAT_OP_MIN;
			break;
		case STAT_OP_MAX:
			stat_ops |= STAT_OP_MAX;
			break;
		case STAT_OP_AVG:
			stat_ops |= STAT_OP_AVG;
			break;
		case STAT_OP_VARIANCE:
			stat_ops |= STAT_OP_VARIANCE;
			bit_shift = va_arg(ap, int);
			break;
		default:
			_stp_warn (&quot;Unknown argument %d\n&quot;, arg);
		}
		arg = va_arg(ap, int);
	} while (arg);
	va_end (ap);

	size = buckets * sizeof(int64_t) + sizeof(stat_data);
	st = _stp_stat_alloc (size);
	if (st == NULL)
		return NULL;

	st-&gt;hist.type = htype;
	st-&gt;hist.start = start;
	st-&gt;hist.stop = stop;
	st-&gt;hist.interval = interval;
	st-&gt;hist.buckets = buckets;
	st-&gt;hist.bit_shift = bit_shift;
	st-&gt;hist.stat_ops = stat_ops;
	return st;
}

/** Delete Stat.
 * Call this to free all memory allocated during initialization.
 *
 * @param st Stat
 */
static void _stp_stat_del (Stat st)
{
	if (st)
		_stp_stat_free(st);
}

/** Add to a Stat.
 * Add an int64 to a Stat, and for optimization purposes specify which
 * statistical operators are bound to given Stat.  Set all of stat_op*
 * to 1 if unsure.  Note that @avg() is being evaluated separately based
 * on @sum and @count within the code directly generated by the translator.
 *
 * @param st Stat
 * @param val Value to add
 * @param stat_op_count int
 * @param stat_op_sum int
 * @param stat_op_min int
 * @param stat_op_max int
 * @param stat_op_variance int
 *
 */
static inline void _stp_stat_add (Stat st, int64_t val, int stat_op_count,
                                  int stat_op_sum, int stat_op_min,
				  int stat_op_max, int stat_op_variance)
{
	stat_data *sd = _stp_stat_per_cpu_ptr (st, STAT_GET_CPU());
	STAT_LOCK(sd);
	__stp_stat_add (&amp;st-&gt;hist, sd, val, stat_op_count, stat_op_sum,
	                stat_op_min, stat_op_max, stat_op_variance);
	STAT_UNLOCK(sd);
	STAT_PUT_CPU();
}

static void _stp_stat_clear_data (Stat st, stat_data *sd)
{
        int j;
        sd-&gt;count = sd-&gt;sum = sd-&gt;min = sd-&gt;max = 0;
        sd-&gt;avg_s = sd-&gt;variance = sd-&gt;variance_s = 0;

        if (st-&gt;hist.type != HIST_NONE) {
                for (j = 0; j &lt; st-&gt;hist.buckets; j++)
                        sd-&gt;histogram[j] = 0;
        }
}

/** Get Stats.
 * Gets the aggregated Stats for all CPUs.
 *
 * @param st Stat
 * @param clear Set if you want the data cleared after the read. Useful
 * for polling.
 * @returns A pointer to a stat.
 */
static stat_data *_stp_stat_get (Stat st, int clear)
{
	int i, j;
	int64_t S1, S2;
	stat_data *agg = _stp_stat_get_agg(st);
	stat_data *sd;
	STAT_LOCK(agg);
	_stp_stat_clear_data (st, agg);
	S1 = S2 = 0;

	for_each_possible_cpu(i) {
		stat_data *sd = _stp_stat_per_cpu_ptr (st, i);
		STAT_LOCK(sd);
		if (sd-&gt;count) {
			agg-&gt;shift = sd-&gt;shift;
			if (agg-&gt;count == 0) {
				agg-&gt;min = sd-&gt;min;
				agg-&gt;max = sd-&gt;max;
			}
			agg-&gt;count += sd-&gt;count;
			agg-&gt;sum += sd-&gt;sum;
			if (sd-&gt;max &gt; agg-&gt;max)
				agg-&gt;max = sd-&gt;max;
			if (sd-&gt;min &lt; agg-&gt;min)
				agg-&gt;min = sd-&gt;min;
			if (st-&gt;hist.type != HIST_NONE) {
				for (j = 0; j &lt; st-&gt;hist.buckets; j++)
					agg-&gt;histogram[j] += sd-&gt;histogram[j];
			}
		}
		STAT_UNLOCK(sd);
	}

	agg-&gt;avg_s = _stp_div64(NULL, agg-&gt;sum &lt;&lt; agg-&gt;shift, agg-&gt;count);

	/*
	 * For aggregating variance over available CPUs, the Total Variance
	 * formula is being used.  This formula is mentioned in following
	 * paper: Niranjan Kamat, Arnab Nandi: A Closer Look at Variance
	 * Implementations In Modern Database Systems: SIGMOD Record 2015.
	 * Available at: http://web.cse.ohio-state.edu/~kamatn/variance.pdf
	 */
	for_each_possible_cpu(i) {
		sd = _stp_stat_per_cpu_ptr (st, i);
		STAT_LOCK(sd);
		if (sd-&gt;count) {
			S1 += sd-&gt;count * (sd-&gt;avg_s - agg-&gt;avg_s) * (sd-&gt;avg_s - agg-&gt;avg_s);
			S2 += (sd-&gt;count - 1) * sd-&gt;variance_s;
		}
		if (clear)
			_stp_stat_clear_data (st, sd);
		STAT_UNLOCK(sd);
	}

	agg-&gt;variance_s = _stp_div64(NULL, (S1 + S2), (agg-&gt;count - 1));
	agg-&gt;variance = agg-&gt;variance_s &gt;&gt; (2 * agg-&gt;shift);

	/*
	 * Originally this function returned the aggregate still
	 * locked and it was the caller's responsibility to unlock the
	 * aggregate. However the translator generated code that called
	 * this function wasn't unlocking it...
	 *
	 * But, the translator generates its own locks for global
	 * variables (like stats), so we don't need to return the
	 * aggregate still locked.
	 *
	 * It is possible we could even skip locking the aggregate in
	 * this function, but to be a bit paranoid lets keep the
	 * locking.
	 */
	STAT_UNLOCK(agg);
	return agg;
}


/** Clear Stats.
 * Clears the Stats.
 *
 * @param st Stat
 */
static void _stp_stat_clear (Stat st)
{
	int i;

	for_each_possible_cpu(i) {
		stat_data *sd = _stp_stat_per_cpu_ptr (st, i);
		STAT_LOCK(sd);
		_stp_stat_clear_data (st, sd);
		STAT_UNLOCK(sd);
	}
}
/** @} */
#endif /* _STAT_C_ */
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Fshare%2Fsystemtap%2Fruntime'>Back to Directory</a>