GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 * Author: Dag-Erling Smørgrav <des@des.no>
 * Author: Guillaume Quintard <guillaume.quintard@gmail.com>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * Log tailer for Varnish
 */

#include "config.h"

#include <limits.h>
#include <math.h>
#include <pthread.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define VOPT_DEFINITION
#define VOPT_INC "varnishhist_options.h"

#include "vdef.h"
#include "vcurses.h"
#include "vapi/vsl.h"
#include "vapi/vsm.h"
#include "vapi/voptget.h"
#include "vapi/vsig.h"
#include "vas.h"
#include "vut.h"
#include "vtim.h"

#if 1
#define AC(x) assert((x) != ERR)
#else
#define AC(x) x
#endif

#define HIST_N 2000             /* how far back we remember */
#define HIST_RES 100            /* bucket resolution */

static struct VUT *vut;

static int hist_low;
static int hist_high;
static int hist_range;
static unsigned hist_buckets;

static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

static int end_of_file = 0;
static unsigned ms_delay = 1000;
static unsigned rr_hist[HIST_N];
static unsigned nhist;
static unsigned next_hist;
static unsigned *bucket_miss;
static unsigned *bucket_hit;
static char *format;
static int match_tag;
static double timebend = 0, t0;
static double vsl_t0 = 0, vsl_to, vsl_ts = 0;
static pthread_cond_t timebend_cv;
static double log_ten;
static char *ident;

static const unsigned scales[] = {
        1,
        2,
        3,
        4,
        5,
        10,
        15,
        20,
        25,
        50,
        100,
        250,
        500,
        1000,
        2500,
        5000,
        10000,
        25000,
        50000,
        100000,
        UINT_MAX
};

struct profile {
        const char *name;
        char VSL_arg;
        enum VSL_tag_e tag;
        const char *prefix;
        int field;
        int hist_low;
        int hist_high;
};

#define HIS_PROF(name,vsl_arg,tag,prefix,field,hist_low,high_high,doc)  \
        {name,vsl_arg,tag,prefix,field,hist_low,high_high},
#define HIS_NO_PREFIX   NULL
#define HIS_CLIENT      'c'
#define HIS_BACKEND     'b'
static const struct profile profiles[] = {
#include "varnishhist_profiles.h"
        { NULL }
};
#undef HIS_NO_PREFIX
#undef HIS_BACKEND
#undef HIS_CLIENT
#undef HIS_PROF

static const struct profile *active_profile;

static void
update(void)
{
        char t[VTIM_FORMAT_SIZE];
        const unsigned w = COLS / hist_range;
        const unsigned n = w * hist_range;
        unsigned bm[n], bh[n];
        unsigned max;
        unsigned scale;
        int i, j;
        unsigned k, l;

        /* Draw horizontal axis */
        for (k = 0; k < n; ++k)
                (void)mvaddch(LINES - 2, k, '-');
        for (i = 0, j = hist_low; i < hist_range; ++i, ++j) {
                (void)mvaddch(LINES - 2, w * i, '+');
                mvprintw(LINES - 1, w * i, "|1e%d", j);
        }

        if (end_of_file)
                mvprintw(0, 0, "%*s", COLS - 1, "EOF");
        else
                mvprintw(0, 0, "%*s", COLS - 1, ident);

        /* count our flock */
        memset(bm, 0, sizeof bm);
        memset(bh, 0, sizeof bh);
        for (k = 0, max = 1; k < hist_buckets; ++k) {
                l = k * n / hist_buckets;
                assert(l < n);
                bm[l] += bucket_miss[k];
                bh[l] += bucket_hit[k];
                max = vmax(max, bm[l] + bh[l]);
        }

        /* scale,time */
        assert(LINES - 3 >= 0);
        for (i = 0; max / scales[i] > (unsigned)(LINES - 3); ++i)
                /* nothing */ ;
        scale = scales[i];

        if (vsl_t0 > 0) {
                VTIM_format(vsl_ts, t);

                mvprintw(0, 0, "1:%u, n = %u, d = %g @ %s x %g",
                    scale, nhist, 1e-3 * ms_delay, t, timebend);
        } else
                mvprintw(0, 0, "1:%u, n = %u, d = %g",
                    scale, nhist, 1e-3 * ms_delay);

        for (j = 5; j < LINES - 2; j += 5)
                mvprintw((LINES - 2) - j, 0, "%u_", j * scale);

        /* show them */
        for (k = 0; k < n; ++k) {
                for (l = 0; l < bm[k] / scale; ++l)
                        (void)mvaddch((LINES - 3) - l, k, '#');
                for (; l < (bm[k] + bh[k]) / scale; ++l)
                        (void)mvaddch((LINES - 3) - l, k, '|');
        }
}

inline static void
upd_vsl_ts(const char *p)
{

        if (timebend == 0)
                return;

        p = strchr(p, ' ');

        if (p == NULL)
                return;

        vsl_ts = vmax_t(double, vsl_ts, strtod(p + 1, NULL));
}

static void
delorean(void)
{
        int i;
        double t = VTIM_mono();

        if (vsl_t0 == 0)
                vsl_to = vsl_t0 = vsl_ts;

        assert(t > t0);
        vsl_to = vsl_t0 + (t - t0) * timebend;

        if (vsl_ts > vsl_to) {
                double when = VTIM_real() + vsl_ts - vsl_to;
                struct timespec ts = VTIM_timespec(when);
                i = pthread_cond_timedwait(&timebend_cv, &mtx, &ts);
                assert(i == 0 || i == ETIMEDOUT);
        }
}

static int v_matchproto_ (VSLQ_dispatch_f)
accumulate(struct VSL_data *vsl, struct VSL_transaction * const pt[],
    void *priv)
{
        int i, tag, skip, match, hit;
        unsigned u;
        double value = 0;
        struct VSL_transaction *tr;
        const char *tsp;
        enum vsl_status stat;

        (void)vsl;
        (void)priv;

        for (tr = pt[0]; tr != NULL; tr = *++pt) {
                if (VSIG_int || VSIG_term || VSIG_hup)
                        return (-1);

                if (tr->reason == VSL_r_esi) {
                        /* Skip ESI requests */
                        continue;
                }

                hit = 0;
                skip = 0;
                match = 0;
                tsp = NULL;
                while (skip == 0) {
                        stat = VSL_Next(tr->c);
                        if (stat == vsl_e_overrun) {
                                /* need to skip forward */
                                PTOK(pthread_mutex_lock(&mtx));
                                vsl_to = vsl_t0 = vsl_ts = 0;
                                t0 = VTIM_mono();
                                PTOK(pthread_mutex_unlock(&mtx));
                                break;
                        }
                        if (stat != vsl_more)
                                break;

                        /* get the value we want and register if it's a hit */
                        tag = VSL_TAG(tr->c->rec.ptr);

                        if (VSL_tagflags[tag])
                                continue;

                        switch (tag) {
                        case SLT_Hit:
                                hit = 1;
                                break;
                        case SLT_VCL_return:
                                if (!strcasecmp(VSL_CDATA(tr->c->rec.ptr),
                                    "restart") ||
                                    !strcasecmp(VSL_CDATA(tr->c->rec.ptr),
                                    "retry"))
                                        skip = 1;
                                break;
                        case SLT_Timestamp:
                                tsp = VSL_CDATA(tr->c->rec.ptr);
                                /* FALLTHROUGH */
                        default:
                                if (tag != match_tag)
                                        break;

                                if (active_profile->prefix &&
                                    strncmp(VSL_CDATA(tr->c->rec.ptr),
                                    active_profile->prefix,
                                    strlen(active_profile->prefix)) != 0)
                                        break;

                                i = sscanf(VSL_CDATA(tr->c->rec.ptr),
                                    format, &value);
                                if (i != 1)
                                        break;
                                match = 1;
                                break;
                        }
                }

                if (skip || !match || value <= 0)
                        continue;

                /* select bucket */
                i = vlimit_t(int, lround(HIST_RES * log(value) / log_ten),
                    hist_low * HIST_RES, hist_high * HIST_RES - 1) -
                        hist_low * HIST_RES;
                assert(i >= 0);
                assert((unsigned)i < hist_buckets);

                PTOK(pthread_mutex_lock(&mtx));

                /*
                 * only parse the last tsp seen in this transaction -
                 * it should be the latest.
                 */
                if (tsp)
                        upd_vsl_ts(tsp);

                /* phase out old data */
                if (nhist == HIST_N) {
                        u = rr_hist[next_hist];
                        if (u >= hist_buckets) {
                                u -= hist_buckets;
                                assert(u < hist_buckets);
                                assert(bucket_hit[u] > 0);
                                bucket_hit[u]--;
                        } else {
                                assert(bucket_miss[u] > 0);
                                bucket_miss[u]--;
                        }
                } else {
                        ++nhist;
                }

                /* phase in new data */
                if (hit) {
                        bucket_hit[i]++;
                        rr_hist[next_hist] = i + hist_buckets;
                } else {
                        bucket_miss[i]++;
                        rr_hist[next_hist] = i;
                }
                if (++next_hist == HIST_N) {
                        next_hist = 0;
                }
                if (vsl_ts >= vsl_to)
                        delorean();
                PTOK(pthread_mutex_unlock(&mtx));
        }
        return (0);
}

static void * v_matchproto_(pthread_t)
do_curses(void *arg)
{
        int ch;
        (void)arg;

        initscr();
        AC(raw());
        AC(noecho());
        AC(nonl());
        AC(intrflush(stdscr, FALSE));
        AC(curs_set(0));
        AC(erase());
        while (!VSIG_int && !VSIG_term && !VSIG_hup) {

                AC(erase());
                PTOK(pthread_mutex_lock(&mtx));
                update();
                PTOK(pthread_mutex_unlock(&mtx));
                AC(refresh());

                assert(ms_delay > 0);
                timeout(ms_delay);
                switch ((ch = getch())) {
                case ERR:
                        break;
#ifdef KEY_RESIZE
                case KEY_RESIZE:
                        AC(erase());
                        break;
#endif
                case '\014':    /* Ctrl-L */
                case '\024':    /* Ctrl-T */
                        redrawwin(stdscr);
                        AC(refresh());
                        break;
                case '\032':    /* Ctrl-Z */
                        AC(endwin());
                        AZ(raise(SIGTSTP));
                        break;
                case '\003':    /* Ctrl-C */
                case '\021':    /* Ctrl-Q */
                case 'Q':
                case 'q':
                        AZ(raise(SIGINT));
                        break;
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                        ms_delay = 1000U << (ch - '0');
                        break;
                case '+':
                        ms_delay = vmax(ms_delay >> 1, 1U);
                        break;
                case '-':
                        ms_delay *= 2;
                        break;
                case '>':
                case '<':
                        /* see below */
                        break;
                default:
                        AC(beep());
                        break;
                }

                if (ch == '<' || ch == '>') {
                        PTOK(pthread_mutex_lock(&mtx));
                        vsl_to = vsl_t0 = vsl_ts;
                        t0 = VTIM_mono();
                        if (timebend == 0)
                                timebend = 1;
                        else if (ch == '<')
                                timebend /= 2;
                        else
                                timebend *= 2;
                        PTOK(pthread_cond_broadcast(&timebend_cv));
                        PTOK(pthread_mutex_unlock(&mtx));
                }
        }
        AC(endwin());
        return (NULL);
}

/*--------------------------------------------------------------------*/

static void v_noreturn_
profile_error(const char *s)
{
        fprintf(stderr, "-P: '%s' is not a valid"
            " profile name or definition\n", s);
        exit(1);
}

int
main(int argc, char **argv)
{
        int i;
        char *colon;
        const char *ptag, *profile = "responsetime";
        pthread_t thr;
        int fnum;
        struct profile cli_p = {0};

        vut = VUT_InitProg(argc, argv, &vopt_spec);
        AN(vut);
        PTOK(pthread_cond_init(&timebend_cv, NULL));

        while ((i = getopt(argc, argv, vopt_spec.vopt_optstring)) != -1) {
                switch (i) {
                case 'h':
                        /* Usage help */
                        VUT_Usage(vut, &vopt_spec, 0);
                case 'p':
                        ms_delay = lround(1e3 * strtod(optarg, NULL));
                        if (ms_delay == 0)
                                VUT_Error(vut, 1, "-p: invalid '%s'", optarg);
                        break;
                case 'P':
                        colon = strchr(optarg, ':');
                        /* no colon, take the profile as a name */
                        if (colon == NULL) {
                                profile = optarg;
                                break;
                        }
                        /* else check if valid definition */
                        if (colon == optarg + 1 && (*optarg == 'b' ||
                            *optarg == 'c' || *optarg == 'E')) {
                                cli_p.VSL_arg = *optarg;
                                ptag = colon + 1;
                                colon = strchr(colon + 1, ':');
                                if (colon == NULL)
                                        profile_error(optarg);
                        } else {
                                ptag = optarg;
                                cli_p.VSL_arg = 'c';
                        }

                        assert(colon);

                        match_tag = VSL_Name2Tag(ptag, colon - ptag);
                        if (match_tag < 0)
                                VUT_Error(vut, 1,
                                    "-P: '%s' is not a valid tag name",
                                    optarg);

                        if (VSL_tagflags[match_tag])
                                VUT_Error(vut, 1,
                                    "-P: '%s' is an unsafe or binary record",
                                    optarg);

                        cli_p.prefix = colon + 1;

                        colon = strchr(colon + 1, ':');
                        if (colon == NULL)
                                profile_error(optarg);

                        *colon = '\0';
                        if (*cli_p.prefix == '\0')
                                cli_p.prefix = NULL;

                        if (sscanf(colon + 1, "%d",  &cli_p.field) != 1)
                                profile_error(optarg);

                        cli_p.name = "custom";
                        cli_p.tag = (enum VSL_tag_e)match_tag;
                        cli_p.hist_low = -6;
                        cli_p.hist_high = 3;
                        profile = NULL;
                        active_profile = &cli_p;

                        colon = strchr(colon + 1, ':');
                        if (colon == NULL)
                                break;

                        if (sscanf(colon + 1, "%d:%d",  &cli_p.hist_low,
                                   &cli_p.hist_high) != 2)
                                profile_error(optarg);

                        break;
                case 'B':
                        timebend = strtod(optarg, NULL);
                        if (timebend == 0)
                                VUT_Error(vut, 1,
                                    "-B: being able to bend time does not"
                                    " mean we can stop it"
                                    " (invalid factor '%s')", optarg);
                        if (timebend < 0)
                                VUT_Error(vut, 1,
                                    "-B: being able to bend time does not"
                                    " mean we can make it go backwards"
                                    " (invalid factor '%s')", optarg);
                        break;
                default:
                        if (!VUT_Arg(vut, i, optarg))
                                VUT_Usage(vut, &vopt_spec, 1);
                }
        }

        if (optind != argc)
                VUT_Usage(vut, &vopt_spec, 1);

        /* Check for valid grouping mode */
        assert(vut->g_arg < VSL_g__MAX);
        if (vut->g_arg != VSL_g_vxid && vut->g_arg != VSL_g_request)
                VUT_Error(vut, 1, "Invalid grouping mode: %s"
                    " (only vxid and request are supported)",
                    VSLQ_grouping[vut->g_arg]);

        if (profile) {
                for (active_profile = profiles; active_profile->name;
                     active_profile++) {
                        if (strcmp(active_profile->name, profile) == 0)
                                break;
                }
        }
        AN(active_profile);
        if (!active_profile->name)
                VUT_Error(vut, 1, "-P: No such profile '%s'", profile);

        assert(active_profile->VSL_arg == 'b' ||
            active_profile->VSL_arg == 'c' ||
            active_profile->VSL_arg == 'E');
        assert(VUT_Arg(vut, active_profile->VSL_arg, NULL));
        match_tag = active_profile->tag;
        fnum = active_profile->field;
        hist_low = active_profile->hist_low;
        hist_high = active_profile->hist_high;

        hist_range = hist_high - hist_low;
        hist_buckets = hist_range * HIST_RES;
        bucket_hit = calloc(hist_buckets, sizeof *bucket_hit);
        bucket_miss = calloc(hist_buckets, sizeof *bucket_miss);

        if (timebend > 0)
                t0 = VTIM_mono();

        format = malloc(4L * fnum);
        AN(format);
        for (i = 0; i < fnum - 1; i++)
                strcpy(format + 4 * i, "%*s ");
        strcpy(format + 4 * (fnum - 1), "%lf");

        log_ten = log(10.0);

        VUT_Setup(vut);
        if (vut->vsm)
                ident = VSM_Dup(vut->vsm, "Arg", "-i");
        else
                ident = strdup("");
        PTOK(pthread_create(&thr, NULL, do_curses, NULL));
        vut->dispatch_f = accumulate;
        vut->dispatch_priv = NULL;
        (void)VUT_Main(vut);
        end_of_file = 1;
        PTOK(pthread_join(thr, NULL));
        VUT_Fini(&vut);
        exit(0);
}

		varnish-cache/bin/varnishhist/varnishhist.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2015 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		* Author: Dag-Erling Smørgrav <des@des.no>
7		* Author: Guillaume Quintard <guillaume.quintard@gmail.com>
8		*
9		* SPDX-License-Identifier: BSD-2-Clause
10		*
11		* Redistribution and use in source and binary forms, with or without
12		* modification, are permitted provided that the following conditions
13		* are met:
14		* 1. Redistributions of source code must retain the above copyright
15		* notice, this list of conditions and the following disclaimer.
16		* 2. Redistributions in binary form must reproduce the above copyright
17		* notice, this list of conditions and the following disclaimer in the
18		* documentation and/or other materials provided with the distribution.
19		*
20		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
24		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30		* SUCH DAMAGE.
31		*
32		* Log tailer for Varnish
33		*/
34
35		#include "config.h"
36
37		#include <limits.h>
38		#include <math.h>
39		#include <pthread.h>
40		#include <stdarg.h>
41		#include <stdlib.h>
42		#include <string.h>
43		#include <unistd.h>
44
45		#define VOPT_DEFINITION
46		#define VOPT_INC "varnishhist_options.h"
47
48		#include "vdef.h"
49		#include "vcurses.h"
50		#include "vapi/vsl.h"
51		#include "vapi/vsm.h"
52		#include "vapi/voptget.h"
53		#include "vapi/vsig.h"
54		#include "vas.h"
55		#include "vut.h"
56		#include "vtim.h"
57
58		#if 1
59		#define AC(x) assert((x) != ERR)
60		#else
61		#define AC(x) x
62		#endif
63
64		#define HIST_N 2000 /* how far back we remember */
65		#define HIST_RES 100 /* bucket resolution */
66
67		static struct VUT *vut;
68
69		static int hist_low;
70		static int hist_high;
71		static int hist_range;
72		static unsigned hist_buckets;
73
74		static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
75
76		static int end_of_file = 0;
77		static unsigned ms_delay = 1000;
78		static unsigned rr_hist[HIST_N];
79		static unsigned nhist;
80		static unsigned next_hist;
81		static unsigned *bucket_miss;
82		static unsigned *bucket_hit;
83		static char *format;
84		static int match_tag;
85		static double timebend = 0, t0;
86		static double vsl_t0 = 0, vsl_to, vsl_ts = 0;
87		static pthread_cond_t timebend_cv;
88		static double log_ten;
89		static char *ident;
90
91		static const unsigned scales[] = {
92		1,
93		2,
94		3,
95		4,
96		5,
97		10,
98		15,
99		20,
100		25,
101		50,
102		100,
103		250,
104		500,
105		1000,
106		2500,
107		5000,
108		10000,
109		25000,
110		50000,
111		100000,
112		UINT_MAX
113		};
114
115		struct profile {
116		const char *name;
117		char VSL_arg;
118		enum VSL_tag_e tag;
119		const char *prefix;
120		int field;
121		int hist_low;
122		int hist_high;
123		};
124
125		#define HIS_PROF(name,vsl_arg,tag,prefix,field,hist_low,high_high,doc) \
126		{name,vsl_arg,tag,prefix,field,hist_low,high_high},
127		#define HIS_NO_PREFIX NULL
128		#define HIS_CLIENT 'c'
129		#define HIS_BACKEND 'b'
130		static const struct profile profiles[] = {
131		#include "varnishhist_profiles.h"
132		{ NULL }
133		};
134		#undef HIS_NO_PREFIX
135		#undef HIS_BACKEND
136		#undef HIS_CLIENT
137		#undef HIS_PROF
138
139		static const struct profile *active_profile;
140
141		static void
142	46048	update(void)
143		{
144		char t[VTIM_FORMAT_SIZE];
145	46048	const unsigned w = COLS / hist_range;
146	46048	const unsigned n = w * hist_range;
147	46048	unsigned bm[n], bh[n];
148		unsigned max;
149		unsigned scale;
150		int i, j;
151		unsigned k, l;
152
153		/* Draw horizontal axis */
154	3364048	for (k = 0; k < n; ++k)
155	3318000	(void)mvaddch(LINES - 2, k, '-');
156	458254	for (i = 0, j = hist_low; i < hist_range; ++i, ++j) {
157	412206	(void)mvaddch(LINES - 2, w * i, '+');
158	412206	mvprintw(LINES - 1, w * i, "\|1e%d", j);
159	412206	}
160
161	46048	if (end_of_file)
162	2	mvprintw(0, 0, "%*s", COLS - 1, "EOF");
163		else
164	46046	mvprintw(0, 0, "%*s", COLS - 1, ident);
165
166		/* count our flock */
167	46048	memset(bm, 0, sizeof bm);
168	46048	memset(bh, 0, sizeof bh);
169	41266648	for (k = 0, max = 1; k < hist_buckets; ++k) {
170	41220600	l = k * n / hist_buckets;
171	41220600	assert(l < n);
172	41220600	bm[l] += bucket_miss[k];
173	41220600	bh[l] += bucket_hit[k];
174	41220600	max = vmax(max, bm[l] + bh[l]);
175	41220600	}
176
177		/* scale,time */
178	46048	assert(LINES - 3 >= 0);
179	46048	for (i = 0; max / scales[i] > (unsigned)(LINES - 3); ++i)
180		/* nothing */ ;
181	46048	scale = scales[i];
182
183	46048	if (vsl_t0 > 0) {
184	45093	VTIM_format(vsl_ts, t);
185
186	45093	mvprintw(0, 0, "1:%u, n = %u, d = %g @ %s x %g",
187	45093	scale, nhist, 1e-3 * ms_delay, t, timebend);
188	45093	} else
189	955	mvprintw(0, 0, "1:%u, n = %u, d = %g",
190	955	scale, nhist, 1e-3 * ms_delay);
191
192	230240	for (j = 5; j < LINES - 2; j += 5)
193	184192	mvprintw((LINES - 2) - j, 0, "%u_", j * scale);
194
195		/* show them */
196	3364048	for (k = 0; k < n; ++k) {
197	3363814	for (l = 0; l < bm[k] / scale; ++l)
198	45814	(void)mvaddch((LINES - 3) - l, k, '#');
199	3318440	for (; l < (bm[k] + bh[k]) / scale; ++l)
200	440	(void)mvaddch((LINES - 3) - l, k, '\|');
201	3318000	}
202	46048	}
203
204		inline static void
205	160	upd_vsl_ts(const char *p)
206		{
207
208	160	if (timebend == 0)
209	120	return;
210
211	40	p = strchr(p, ' ');
212
213	40	if (p == NULL)
214	0	return;
215
216	40	vsl_ts = vmax_t(double, vsl_ts, strtod(p + 1, NULL));
217	160	}
218
219		static void
220	160	delorean(void)
221		{
222		int i;
223	160	double t = VTIM_mono();
224
225	160	if (vsl_t0 == 0)
226	160	vsl_to = vsl_t0 = vsl_ts;
227
228	160	assert(t > t0);
229	160	vsl_to = vsl_t0 + (t - t0) * timebend;
230
231	160	if (vsl_ts > vsl_to) {
232	0	double when = VTIM_real() + vsl_ts - vsl_to;
233	0	struct timespec ts = VTIM_timespec(when);
234	0	i = pthread_cond_timedwait(&timebend_cv, &mtx, &ts);
235	0	assert(i == 0 \|\| i == ETIMEDOUT);
236	0	}
237	160	}
238
239		static int v_matchproto_ (VSLQ_dispatch_f)
240	240	accumulate(struct VSL_data vsl, struct VSL_transaction const pt[],
241		void *priv)
242		{
243		int i, tag, skip, match, hit;
244		unsigned u;
245	240	double value = 0;
246		struct VSL_transaction *tr;
247		const char *tsp;
248		enum vsl_status stat;
249
250	240	(void)vsl;
251	240	(void)priv;
252
253	480	for (tr = pt[0]; tr != NULL; tr = *++pt) {
254	240	if (VSIG_int \|\| VSIG_term \|\| VSIG_hup)
255	0	return (-1);
256
257	240	if (tr->reason == VSL_r_esi) {
258		/* Skip ESI requests */
259	0	continue;
260		}
261
262	240	hit = 0;
263	240	skip = 0;
264	240	match = 0;
265	240	tsp = NULL;
266	7320	while (skip == 0) {
267	7320	stat = VSL_Next(tr->c);
268	7320	if (stat == vsl_e_overrun) {
269		/* need to skip forward */
270	0	PTOK(pthread_mutex_lock(&mtx));
271	0	vsl_to = vsl_t0 = vsl_ts = 0;
272	0	t0 = VTIM_mono();
273	0	PTOK(pthread_mutex_unlock(&mtx));
274	0	break;
275		}
276	7320	if (stat != vsl_more)
277	240	break;
278
279		/* get the value we want and register if it's a hit */
280	7080	tag = VSL_TAG(tr->c->rec.ptr);
281
282	7080	if (VSL_tagflags[tag])
283	720	continue;
284
285	6360	switch (tag) {
286		case SLT_Hit:
287	40	hit = 1;
288	40	break;
289		case SLT_VCL_return:
290	480	if (!strcasecmp(VSL_CDATA(tr->c->rec.ptr),
291	480	"restart") \|\|
292	480	!strcasecmp(VSL_CDATA(tr->c->rec.ptr),
293		"retry"))
294	0	skip = 1;
295	480	break;
296		case SLT_Timestamp:
297	920	tsp = VSL_CDATA(tr->c->rec.ptr);
298		/* FALLTHROUGH */
299		default:
300	5840	if (tag != match_tag)
301	5160	break;
302
303	680	if (active_profile->prefix &&
304	1280	strncmp(VSL_CDATA(tr->c->rec.ptr),
305	640	active_profile->prefix,
306	1280	strlen(active_profile->prefix)) != 0)
307	520	break;
308
309	320	i = sscanf(VSL_CDATA(tr->c->rec.ptr),
310	160	format, &value);
311	160	if (i != 1)
312	0	break;
313	160	match = 1;
314	160	break;
315		}
316		}
317
318	240	if (skip \|\| !match \|\| value <= 0)
319	80	continue;
320
321		/* select bucket */
322	160	i = vlimit_t(int, lround(HIST_RES * log(value) / log_ten),
323	160	hist_low * HIST_RES, hist_high * HIST_RES - 1) -
324	160	hist_low * HIST_RES;
325	160	assert(i >= 0);
326	160	assert((unsigned)i < hist_buckets);
327
328	160	PTOK(pthread_mutex_lock(&mtx));
329
330		/*
331		* only parse the last tsp seen in this transaction -
332		* it should be the latest.
333		*/
334	160	if (tsp)
335	160	upd_vsl_ts(tsp);
336
337		/* phase out old data */
338	160	if (nhist == HIST_N) {
339	0	u = rr_hist[next_hist];
340	0	if (u >= hist_buckets) {
341	0	u -= hist_buckets;
342	0	assert(u < hist_buckets);
343	0	assert(bucket_hit[u] > 0);
344	0	bucket_hit[u]--;
345	0	} else {
346	0	assert(bucket_miss[u] > 0);
347	0	bucket_miss[u]--;
348		}
349	0	} else {
350	160	++nhist;
351		}
352
353		/* phase in new data */
354	160	if (hit) {
355	40	bucket_hit[i]++;
356	40	rr_hist[next_hist] = i + hist_buckets;
357	40	} else {
358	120	bucket_miss[i]++;
359	120	rr_hist[next_hist] = i;
360		}
361	160	if (++next_hist == HIST_N) {
362	0	next_hist = 0;
363	0	}
364	160	if (vsl_ts >= vsl_to)
365	160	delorean();
366	160	PTOK(pthread_mutex_unlock(&mtx));
367	160	}
368	240	return (0);
369	240	}
370
371		static void * v_matchproto_(pthread_t)
372	120	do_curses(void *arg)
373		{
374		int ch;
375	120	(void)arg;
376
377	120	initscr();
378	120	AC(raw());
379	120	AC(noecho());
380	120	AC(nonl());
381	120	AC(intrflush(stdscr, FALSE));
382	120	AC(curs_set(0));
383	120	AC(erase());
384	46168	while (!VSIG_int && !VSIG_term && !VSIG_hup) {
385
386	46048	AC(erase());
387	46048	PTOK(pthread_mutex_lock(&mtx));
388	46048	update();
389	46048	PTOK(pthread_mutex_unlock(&mtx));
390	46048	AC(refresh());
391
392	46048	assert(ms_delay > 0);
393	46048	timeout(ms_delay);
394	46048	switch ((ch = getch())) {
395		case ERR:
396	45088	break;
397		#ifdef KEY_RESIZE
398		case KEY_RESIZE:
399	40	AC(erase());
400	40	break;
401		#endif
402		case '\014': /* Ctrl-L */
403		case '\024': /* Ctrl-T */
404	40	redrawwin(stdscr);
405	40	AC(refresh());
406	40	break;
407		case '\032': /* Ctrl-Z */
408	0	AC(endwin());
409	0	AZ(raise(SIGTSTP));
410	0	break;
411		case '\003': /* Ctrl-C */
412		case '\021': /* Ctrl-Q */
413		case 'Q':
414		case 'q':
415	40	AZ(raise(SIGINT));
416	40	break;
417		case '0':
418		case '1':
419		case '2':
420		case '3':
421		case '4':
422		case '5':
423		case '6':
424		case '7':
425		case '8':
426		case '9':
427	80	ms_delay = 1000U << (ch - '0');
428	80	break;
429		case '+':
430	480	ms_delay = vmax(ms_delay >> 1, 1U);
431	480	break;
432		case '-':
433	80	ms_delay *= 2;
434	80	break;
435		case '>':
436		case '<':
437		/* see below */
438	160	break;
439		default:
440	40	AC(beep());
441	40	break;
442		}
443
444	46048	if (ch == '<' \|\| ch == '>') {
445	160	PTOK(pthread_mutex_lock(&mtx));
446	160	vsl_to = vsl_t0 = vsl_ts;
447	160	t0 = VTIM_mono();
448	160	if (timebend == 0)
449	40	timebend = 1;
450	120	else if (ch == '<')
451	80	timebend /= 2;
452		else
453	40	timebend *= 2;
454	160	PTOK(pthread_cond_broadcast(&timebend_cv));
455	160	PTOK(pthread_mutex_unlock(&mtx));
456	160	}
457		}
458	120	AC(endwin());
459	120	return (NULL);
460		}
461
462		/--------------------------------------------------------------------/
463
464		static void v_noreturn_
465	200	profile_error(const char *s)
466		{
467	400	fprintf(stderr, "-P: '%s' is not a valid"
468	200	" profile name or definition\n", s);
469	200	exit(1);
470		}
471
472		int
473	760	main(int argc, char **argv)
474		{
475		int i;
476		char *colon;
477	760	const char ptag, profile = "responsetime";
478		pthread_t thr;
479		int fnum;
480	760	struct profile cli_p = {0};
481
482	760	vut = VUT_InitProg(argc, argv, &vopt_spec);
483	760	AN(vut);
484	760	PTOK(pthread_cond_init(&timebend_cv, NULL));
485
486	1120	while ((i = getopt(argc, argv, vopt_spec.vopt_optstring)) != -1) {
487	880	switch (i) {
488		case 'h':
489		/* Usage help */
490	40	VUT_Usage(vut, &vopt_spec, 0);
491		case 'p':
492	120	ms_delay = lround(1e3 * strtod(optarg, NULL));
493	120	if (ms_delay == 0)
494	80	VUT_Error(vut, 1, "-p: invalid '%s'", optarg);
495	40	break;
496		case 'P':
497	440	colon = strchr(optarg, ':');
498		/* no colon, take the profile as a name */
499	440	if (colon == NULL) {