| | vinyl-cache/bin/vinylstat/vinylstat_curses.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: Martin Blix Grydeland <martin@varnish-software.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 |
|
* Statistics output program |
| 33 |
|
*/ |
| 34 |
|
|
| 35 |
|
#include "config.h" |
| 36 |
|
|
| 37 |
|
#include <stdlib.h> |
| 38 |
|
#include <unistd.h> |
| 39 |
|
#include <string.h> |
| 40 |
|
#include <stdint.h> |
| 41 |
|
#include <math.h> |
| 42 |
|
|
| 43 |
|
#include "vdef.h" |
| 44 |
|
#include "vas.h" |
| 45 |
|
#include "miniobj.h" |
| 46 |
|
#include "vqueue.h" |
| 47 |
|
#include "vtim.h" |
| 48 |
|
#include "vapi/vsig.h" |
| 49 |
|
|
| 50 |
|
#include "vinylstat.h" |
| 51 |
|
#include "vcurses.h" |
| 52 |
|
|
| 53 |
|
#define LINES_STATUS 3 |
| 54 |
|
#define LINES_BAR_T 1 |
| 55 |
|
#define LINES_BAR_B 1 |
| 56 |
|
#define LINES_INFO 3 |
| 57 |
|
#define LINES_POINTS_MIN 3 |
| 58 |
|
|
| 59 |
|
#define N_COL 6 |
| 60 |
|
#define COLW 14 |
| 61 |
|
#define COLW_NAME_MIN 24 |
| 62 |
|
|
| 63 |
|
#define VALUE_MAX 999999999999 |
| 64 |
|
|
| 65 |
|
#define REBUILD_NEXT (1u << 0) |
| 66 |
|
#define REBUILD_FIRST (1u << 1) |
| 67 |
|
|
| 68 |
|
enum kb_e { |
| 69 |
|
#define BINDING(name, desc) KB_ ## name, |
| 70 |
|
#define BINDING_SIG |
| 71 |
|
#include "vinylstat_bindings.h" |
| 72 |
|
}; |
| 73 |
|
|
| 74 |
|
struct ma { |
| 75 |
|
unsigned n, nmax; |
| 76 |
|
double acc; |
| 77 |
|
}; |
| 78 |
|
|
| 79 |
|
struct pt { |
| 80 |
|
unsigned magic; |
| 81 |
|
#define PT_MAGIC 0x41698E4F |
| 82 |
|
VTAILQ_ENTRY(pt) list; |
| 83 |
|
|
| 84 |
|
const struct VSC_point *vpt; |
| 85 |
|
|
| 86 |
|
char seen; |
| 87 |
|
|
| 88 |
|
uint64_t cur, last; |
| 89 |
|
double t_cur, t_last; |
| 90 |
|
double chg, avg; |
| 91 |
|
|
| 92 |
|
struct ma ma_10, ma_100, ma_1000; |
| 93 |
|
}; |
| 94 |
|
|
| 95 |
|
struct hitrate { |
| 96 |
|
uint64_t lhit, lmiss; |
| 97 |
|
struct ma hr_10; |
| 98 |
|
struct ma hr_100; |
| 99 |
|
struct ma hr_1000; |
| 100 |
|
}; |
| 101 |
|
static struct hitrate hitrate; |
| 102 |
|
|
| 103 |
|
static VTAILQ_HEAD(, pt) ptlist = VTAILQ_HEAD_INITIALIZER(ptlist); |
| 104 |
|
static int n_ptlist = 0; |
| 105 |
|
static int n_ptarray = 0; |
| 106 |
|
static struct pt **ptarray = NULL; |
| 107 |
|
static const volatile uint64_t *mgt_uptime; |
| 108 |
|
static const volatile uint64_t *main_uptime; |
| 109 |
|
static const volatile uint64_t *main_cache_hit; |
| 110 |
|
static const volatile uint64_t *main_cache_miss; |
| 111 |
|
|
| 112 |
|
static int l_status, l_bar_t, l_points, l_bar_b, l_info; |
| 113 |
|
static unsigned colw_name = COLW_NAME_MIN; |
| 114 |
|
static WINDOW *w_status = NULL; |
| 115 |
|
static WINDOW *w_bar_t = NULL; |
| 116 |
|
static WINDOW *w_points = NULL; |
| 117 |
|
static WINDOW *w_bar_b = NULL; |
| 118 |
|
static WINDOW *w_info = NULL; |
| 119 |
|
|
| 120 |
|
static const struct VSC_level_desc *verbosity; |
| 121 |
|
static int show_help = 0; |
| 122 |
|
static int help_line = 0; |
| 123 |
|
static int keep_running = 1; |
| 124 |
|
static int hide_unseen = 1; |
| 125 |
|
static int raw_vsc = 0; |
| 126 |
|
static int page_start = 0; |
| 127 |
|
static int current = 0; |
| 128 |
|
static int rebuild = 0; |
| 129 |
|
static int redraw = 0; |
| 130 |
|
static int sample = 0; |
| 131 |
|
static int reset_averages = 0; |
| 132 |
|
static int scale = 1; |
| 133 |
|
static double t_sample = 0.; |
| 134 |
|
static double interval = 1.; |
| 135 |
|
static unsigned vsm_status = 0; |
| 136 |
|
|
| 137 |
|
#define NOTIF_MAXLEN 256 |
| 138 |
|
static char notification_message[NOTIF_MAXLEN] = ""; |
| 139 |
|
static vtim_mono notification_eol = 0.0; |
| 140 |
|
|
| 141 |
|
static void |
| 142 |
28 |
init_hitrate(void) |
| 143 |
|
{ |
| 144 |
28 |
memset(&hitrate, 0, sizeof (struct hitrate)); |
| 145 |
28 |
if (main_cache_hit != NULL) { |
| 146 |
28 |
hitrate.lhit = *main_cache_hit; |
| 147 |
28 |
hitrate.lmiss = *main_cache_miss; |
| 148 |
28 |
} |
| 149 |
28 |
hitrate.hr_10.nmax = 10; |
| 150 |
28 |
hitrate.hr_100.nmax = 100; |
| 151 |
28 |
hitrate.hr_1000.nmax = 1000; |
| 152 |
28 |
} |
| 153 |
|
|
| 154 |
|
static void |
| 155 |
24249 |
update_ma(struct ma *ma, double val) |
| 156 |
|
{ |
| 157 |
24249 |
AN(ma); |
| 158 |
24249 |
AN(ma->nmax); |
| 159 |
24249 |
if (ma->n < ma->nmax) |
| 160 |
24249 |
ma->n++; |
| 161 |
24249 |
ma->acc += (val - ma->acc) / (double)ma->n; |
| 162 |
24249 |
} |
| 163 |
|
|
| 164 |
|
static void |
| 165 |
242 |
update_position(void) |
| 166 |
|
{ |
| 167 |
|
int old_current, old_page_start; |
| 168 |
|
|
| 169 |
242 |
old_current = current; |
| 170 |
242 |
old_page_start = page_start; |
| 171 |
|
|
| 172 |
242 |
if (n_ptarray == 0) { |
| 173 |
107 |
current = 0; |
| 174 |
107 |
page_start = 0; |
| 175 |
107 |
} else { |
| 176 |
135 |
current = vlimit_t(int, current, 0, n_ptarray - 1); |
| 177 |
135 |
page_start = vmin(page_start, current); |
| 178 |
135 |
if (current > page_start + (l_points - 1)) |
| 179 |
8 |
page_start = current - (l_points - 1); |
| 180 |
135 |
page_start = vlimit_t(int, page_start, 0, n_ptarray - 1); |
| 181 |
|
} |
| 182 |
|
|
| 183 |
242 |
if (current != old_current || page_start != old_page_start) |
| 184 |
47 |
redraw = 1; |
| 185 |
242 |
} |
| 186 |
|
|
| 187 |
|
static void |
| 188 |
79 |
delete_pt_array(void) |
| 189 |
|
{ |
| 190 |
79 |
if (ptarray != NULL) |
| 191 |
79 |
free(ptarray); |
| 192 |
79 |
ptarray = NULL; |
| 193 |
79 |
n_ptarray = 0; |
| 194 |
|
|
| 195 |
79 |
update_position(); |
| 196 |
79 |
} |
| 197 |
|
|
| 198 |
|
static void |
| 199 |
107 |
build_pt_array(void) |
| 200 |
|
{ |
| 201 |
|
int i; |
| 202 |
|
struct pt *pt; |
| 203 |
107 |
struct pt *pt_current = NULL; |
| 204 |
107 |
int current_line = 0; |
| 205 |
|
|
| 206 |
107 |
if (current < n_ptarray) { |
| 207 |
51 |
pt_current = ptarray[current]; |
| 208 |
51 |
current_line = current - page_start; |
| 209 |
51 |
} |
| 210 |
|
|
| 211 |
107 |
if (ptarray != NULL) |
| 212 |
79 |
delete_pt_array(); |
| 213 |
107 |
AZ(n_ptarray); |
| 214 |
107 |
ptarray = calloc(n_ptlist, sizeof *ptarray); |
| 215 |
107 |
AN(ptarray); |
| 216 |
|
|
| 217 |
39450 |
VTAILQ_FOREACH(pt, &ptlist, list) { |
| 218 |
39343 |
CHECK_OBJ_NOTNULL(pt, PT_MAGIC); |
| 219 |
39343 |
if (pt->vpt->level > verbosity) { |
| 220 |
22319 |
if (has_f && (rebuild & REBUILD_FIRST)) |
| 221 |
24 |
verbosity = VSC_ChangeLevel(verbosity, |
| 222 |
12 |
pt->vpt->level - verbosity); |
| 223 |
|
else |
| 224 |
22307 |
continue; |
| 225 |
12 |
} |
| 226 |
17036 |
if (!pt->seen && hide_unseen) |
| 227 |
13881 |
continue; |
| 228 |
3155 |
assert(n_ptarray < n_ptlist); |
| 229 |
3155 |
ptarray[n_ptarray++] = pt; |
| 230 |
3155 |
} |
| 231 |
107 |
assert(n_ptarray <= n_ptlist); |
| 232 |
|
|
| 233 |
1931 |
for (i = 0; pt_current != NULL && i < n_ptarray; i++) |
| 234 |
1875 |
if (ptarray[i] == pt_current) |
| 235 |
51 |
break; |
| 236 |
107 |
current = i; |
| 237 |
107 |
page_start = current - current_line; |
| 238 |
107 |
update_position(); |
| 239 |
|
|
| 240 |
107 |
rebuild = 0; |
| 241 |
107 |
redraw = 1; |
| 242 |
107 |
} |
| 243 |
|
|
| 244 |
|
static void |
| 245 |
114 |
sample_points(void) |
| 246 |
|
{ |
| 247 |
|
struct pt *pt; |
| 248 |
|
uint64_t v; |
| 249 |
|
|
| 250 |
42408 |
VTAILQ_FOREACH(pt, &ptlist, list) { |
| 251 |
42294 |
AN(pt->vpt); |
| 252 |
42294 |
AN(pt->vpt->ptr); |
| 253 |
42294 |
v = VSC_Value(pt->vpt); |
| 254 |
42294 |
if (v == 0 && !pt->seen) |
| 255 |
32427 |
continue; |
| 256 |
9867 |
if (!pt->seen) { |
| 257 |
2476 |
pt->seen = 1; |
| 258 |
2476 |
rebuild = REBUILD_NEXT; |
| 259 |
2476 |
} |
| 260 |
9867 |
pt->last = pt->cur; |
| 261 |
9867 |
pt->cur = v; |
| 262 |
9867 |
pt->t_last = pt->t_cur; |
| 263 |
9867 |
pt->t_cur = VTIM_mono(); |
| 264 |
|
|
| 265 |
9867 |
if (reset_averages) { |
| 266 |
484 |
pt->chg = 0; |
| 267 |
484 |
pt->ma_10.n = 0; |
| 268 |
484 |
pt->ma_100.n = 0; |
| 269 |
484 |
pt->ma_1000.n = 0; |
| 270 |
484 |
} |
| 271 |
9867 |
if (pt->t_last) |
| 272 |
14782 |
pt->chg = ((int64_t)pt->cur - (int64_t)pt->last) / |
| 273 |
7391 |
(pt->t_cur - pt->t_last); |
| 274 |
|
|
| 275 |
9867 |
if (pt->vpt->semantics == 'g') { |
| 276 |
2710 |
pt->avg = 0.; |
| 277 |
2710 |
update_ma(&pt->ma_10, (int64_t)pt->cur); |
| 278 |
2710 |
update_ma(&pt->ma_100, (int64_t)pt->cur); |
| 279 |
2710 |
update_ma(&pt->ma_1000, (int64_t)pt->cur); |
| 280 |
9867 |
} else if (pt->vpt->semantics == 'c') { |
| 281 |
7063 |
if (main_uptime != NULL && *main_uptime) |
| 282 |
5995 |
pt->avg = pt->cur / (double)*main_uptime; |
| 283 |
|
else |
| 284 |
1068 |
pt->avg = 0.; |
| 285 |
7063 |
if (pt->t_last) { |
| 286 |
5259 |
update_ma(&pt->ma_10, pt->chg); |
| 287 |
5259 |
update_ma(&pt->ma_100, pt->chg); |
| 288 |
5259 |
update_ma(&pt->ma_1000, pt->chg); |
| 289 |
5259 |
} |
| 290 |
7063 |
} |
| 291 |
9867 |
} |
| 292 |
114 |
} |
| 293 |
|
|
| 294 |
|
static void |
| 295 |
114 |
sample_hitrate(void) |
| 296 |
|
{ |
| 297 |
|
double hr, mr, ratio; |
| 298 |
|
uint64_t hit, miss; |
| 299 |
|
|
| 300 |
114 |
if (main_cache_hit == NULL) |
| 301 |
0 |
return; |
| 302 |
|
|
| 303 |
114 |
hit = *main_cache_hit; |
| 304 |
114 |
miss = *main_cache_miss; |
| 305 |
114 |
hr = hit - hitrate.lhit; |
| 306 |
114 |
mr = miss - hitrate.lmiss; |
| 307 |
114 |
hitrate.lhit = hit; |
| 308 |
114 |
hitrate.lmiss = miss; |
| 309 |
|
|
| 310 |
114 |
if (hr + mr != 0) |
| 311 |
16 |
ratio = hr / (hr + mr); |
| 312 |
|
else |
| 313 |
98 |
ratio = 0; |
| 314 |
114 |
if (reset_averages) { |
| 315 |
4 |
hitrate.hr_10.n = 0; |
| 316 |
4 |
hitrate.hr_100.n = 0; |
| 317 |
4 |
hitrate.hr_1000.n = 0; |
| 318 |
4 |
} |
| 319 |
114 |
update_ma(&hitrate.hr_10, ratio); |
| 320 |
114 |
update_ma(&hitrate.hr_100, ratio); |
| 321 |
114 |
update_ma(&hitrate.hr_1000, ratio); |
| 322 |
114 |
} |
| 323 |
|
|
| 324 |
|
static void |
| 325 |
114 |
sample_data(void) |
| 326 |
|
{ |
| 327 |
114 |
t_sample = VTIM_mono(); |
| 328 |
114 |
sample = 0; |
| 329 |
114 |
redraw = 1; |
| 330 |
114 |
sample_points(); |
| 331 |
114 |
sample_hitrate(); |
| 332 |
114 |
reset_averages = 0; |
| 333 |
114 |
} |
| 334 |
|
|
| 335 |
|
static void |
| 336 |
160 |
destroy_window(WINDOW **w) |
| 337 |
|
{ |
| 338 |
|
|
| 339 |
160 |
AN(w); |
| 340 |
160 |
if (*w == NULL) |
| 341 |
140 |
return; |
| 342 |
20 |
AC(delwin(*w)); |
| 343 |
20 |
*w = NULL; |
| 344 |
160 |
} |
| 345 |
|
|
| 346 |
|
static void |
| 347 |
32 |
make_windows(void) |
| 348 |
|
{ |
| 349 |
|
int Y, X; |
| 350 |
|
int y; |
| 351 |
|
int y_status, y_bar_t, y_points, y_bar_b, y_info; |
| 352 |
|
|
| 353 |
32 |
destroy_window(&w_status); |
| 354 |
32 |
destroy_window(&w_bar_t); |
| 355 |
32 |
destroy_window(&w_points); |
| 356 |
32 |
destroy_window(&w_bar_b); |
| 357 |
32 |
destroy_window(&w_info); |
| 358 |
|
|
| 359 |
32 |
Y = LINES; |
| 360 |
32 |
X = COLS; |
| 361 |
|
|
| 362 |
32 |
l_status = LINES_STATUS; |
| 363 |
32 |
l_bar_t = LINES_BAR_T; |
| 364 |
32 |
l_bar_b = LINES_BAR_B; |
| 365 |
32 |
l_info = LINES_INFO; |
| 366 |
32 |
l_points = Y - (l_status + l_bar_t + l_bar_b + l_info); |
| 367 |
32 |
if (l_points < LINES_POINTS_MIN) { |
| 368 |
0 |
l_points += l_info; |
| 369 |
0 |
l_info = 0; |
| 370 |
0 |
} |
| 371 |
32 |
l_points = vmax(l_points, LINES_POINTS_MIN); |
| 372 |
|
|
| 373 |
32 |
y = 0; |
| 374 |
32 |
y_status = y; |
| 375 |
32 |
y += l_status; |
| 376 |
32 |
y_bar_t = y; |
| 377 |
32 |
y += l_bar_t; |
| 378 |
32 |
y_points = y; |
| 379 |
32 |
y += l_points; |
| 380 |
32 |
y_bar_b = y; |
| 381 |
32 |
y += l_bar_b; |
| 382 |
32 |
y_info = y; |
| 383 |
32 |
y += l_info; |
| 384 |
32 |
assert(y >= Y); |
| 385 |
|
|
| 386 |
32 |
w_status = newwin(l_status, X, y_status, 0); |
| 387 |
32 |
AN(w_status); |
| 388 |
32 |
AC(nodelay(w_status, 1)); |
| 389 |
32 |
AC(keypad(w_status, 1)); |
| 390 |
32 |
AC(wnoutrefresh(w_status)); |
| 391 |
|
|
| 392 |
32 |
w_bar_t = newwin(l_bar_t, X, y_bar_t, 0); |
| 393 |
32 |
AN(w_bar_t); |
| 394 |
32 |
wbkgd(w_bar_t, A_REVERSE); |
| 395 |
32 |
AC(wnoutrefresh(w_bar_t)); |
| 396 |
|
|
| 397 |
32 |
w_points = newwin(l_points, X, y_points, 0); |
| 398 |
32 |
AN(w_points); |
| 399 |
32 |
AC(wnoutrefresh(w_points)); |
| 400 |
|
|
| 401 |
32 |
w_bar_b = newwin(l_bar_b, X, y_bar_b, 0); |
| 402 |
32 |
AN(w_bar_b); |
| 403 |
32 |
wbkgd(w_bar_b, A_REVERSE); |
| 404 |
32 |
AC(wnoutrefresh(w_bar_b)); |
| 405 |
|
|
| 406 |
32 |
if (l_info) { |
| 407 |
32 |
w_info = newwin(l_info, X, y_info, 0); |
| 408 |
32 |
AN(w_info); |
| 409 |
32 |
AC(wnoutrefresh(w_info)); |
| 410 |
32 |
} |
| 411 |
|
|
| 412 |
32 |
if (X - COLW_NAME_MIN > N_COL * COLW) |
| 413 |
4 |
colw_name = X - (N_COL * COLW); |
| 414 |
|
else |
| 415 |
28 |
colw_name = COLW_NAME_MIN; |
| 416 |
|
|
| 417 |
32 |
redraw = 1; |
| 418 |
32 |
} |
| 419 |
|
|
| 420 |
|
static void |
| 421 |
303 |
print_duration(WINDOW *w, uint64_t t) |
| 422 |
|
{ |
| 423 |
|
|
| 424 |
303 |
IC(wprintw(w, "%4ju+%02ju:%02ju:%02ju", |
| 425 |
|
(uintmax_t)t / 86400, (uintmax_t)(t % 86400) / 3600, |
| 426 |
|
(uintmax_t)(t % 3600) / 60, (uintmax_t)t % 60)); |
| 427 |
303 |
} |
| 428 |
|
|
| 429 |
|
static void |
| 430 |
380 |
running(WINDOW *w, uint64_t up, int flg) |
| 431 |
|
{ |
| 432 |
380 |
if (vsm_status & flg) { |
| 433 |
299 |
print_duration(w_status, up); |
| 434 |
299 |
} else { |
| 435 |
81 |
wattron(w, A_STANDOUT); |
| 436 |
81 |
IC(wprintw(w, " Not Running")); |
| 437 |
81 |
wattroff(w, A_STANDOUT); |
| 438 |
|
} |
| 439 |
380 |
} |
| 440 |
|
|
| 441 |
|
static void |
| 442 |
190 |
draw_status(void) |
| 443 |
|
{ |
| 444 |
190 |
uint64_t up_mgt = 0; |
| 445 |
190 |
uint64_t up_chld = 0; |
| 446 |
|
|
| 447 |
190 |
AN(w_status); |
| 448 |
|
|
| 449 |
190 |
AC(werase(w_status)); |
| 450 |
|
|
| 451 |
190 |
if (mgt_uptime != NULL) |
| 452 |
190 |
up_mgt = *mgt_uptime; |
| 453 |
190 |
if (main_uptime != NULL) |
| 454 |
190 |
up_chld = *main_uptime; |
| 455 |
|
|
| 456 |
190 |
IC(mvwprintw(w_status, 0, 0, "Uptime mgt: ")); |
| 457 |
190 |
running(w_status, up_mgt, VSM_MGT_RUNNING); |
| 458 |
190 |
IC(mvwprintw(w_status, 1, 0, "Uptime child: ")); |
| 459 |
190 |
running(w_status, up_chld, VSM_WRK_RUNNING); |
| 460 |
190 |
IC(mvwprintw(w_status, 2, 0, "Press <h> to toggle help screen")); |
| 461 |
|
|
| 462 |
190 |
if (VTIM_mono() < notification_eol) |
| 463 |
65 |
mvwaddstr(w_status, 2, 0, notification_message); |
| 464 |
|
|
| 465 |
190 |
if (COLS > 70) { |
| 466 |
190 |
IC(mvwprintw(w_status, 0, getmaxx(w_status) - 37, |
| 467 |
|
"Hitrate n: %8u %8u %8u", hitrate.hr_10.n, hitrate.hr_100.n, |
| 468 |
|
hitrate.hr_1000.n)); |
| 469 |
190 |
IC(mvwprintw(w_status, 1, getmaxx(w_status) - 37, |
| 470 |
|
" avg(n): %8.4f %8.4f %8.4f", hitrate.hr_10.acc, |
| 471 |
|
hitrate.hr_100.acc, hitrate.hr_1000.acc)); |
| 472 |
190 |
} |
| 473 |
|
|
| 474 |
190 |
AC(wnoutrefresh(w_status)); |
| 475 |
190 |
} |
| 476 |
|
|
| 477 |
|
static void |
| 478 |
178 |
draw_bar_t(void) |
| 479 |
|
{ |
| 480 |
|
int X, x; |
| 481 |
|
enum { |
| 482 |
|
COL_CUR, |
| 483 |
|
COL_CHG, |
| 484 |
|
COL_AVG, |
| 485 |
|
COL_MA10, |
| 486 |
|
COL_MA100, |
| 487 |
|
COL_MA1000, |
| 488 |
|
COL_LAST |
| 489 |
|
} col; |
| 490 |
|
|
| 491 |
178 |
AN(w_bar_t); |
| 492 |
|
|
| 493 |
178 |
X = getmaxx(w_bar_t); |
| 494 |
178 |
x = 0; |
| 495 |
178 |
AC(werase(w_bar_t)); |
| 496 |
178 |
if (page_start > 0) |
| 497 |
116 |
IC(mvwprintw(w_bar_t, 0, x, "^^^")); |
| 498 |
178 |
x += 4; |
| 499 |
178 |
IC(mvwprintw(w_bar_t, 0, x, "%.*s", colw_name - 4, "NAME")); |
| 500 |
178 |
x += colw_name - 4; |
| 501 |
178 |
col = COL_CUR; |
| 502 |
946 |
while (col < COL_LAST) { |
| 503 |
918 |
if (X - x < COLW) |
| 504 |
150 |
break; |
| 505 |
768 |
switch (col) { |
| 506 |
|
case COL_CUR: |
| 507 |
178 |
IC(mvwprintw(w_bar_t, 0, x, " %12.12s", "CURRENT")); |
| 508 |
178 |
break; |
| 509 |
|
case COL_CHG: |
| 510 |
178 |
IC(mvwprintw(w_bar_t, 0, x, " %12.12s", "CHANGE")); |
| 511 |
178 |
break; |
| 512 |
|
case COL_AVG: |
| 513 |
178 |
IC(mvwprintw(w_bar_t, 0, x, " %12.12s", "AVERAGE")); |
| 514 |
178 |
break; |
| 515 |
|
case COL_MA10: |
| 516 |
178 |
IC(mvwprintw(w_bar_t, 0, x, " %12.12s", "AVG_10")); |
| 517 |
178 |
break; |
| 518 |
|
case COL_MA100: |
| 519 |
28 |
IC(mvwprintw(w_bar_t, 0, x, " %12.12s", "AVG_100")); |
| 520 |
28 |
break; |
| 521 |
|
case COL_MA1000: |
| 522 |
28 |
IC(mvwprintw(w_bar_t, 0, x, " %12.12s", "AVG_1000")); |
| 523 |
28 |
break; |
| 524 |
|
default: |
| 525 |
0 |
break; |
| 526 |
|
} |
| 527 |
768 |
x += COLW; |
| 528 |
768 |
col++; |
| 529 |
|
} |
| 530 |
|
|
| 531 |
178 |
AC(wnoutrefresh(w_bar_t)); |
| 532 |
178 |
} |
| 533 |
|
|
| 534 |
|
static void |
| 535 |
1358 |
draw_line_default(WINDOW *w, int y, int x, int X, const struct pt *pt) |
| 536 |
|
{ |
| 537 |
|
enum { |
| 538 |
|
COL_CUR, |
| 539 |
|
COL_CHG, |
| 540 |
|
COL_AVG, |
| 541 |
|
COL_MA10, |
| 542 |
|
COL_MA100, |
| 543 |
|
COL_MA1000, |
| 544 |
|
COL_LAST |
| 545 |
|
} col; |
| 546 |
|
|
| 547 |
1358 |
AN(w); |
| 548 |
1358 |
AN(pt); |
| 549 |
|
|
| 550 |
1358 |
col = COL_CUR; |
| 551 |
7462 |
while (col < COL_LAST) { |
| 552 |
7126 |
if (X - x < COLW) |
| 553 |
1022 |
break; |
| 554 |
6104 |
switch (col) { |
| 555 |
|
case COL_CUR: |
| 556 |
1358 |
IC(mvwprintw(w, y, x, " %12ju", (uintmax_t)pt->cur)); |
| 557 |
1358 |
break; |
| 558 |
|
case COL_CHG: |
| 559 |
1358 |
if (pt->t_last) |
| 560 |
978 |
IC(mvwprintw(w, y, x, " %12.2f", pt->chg)); |
| 561 |
|
else |
| 562 |
380 |
IC(mvwprintw(w, y, x, " %12s", ". ")); |
| 563 |
1358 |
break; |
| 564 |
|
case COL_AVG: |
| 565 |
1358 |
if (pt->avg) |
| 566 |
386 |
IC(mvwprintw(w, y, x, " %12.2f", pt->avg)); |
| 567 |
|
else |
| 568 |
972 |
IC(mvwprintw(w, y, x, " %12s", ". ")); |
| 569 |
1358 |
break; |
| 570 |
|
case COL_MA10: |
| 571 |
1358 |
IC(mvwprintw(w, y, x, " %12.2f", pt->ma_10.acc)); |
| 572 |
1358 |
break; |
| 573 |
|
case COL_MA100: |
| 574 |
336 |
IC(mvwprintw(w, y, x, " %12.2f", pt->ma_100.acc)); |
| 575 |
336 |
break; |
| 576 |
|
case COL_MA1000: |
| 577 |
336 |
IC(mvwprintw(w, y, x, " %12.2f", pt->ma_1000.acc)); |
| 578 |
336 |
break; |
| 579 |
|
default: |
| 580 |
0 |
break; |
| 581 |
|
} |
| 582 |
6104 |
x += COLW; |
| 583 |
6104 |
col++; |
| 584 |
|
} |
| 585 |
1358 |
} |
| 586 |
|
|
| 587 |
|
static double |
| 588 |
757 |
scale_bytes(double val, char *q) |
| 589 |
|
{ |
| 590 |
|
const char *p; |
| 591 |
|
|
| 592 |
969 |
for (p = " KMGTPEZY"; *p; p++) { |
| 593 |
969 |
if (fabs(val) < 1024.) |
| 594 |
757 |
break; |
| 595 |
212 |
val /= 1024.; |
| 596 |
212 |
} |
| 597 |
757 |
*q = *p; |
| 598 |
757 |
return (val); |
| 599 |
|
} |
| 600 |
|
|
| 601 |
|
static void |
| 602 |
1293 |
print_bytes(WINDOW *w, double val) |
| 603 |
|
{ |
| 604 |
1293 |
char q = ' '; |
| 605 |
|
|
| 606 |
1293 |
if (scale) |
| 607 |
757 |
val = scale_bytes(val, &q); |
| 608 |
1293 |
IC(wprintw(w, " %12.2f%c", val, q)); |
| 609 |
1293 |
} |
| 610 |
|
|
| 611 |
|
static void |
| 612 |
476 |
print_trunc(WINDOW *w, uintmax_t val) |
| 613 |
|
{ |
| 614 |
476 |
if (val > VALUE_MAX) { |
| 615 |
0 |
while (val > VALUE_MAX) |
| 616 |
0 |
val /= 1000; |
| 617 |
0 |
IC(wprintw(w, " %9ju...", val)); |
| 618 |
0 |
} else |
| 619 |
476 |
IC(wprintw(w, " %12ju", val)); |
| 620 |
476 |
} |
| 621 |
|
|
| 622 |
|
static void |
| 623 |
541 |
draw_line_bytes(WINDOW *w, int y, int x, int X, const struct pt *pt) |
| 624 |
|
{ |
| 625 |
|
enum { |
| 626 |
|
COL_CUR, |
| 627 |
|
COL_CHG, |
| 628 |
|
COL_AVG, |
| 629 |
|
COL_MA10, |
| 630 |
|
COL_MA100, |
| 631 |
|
COL_MA1000, |
| 632 |
|
COL_LAST |
| 633 |
|
} col; |
| 634 |
|
|
| 635 |
541 |
AN(w); |
| 636 |
541 |
AN(pt); |
| 637 |
|
|
| 638 |
541 |
col = COL_CUR; |
| 639 |
2881 |
while (col < COL_LAST) { |
| 640 |
2793 |
if (X - x < COLW) |
| 641 |
453 |
break; |
| 642 |
2340 |
wmove(w, y, x); |
| 643 |
2340 |
switch (col) { |
| 644 |
|
case COL_CUR: |
| 645 |
541 |
if (scale && pt->cur > 1024) |
| 646 |
65 |
print_bytes(w, (double)pt->cur); |
| 647 |
|
else |
| 648 |
476 |
print_trunc(w, (uintmax_t)pt->cur); |
| 649 |
541 |
break; |
| 650 |
|
case COL_CHG: |
| 651 |
541 |
if (pt->t_last) |
| 652 |
289 |
print_bytes(w, pt->chg); |
| 653 |
|
else |
| 654 |
252 |
IC(wprintw(w, " %12s", ". ")); |
| 655 |
541 |
break; |
| 656 |
|
case COL_AVG: |
| 657 |
541 |
if (pt->avg) |
| 658 |
222 |
print_bytes(w, pt->avg); |
| 659 |
|
else |
| 660 |
319 |
IC(wprintw(w, " %12s", ". ")); |
| 661 |
541 |
break; |
| 662 |
|
case COL_MA10: |
| 663 |
541 |
print_bytes(w, pt->ma_10.acc); |
| 664 |
541 |
break; |
| 665 |
|
case COL_MA100: |
| 666 |
88 |
print_bytes(w, pt->ma_100.acc); |
| 667 |
88 |
break; |
| 668 |
|
case COL_MA1000: |
| 669 |
88 |
print_bytes(w, pt->ma_1000.acc); |
| 670 |
88 |
break; |
| 671 |
|
default: |
| 672 |
0 |
break; |
| 673 |
|
} |
| 674 |
2340 |
x += COLW; |
| 675 |
2340 |
col++; |
| 676 |
|
} |
| 677 |
541 |
} |
| 678 |
|
|
| 679 |
|
static void |
| 680 |
69 |
draw_line_bitmap(WINDOW *w, int y, int x, int X, const struct pt *pt) |
| 681 |
|
{ |
| 682 |
|
unsigned ch; |
| 683 |
|
enum { |
| 684 |
|
COL_VAL, |
| 685 |
|
COL_MAP, |
| 686 |
|
COL_LAST |
| 687 |
|
} col; |
| 688 |
|
|
| 689 |
69 |
AN(w); |
| 690 |
69 |
AN(pt); |
| 691 |
69 |
assert(pt->vpt->format == 'b'); |
| 692 |
|
|
| 693 |
69 |
col = COL_VAL; |
| 694 |
207 |
while (col < COL_LAST) { |
| 695 |
138 |
switch (col) { |
| 696 |
|
case COL_VAL: |
| 697 |
69 |
if (X - x < COLW) |
| 698 |
0 |
return; |
| 699 |
69 |
IC(mvwprintw(w, y, x, " %10.10jx", |
| 700 |
|
(uintmax_t)((pt->cur >> 24) & 0xffffffffffLL))); |
| 701 |
69 |
x += COLW; |
| 702 |
69 |
break; |
| 703 |
|
case COL_MAP: |
| 704 |
69 |
if (X - x < 2 * COLW) |
| 705 |
0 |
return; |
| 706 |
69 |
x += (2 * COLW) - 24; |
| 707 |
1725 |
for (ch = 0x800000; ch; ch >>= 1) { |
| 708 |
1656 |
if (pt->cur & ch) |
| 709 |
375 |
mvwaddch(w, y, x, 'V'); |
| 710 |
|
else |
| 711 |
1281 |
mvwaddch(w, y, x, '_'); |
| 712 |
1656 |
x++; |
| 713 |
1656 |
} |
| 714 |
69 |
break; |
| 715 |
|
default: |
| 716 |
0 |
break; |
| 717 |
|
} |
| 718 |
138 |
col++; |
| 719 |
|
} |
| 720 |
69 |
} |
| 721 |
|
|
| 722 |
|
static void |
| 723 |
12 |
draw_line_duration(WINDOW *w, int y, int x, int X, const struct pt *pt) |
| 724 |
|
{ |
| 725 |
|
enum { |
| 726 |
|
COL_DUR, |
| 727 |
|
COL_LAST |
| 728 |
|
} col; |
| 729 |
|
|
| 730 |
12 |
AN(w); |
| 731 |
12 |
AN(pt); |
| 732 |
|
|
| 733 |
12 |
col = COL_DUR; |
| 734 |
24 |
while (col < COL_LAST) { |
| 735 |
12 |
if (X - x < COLW) |
| 736 |
0 |
break; |
| 737 |
12 |
switch (col) { |
| 738 |
|
case COL_DUR: |
| 739 |
12 |
wmove(w, y, x); |
| 740 |
12 |
if (scale) |
| 741 |
4 |
print_duration(w, pt->cur); |
| 742 |
|
else |
| 743 |
8 |
IC(wprintw(w, " %12ju", (uintmax_t)pt->cur)); |
| 744 |
12 |
break; |
| 745 |
|
default: |
| 746 |
0 |
break; |
| 747 |
|
} |
| 748 |
12 |
x += COLW; |
| 749 |
12 |
col++; |
| 750 |
|
} |
| 751 |
12 |
} |
| 752 |
|
|
| 753 |
|
static void |
| 754 |
1980 |
draw_line(WINDOW *w, int y, const struct pt *pt) |
| 755 |
|
{ |
| 756 |
|
int x, X; |
| 757 |
|
|
| 758 |
1980 |
assert(colw_name >= COLW_NAME_MIN); |
| 759 |
1980 |
X = getmaxx(w); |
| 760 |
1980 |
x = 0; |
| 761 |
1980 |
if (vstrlen(pt->vpt->name) > colw_name) |
| 762 |
131 |
IC(mvwprintw(w, y, x, "%.*s...", colw_name - 3, pt->vpt->name)); |
| 763 |
|
else |
| 764 |
1849 |
IC(mvwprintw(w, y, x, "%.*s", colw_name, pt->vpt->name)); |
| 765 |
1980 |
x += colw_name; |
| 766 |
|
|
| 767 |
1980 |
switch (pt->vpt->format) { |
| 768 |
|
case 'b': |
| 769 |
69 |
draw_line_bitmap(w, y, x, X, pt); |
| 770 |
69 |
break; |
| 771 |
|
case 'B': |
| 772 |
541 |
draw_line_bytes(w, y, x, X, pt); |
| 773 |
541 |
break; |
| 774 |
|
case 'd': |
| 775 |
12 |
draw_line_duration(w, y, x, X, pt); |
| 776 |
12 |
break; |
| 777 |
|
default: |
| 778 |
1358 |
draw_line_default(w, y, x, X, pt); |
| 779 |
1358 |
break; |
| 780 |
|
} |
| 781 |
1980 |
} |
| 782 |
|
|
| 783 |
|
static void |
| 784 |
178 |
draw_points(void) |
| 785 |
|
{ |
| 786 |
|
int line; |
| 787 |
|
int n; |
| 788 |
|
|
| 789 |
178 |
AN(w_points); |
| 790 |
|
|
| 791 |
178 |
AC(werase(w_points)); |
| 792 |
178 |
if (n_ptarray == 0) { |
| 793 |
28 |
AC(wnoutrefresh(w_points)); |
| 794 |
28 |
return; |
| 795 |
|
} |
| 796 |
|
|
| 797 |
150 |
assert(current >= 0); |
| 798 |
150 |
assert(current < n_ptarray); |
| 799 |
150 |
assert(page_start >= 0); |
| 800 |
150 |
assert(page_start < n_ptarray); |
| 801 |
150 |
assert(current >= page_start); |
| 802 |
150 |
assert(current - page_start < l_points); |
| 803 |
|
|
| 804 |
2130 |
for (line = 0; line < l_points; line++) { |
| 805 |
2028 |
n = line + page_start; |
| 806 |
2028 |
if (n >= n_ptarray) |
| 807 |
48 |
break; |
| 808 |
1980 |
if (n == current) |
| 809 |
150 |
wattron(w_points, A_BOLD); |
| 810 |
1980 |
draw_line(w_points, line, ptarray[n]); |
| 811 |
1980 |
if (n == current) |
| 812 |
150 |
wattroff(w_points, A_BOLD); |
| 813 |
1980 |
} |
| 814 |
150 |
AC(wnoutrefresh(w_points)); |
| 815 |
178 |
} |
| 816 |
|
|
| 817 |
|
static void |
| 818 |
12 |
draw_help(void) |
| 819 |
|
{ |
| 820 |
|
const char *const *p; |
| 821 |
|
int l, y, X; |
| 822 |
|
|
| 823 |
12 |
if (l_points >= bindings_help_len) { |
| 824 |
0 |
assert(help_line == 0); |
| 825 |
0 |
l = bindings_help_len; |
| 826 |
0 |
} else { |
| 827 |
12 |
assert(help_line >= 0); |
| 828 |
12 |
assert(help_line <= bindings_help_len - l_points); |
| 829 |
12 |
l = l_points; |
| 830 |
|
} |
| 831 |
|
|
| 832 |
12 |
X = getmaxx(w_points); |
| 833 |
12 |
AC(werase(w_points)); |
| 834 |
|
|
| 835 |
204 |
for (y = 0, p = bindings_help + help_line; y < l; y++, p++) { |
| 836 |
192 |
if (**p == '\t') { |
| 837 |
100 |
IC(mvwprintw(w_points, y, 0, " %.*s", X - 4, *p + 1)); |
| 838 |
100 |
} else { |
| 839 |
92 |
wattron(w_points, A_BOLD); |
| 840 |
92 |
IC(mvwprintw(w_points, y, 0, "%.*s", X, *p)); |
| 841 |
92 |
wattroff(w_points, A_BOLD); |
| 842 |
|
} |
| 843 |
192 |
} |
| 844 |
|
|
| 845 |
12 |
AC(wnoutrefresh(w_points)); |
| 846 |
12 |
} |
| 847 |
|
|
| 848 |
|
static void |
| 849 |
178 |
draw_bar_b(void) |
| 850 |
|
{ |
| 851 |
|
int x, X; |
| 852 |
|
char buf[64]; |
| 853 |
|
|
| 854 |
178 |
AN(w_bar_b); |
| 855 |
|
|
| 856 |
178 |
x = 0; |
| 857 |
178 |
X = getmaxx(w_bar_b); |
| 858 |
178 |
AC(werase(w_bar_b)); |
| 859 |
178 |
if (page_start + l_points < n_ptarray) |
| 860 |
89 |
IC(mvwprintw(w_bar_b, 0, x, "vvv")); |
| 861 |
178 |
x += 4; |
| 862 |
178 |
if (current < n_ptarray) |
| 863 |
150 |
IC(mvwprintw(w_bar_b, 0, x, "%s", ptarray[current]->vpt->name)); |
| 864 |
|
|
| 865 |
178 |
bprintf(buf, "%d-%d/%d", page_start + 1, |
| 866 |
|
page_start + l_points < n_ptarray ? |
| 867 |
|
page_start + l_points : n_ptarray, |
| 868 |
|
n_ptarray); |
| 869 |
178 |
IC(mvwprintw(w_bar_b, 0, X - vstrlen(buf), "%s", buf)); |
| 870 |
178 |
X -= vstrlen(buf) + 2; |
| 871 |
|
|
| 872 |
178 |
if (verbosity != NULL) { |
| 873 |
178 |
IC(mvwprintw(w_bar_b, 0, X - vstrlen(verbosity->label), "%s", |
| 874 |
|
verbosity->label)); |
| 875 |
178 |
X -= vstrlen(verbosity->label) + 2; |
| 876 |
178 |
} |
| 877 |
178 |
if (!hide_unseen) { |
| 878 |
48 |
IC(mvwprintw(w_bar_b, 0, X - 6, "%s", "UNSEEN")); |
| 879 |
48 |
X -= 8; |
| 880 |
48 |
} |
| 881 |
178 |
if (raw_vsc) |
| 882 |
0 |
IC(mvwprintw(w_bar_b, 0, X - 3, "%s", "RAW")); |
| 883 |
|
|
| 884 |
178 |
AC(wnoutrefresh(w_bar_b)); |
| 885 |
178 |
} |
| 886 |
|
|
| 887 |
|
static void |
| 888 |
178 |
draw_info(void) |
| 889 |
|
{ |
| 890 |
|
|
| 891 |
178 |
if (w_info == NULL) |
| 892 |
0 |
return; |
| 893 |
|
|
| 894 |
178 |
AC(werase(w_info)); |
| 895 |
178 |
if (current < n_ptarray) { |
| 896 |
|
/* XXX: Word wrapping, and overflow handling? */ |
| 897 |
150 |
IC(mvwprintw(w_info, 0, 0, "%s:", |
| 898 |
|
ptarray[current]->vpt->sdesc)); |
| 899 |
150 |
IC(mvwprintw(w_info, 1, 0, "%s", |
| 900 |
|
ptarray[current]->vpt->ldesc)); |
| 901 |
150 |
} |
| 902 |
178 |
AC(wnoutrefresh(w_info)); |
| 903 |
178 |
} |
| 904 |
|
|
| 905 |
|
static void |
| 906 |
190 |
draw_screen(void) |
| 907 |
|
{ |
| 908 |
190 |
draw_status(); |
| 909 |
190 |
if (show_help) { |
| 910 |
12 |
AC(werase(w_bar_t)); |
| 911 |
12 |
AC(werase(w_bar_b)); |
| 912 |
12 |
AC(werase(w_info)); |
| 913 |
12 |
AC(wnoutrefresh(w_bar_t)); |
| 914 |
12 |
AC(wnoutrefresh(w_bar_b)); |
| 915 |
12 |
AC(wnoutrefresh(w_info)); |
| 916 |
12 |
draw_help(); |
| 917 |
12 |
} else { |
| 918 |
178 |
draw_bar_t(); |
| 919 |
178 |
draw_points(); |
| 920 |
178 |
draw_bar_b(); |
| 921 |
178 |
draw_info(); |
| 922 |
|
} |
| 923 |
190 |
AC(doupdate()); |
| 924 |
190 |
redraw = 0; |
| 925 |
190 |
} |
| 926 |
|
|
| 927 |
|
static void |
| 928 |
8 |
handle_common_keypress(enum kb_e kb) |
| 929 |
|
{ |
| 930 |
|
|
| 931 |
8 |
switch (kb) { |
| 932 |
|
case KB_QUIT: |
| 933 |
8 |
keep_running = 0; |
| 934 |
8 |
return; |
| 935 |
|
case KB_SIG_INT: |
| 936 |
0 |
AZ(raise(SIGINT)); |
| 937 |
0 |
return; |
| 938 |
|
case KB_SIG_TSTP: |
| 939 |
0 |
AZ(raise(SIGTSTP)); |
| 940 |
0 |
return; |
| 941 |
|
default: |
| 942 |
0 |
WRONG("unexpected key binding"); |
| 943 |
0 |
} |
| 944 |
8 |
} |
| 945 |
|
|
| 946 |
|
static void |
| 947 |
72 |
handle_points_keypress(struct vsc *vsc, enum kb_e kb) |
| 948 |
|
{ |
| 949 |
|
|
| 950 |
72 |
switch (kb) { |
| 951 |
|
case KB_HELP: |
| 952 |
8 |
show_help = 1; |
| 953 |
8 |
help_line = 0; |
| 954 |
8 |
redraw = 1; |
| 955 |
8 |
return; |
| 956 |
|
case KB_UP: |
| 957 |
4 |
if (current == 0) |
| 958 |
0 |
return; |
| 959 |
4 |
current--; |
| 960 |
4 |
break; |
| 961 |
|
case KB_DOWN: |
| 962 |
0 |
if (current == n_ptarray - 1) |
| 963 |
0 |
return; |
| 964 |
0 |
current++; |
| 965 |
0 |
break; |
| 966 |
|
case KB_PAGEUP: |
| 967 |
8 |
current -= l_points; |
| 968 |
8 |
page_start -= l_points; |
| 969 |
8 |
break; |
| 970 |
|
case KB_PAGEDOWN: |
| 971 |
8 |
current += l_points; |
| 972 |
8 |
if (page_start + l_points < n_ptarray - 1) |
| 973 |
8 |
page_start += l_points; |
| 974 |
8 |
break; |
| 975 |
|
case KB_TOP: |
| 976 |
4 |
current = 0; |
| 977 |
4 |
break; |
| 978 |
|
case KB_BOTTOM: |
| 979 |
8 |
current = n_ptarray - 1; |
| 980 |
8 |
break; |
| 981 |
|
case KB_UNSEEN: |
| 982 |
4 |
hide_unseen = 1 - hide_unseen; |
| 983 |
4 |
rebuild = REBUILD_NEXT; |
| 984 |
4 |
break; |
| 985 |
|
case KB_RAW: |
| 986 |
0 |
AN(VSC_Arg(vsc, 'r', NULL)); |
| 987 |
0 |
raw_vsc = VSC_IsRaw(vsc); |
| 988 |
0 |
rebuild = REBUILD_NEXT; |
| 989 |
0 |
break; |
| 990 |
|
case KB_SCALE: |
| 991 |
4 |
scale = 1 - scale; |
| 992 |
4 |
rebuild = REBUILD_NEXT; |
| 993 |
4 |
break; |
| 994 |
|
case KB_ACCEL: |
| 995 |
4 |
interval += 0.1; |
| 996 |
4 |
(void)snprintf(notification_message, NOTIF_MAXLEN, |
| 997 |
4 |
"Refresh interval set to %.1f seconds.", interval); |
| 998 |
|
|
| 999 |
4 |
notification_eol = VTIM_mono() + 1.25; |
| 1000 |
4 |
break; |
| 1001 |
|
case KB_DECEL: |
| 1002 |
4 |
interval -= 0.1; |
| 1003 |
4 |
if (interval < 0.1) |
| 1004 |
0 |
interval = 0.1; |
| 1005 |
4 |
(void)snprintf(notification_message, NOTIF_MAXLEN, |
| 1006 |
4 |
"Refresh interval set to %.1f seconds.", interval); |
| 1007 |
|
|
| 1008 |
4 |
notification_eol = VTIM_mono() + 1.25; |
| 1009 |
4 |
break; |
| 1010 |
|
case KB_VERBOSE: |
| 1011 |
4 |
verbosity = VSC_ChangeLevel(verbosity, 1); |
| 1012 |
4 |
rebuild = REBUILD_NEXT; |
| 1013 |
4 |
break; |
| 1014 |
|
case KB_QUIET: |
| 1015 |
0 |
verbosity = VSC_ChangeLevel(verbosity, -1); |
| 1016 |
0 |
rebuild = REBUILD_NEXT; |
| 1017 |
0 |
break; |
| 1018 |
|
case KB_SAMPLE: |
| 1019 |
0 |
sample = 1; |
| 1020 |
0 |
return; |
| 1021 |
|
case KB_RESET_AVERAGES: |
| 1022 |
4 |
reset_averages = 1; |
| 1023 |
4 |
return; |
| 1024 |
|
case KB_QUIT: |
| 1025 |
|
case KB_SIG_INT: |
| 1026 |
|
case KB_SIG_TSTP: |
| 1027 |
8 |
handle_common_keypress(kb); |
| 1028 |
8 |
return; |
| 1029 |
|
default: |
| 1030 |
0 |
WRONG("unhandled key binding"); |
| 1031 |
0 |
} |
| 1032 |
|
|
| 1033 |
52 |
update_position(); |
| 1034 |
52 |
redraw = 1; |
| 1035 |
72 |
} |
| 1036 |
|
|
| 1037 |
|
static void |
| 1038 |
12 |
handle_help_keypress(enum kb_e kb) |
| 1039 |
|
{ |
| 1040 |
12 |
int hl = help_line; |
| 1041 |
|
|
| 1042 |
12 |
switch (kb) { |
| 1043 |
|
case KB_HELP: |
| 1044 |
8 |
show_help = 0; |
| 1045 |
8 |
redraw = 1; |
| 1046 |
8 |
return; |
| 1047 |
|
case KB_UP: |
| 1048 |
0 |
help_line--; |
| 1049 |
0 |
break; |
| 1050 |
|
case KB_DOWN: |
| 1051 |
0 |
help_line++; |
| 1052 |
0 |
break; |
| 1053 |
|
case KB_PAGEUP: |
| 1054 |
0 |
help_line -= l_points; |
| 1055 |
0 |
break; |
| 1056 |
|
case KB_PAGEDOWN: |
| 1057 |
0 |
help_line += l_points; |
| 1058 |
0 |
break; |
| 1059 |
|
case KB_TOP: |
| 1060 |
0 |
help_line = 0; |
| 1061 |
0 |
break; |
| 1062 |
|
case KB_BOTTOM: |
| 1063 |
4 |
help_line = bindings_help_len; |
| 1064 |
4 |
break; |
| 1065 |
|
case KB_UNSEEN: |
| 1066 |
|
case KB_RAW: |
| 1067 |
|
case KB_SCALE: |
| 1068 |
|
case KB_ACCEL: |
| 1069 |
|
case KB_DECEL: |
| 1070 |
|
case KB_VERBOSE: |
| 1071 |
|
case KB_QUIET: |
| 1072 |
|
case KB_SAMPLE: |
| 1073 |
|
case KB_RESET_AVERAGES: |
| 1074 |
0 |
break; |
| 1075 |
|
case KB_QUIT: |
| 1076 |
|
case KB_SIG_INT: |
| 1077 |
|
case KB_SIG_TSTP: |
| 1078 |
0 |
handle_common_keypress(kb); |
| 1079 |
0 |
return; |
| 1080 |
|
default: |
| 1081 |
0 |
WRONG("unhandled key binding"); |
| 1082 |
0 |
} |
| 1083 |
|
|
| 1084 |
4 |
help_line = vlimit_t(int, help_line, 0, bindings_help_len - l_points); |
| 1085 |
4 |
redraw = (help_line != hl); |
| 1086 |
12 |
} |
| 1087 |
|
|
| 1088 |
|
static void |
| 1089 |
84 |
handle_keypress(struct vsc *vsc, int ch) |
| 1090 |
|
{ |
| 1091 |
|
enum kb_e kb; |
| 1092 |
|
|
| 1093 |
84 |
switch (ch) { |
| 1094 |
|
#define BINDING_KEY(chr, name, or) \ |
| 1095 |
|
case chr: |
| 1096 |
|
#define BINDING(name, desc) \ |
| 1097 |
|
kb = KB_ ## name; \ |
| 1098 |
|
break; |
| 1099 |
|
#define BINDING_SIG |
| 1100 |
|
#include "vinylstat_bindings.h" |
| 1101 |
|
default: |
| 1102 |
|
return; |
| 1103 |
|
} |
| 1104 |
|
|
| 1105 |
84 |
if (show_help) |
| 1106 |
12 |
handle_help_keypress(kb); |
| 1107 |
|
else |
| 1108 |
72 |
handle_points_keypress(vsc, kb); |
| 1109 |
84 |
} |
| 1110 |
|
|
| 1111 |
|
static void * v_matchproto_(VSC_new_f) |
| 1112 |
9884 |
newpt(void *priv, const struct VSC_point *const vpt) |
| 1113 |
|
{ |
| 1114 |
|
struct pt *pt; |
| 1115 |
|
|
| 1116 |
9884 |
AZ(priv); |
| 1117 |
9884 |
ALLOC_OBJ(pt, PT_MAGIC); |
| 1118 |
9884 |
rebuild |= REBUILD_NEXT; |
| 1119 |
9884 |
AN(pt); |
| 1120 |
9884 |
pt->vpt = vpt; |
| 1121 |
9884 |
pt->last = VSC_Value(vpt); |
| 1122 |
9884 |
pt->ma_10.nmax = 10; |
| 1123 |
9884 |
pt->ma_100.nmax = 100; |
| 1124 |
9884 |
pt->ma_1000.nmax = 1000; |
| 1125 |
|
|
| 1126 |
9884 |
VTAILQ_INSERT_TAIL(&ptlist, pt, list); |
| 1127 |
9884 |
n_ptlist++; |
| 1128 |
|
|
| 1129 |
9884 |
AZ(vstrcmp(vpt->ctype, "uint64_t")); |
| 1130 |
|
|
| 1131 |
9884 |
if (!vstrcmp(vpt->name, "MGT.uptime")) |
| 1132 |
28 |
mgt_uptime = vpt->ptr; |
| 1133 |
9884 |
if (!vstrcmp(vpt->name, "MAIN.uptime")) |
| 1134 |
28 |
main_uptime = vpt->ptr; |
| 1135 |
9884 |
if (!vstrcmp(vpt->name, "MAIN.cache_hit")) |
| 1136 |
28 |
main_cache_hit = vpt->ptr; |
| 1137 |
9884 |
if (!vstrcmp(vpt->name, "MAIN.cache_miss")) |
| 1138 |
28 |
main_cache_miss = vpt->ptr; |
| 1139 |
9884 |
return (pt); |
| 1140 |
|
} |
| 1141 |
|
|
| 1142 |
|
static void v_matchproto_(VSC_destroy_f) |
| 1143 |
9884 |
delpt(void *priv, const struct VSC_point *const vpt) |
| 1144 |
|
{ |
| 1145 |
|
struct pt *pt; |
| 1146 |
|
|
| 1147 |
9884 |
AZ(priv); |
| 1148 |
9884 |
CAST_OBJ_NOTNULL(pt, vpt->priv, PT_MAGIC); |
| 1149 |
9884 |
rebuild |= REBUILD_NEXT; |
| 1150 |
9884 |
VTAILQ_REMOVE(&ptlist, pt, list); |
| 1151 |
9884 |
n_ptlist--; |
| 1152 |
9884 |
FREE_OBJ(pt); |
| 1153 |
9884 |
if (vpt->ptr == mgt_uptime) |
| 1154 |
28 |
mgt_uptime = NULL; |
| 1155 |
9884 |
if (vpt->ptr == main_uptime) |
| 1156 |
28 |
main_uptime = NULL; |
| 1157 |
9884 |
if (vpt->ptr == main_cache_hit) |
| 1158 |
28 |
main_cache_hit = NULL; |
| 1159 |
9884 |
if (vpt->ptr == main_cache_miss) |
| 1160 |
28 |
main_cache_miss = NULL; |
| 1161 |
9884 |
} |
| 1162 |
|
|
| 1163 |
|
void |
| 1164 |
28 |
do_curses(struct vsm *vsm, struct vsc *vsc) |
| 1165 |
|
{ |
| 1166 |
|
long t; |
| 1167 |
|
int ch; |
| 1168 |
|
double now; |
| 1169 |
|
|
| 1170 |
28 |
verbosity = VSC_ChangeLevel(NULL, 0); |
| 1171 |
|
|
| 1172 |
28 |
(void)initscr(); |
| 1173 |
28 |
AC(raw()); |
| 1174 |
28 |
AC(noecho()); |
| 1175 |
28 |
AC(nonl()); |
| 1176 |
28 |
IC(curs_set(0)); |
| 1177 |
|
|
| 1178 |
28 |
make_windows(); |
| 1179 |
28 |
AC(doupdate()); |
| 1180 |
|
|
| 1181 |
28 |
VSC_State(vsc, newpt, delpt, NULL); |
| 1182 |
|
|
| 1183 |
28 |
raw_vsc = VSC_IsRaw(vsc); |
| 1184 |
28 |
rebuild |= REBUILD_FIRST; |
| 1185 |
28 |
(void)VSC_Iter(vsc, vsm, NULL, NULL); |
| 1186 |
28 |
build_pt_array(); |
| 1187 |
28 |
init_hitrate(); |
| 1188 |
|
|
| 1189 |
222 |
while (keep_running && !VSIG_int && !VSIG_term && !VSIG_hup) { |
| 1190 |
194 |
(void)VSC_Iter(vsc, vsm, NULL, NULL); |
| 1191 |
194 |
vsm_status = VSM_Status(vsm); |
| 1192 |
194 |
if (vsm_status & (VSM_MGT_RESTARTED|VSM_WRK_RESTARTED)) |
| 1193 |
0 |
init_hitrate(); |
| 1194 |
194 |
if (rebuild) |
| 1195 |
79 |
build_pt_array(); |
| 1196 |
|
|
| 1197 |
194 |
now = VTIM_mono(); |
| 1198 |
194 |
if (now - t_sample > interval) |
| 1199 |
114 |
sample = 1; |
| 1200 |
194 |
if (sample) |
| 1201 |
114 |
sample_data(); |
| 1202 |
194 |
if (redraw) |
| 1203 |
190 |
draw_screen(); |
| 1204 |
|
|
| 1205 |
194 |
t = (long)((t_sample + interval - now) * 1000); |
| 1206 |
194 |
wtimeout(w_status, t); |
| 1207 |
|
|
| 1208 |
194 |
ch = wgetch(w_status); |
| 1209 |
194 |
switch (ch) { |
| 1210 |
|
case ERR: |
| 1211 |
106 |
break; |
| 1212 |
|
#ifdef KEY_RESIZE /* sigh, Solaris lacks this.. */ |
| 1213 |
|
case KEY_RESIZE: |
| 1214 |
4 |
make_windows(); |
| 1215 |
4 |
update_position(); |
| 1216 |
4 |
break; |
| 1217 |
|
#endif |
| 1218 |
|
default: |
| 1219 |
84 |
handle_keypress(vsc, ch); |
| 1220 |
84 |
break; |
| 1221 |
|
} |
| 1222 |
|
} |
| 1223 |
28 |
VSC_Destroy(&vsc, vsm); |
| 1224 |
28 |
AN(VTAILQ_EMPTY(&ptlist)); |
| 1225 |
28 |
VSM_Destroy(&vsm); |
| 1226 |
28 |
AZ(endwin()); |
| 1227 |
28 |
} |