diff options
Diffstat (limited to 'src/overlays.c')
| -rw-r--r-- | src/overlays.c | 798 |
1 files changed, 399 insertions, 399 deletions
diff --git a/src/overlays.c b/src/overlays.c index 3edda0b..01d9fe1 100644 --- a/src/overlays.c +++ b/src/overlays.c @@ -34,20 +34,20 @@ #include "vwm.h" #include "xwindow.h" -#define OVERLAY_MASK_DEPTH 8 /* XXX: 1 would save memory, but Xorg isn't good at it */ -#define OVERLAY_FIXED_FONT "-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1" -#define OVERLAY_ROW_HEIGHT 15 /* this should always be larger than the font height */ -#define OVERLAY_GRAPH_MIN_WIDTH 200 /* always create graphs at least this large */ -#define OVERLAY_GRAPH_MIN_HEIGHT (4 * OVERLAY_ROW_HEIGHT) -#define OVERLAY_ISTHREAD_ARGV "~" /* use this string to mark threads in the argv field */ -#define OVERLAY_NOCOMM_ARGV "#missed it!" /* use this string to substitute the command when missing in argv field */ -#define OVERLAY_MAX_ARGC 512 /* this is a huge amount */ -#define OVERLAY_VMON_PROC_WANTS (VMON_WANT_PROC_STAT | VMON_WANT_PROC_FOLLOW_CHILDREN | VMON_WANT_PROC_FOLLOW_THREADS) -#define OVERLAY_VMON_SYS_WANTS (VMON_WANT_SYS_STAT) - -/* the global overlays state, supplied to vwm_overlay_create() which keeps a reference for future use. */ -typedef struct _vwm_overlays_t { - vwm_xserver_t *xserver; /* xserver supplied to vwm_overlays_init() */ +#define CHART_MASK_DEPTH 8 /* XXX: 1 would save memory, but Xorg isn't good at it */ +#define CHART_FIXED_FONT "-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1" +#define CHART_ROW_HEIGHT 15 /* this should always be larger than the font height */ +#define CHART_GRAPH_MIN_WIDTH 200 /* always create graphs at least this large */ +#define CHART_GRAPH_MIN_HEIGHT (4 * CHART_ROW_HEIGHT) +#define CHART_ISTHREAD_ARGV "~" /* use this string to mark threads in the argv field */ +#define CHART_NOCOMM_ARGV "#missed it!" /* use this string to substitute the command when missing in argv field */ +#define CHART_MAX_ARGC 512 /* this is a huge amount */ +#define CHART_VMON_PROC_WANTS (VMON_WANT_PROC_STAT | VMON_WANT_PROC_FOLLOW_CHILDREN | VMON_WANT_PROC_FOLLOW_THREADS) +#define CHART_VMON_SYS_WANTS (VMON_WANT_SYS_STAT) + +/* the global charts state, supplied to vwm_chart_create() which keeps a reference for future use. */ +typedef struct _vwm_charts_t { + vwm_xserver_t *xserver; /* xserver supplied to vwm_charts_init() */ /* libvmon */ struct timeval maybe_sample, last_sample, this_sample; @@ -60,7 +60,7 @@ typedef struct _vwm_overlays_t { int sampling_paused, contiguous_drops; /* X */ - XFontStruct *overlay_font; + XFontStruct *chart_font; GC text_gc; Picture shadow_fill, text_fill, @@ -69,28 +69,28 @@ typedef struct _vwm_overlays_t { grapha_fill, graphb_fill, finish_fill; -} vwm_overlays_t; +} vwm_charts_t; -/* everything needed by the per-window overlay's context */ -typedef struct _vwm_overlay_t { +/* everything needed by the per-window chart's context */ +typedef struct _vwm_chart_t { vmon_proc_t *monitor; /* vmon process monitor handle */ - Pixmap text_pixmap; /* pixmap for overlayed text (kept around for XDrawText usage) */ + Pixmap text_pixmap; /* pixmap for charted text (kept around for XDrawText usage) */ Picture text_picture; /* picture representation of text_pixmap */ Picture shadow_picture; /* text shadow layer */ Picture grapha_picture; /* graph A layer */ Picture graphb_picture; /* graph B layer */ Picture tmp_picture; /* 1 row worth of temporary picture space */ - Picture picture; /* overlay picture derived from the pixmap, for render compositing */ - int width; /* current width of the overlay */ - int height; /* current height of the overlay */ - int visible_width; /* currently visible width of the overlay */ - int visible_height; /* currently visible height of the overlay */ + Picture picture; /* chart picture derived from the pixmap, for render compositing */ + int width; /* current width of the chart */ + int height; /* current height of the chart */ + int visible_width; /* currently visible width of the chart */ + int visible_height; /* currently visible height of the chart */ int phase; /* current position within the (horizontally scrolling) graphs */ int heirarchy_end; /* row where the process heirarchy currently ends */ int snowflakes_cnt; /* count of snowflaked rows (reset to zero to truncate snowflakes display) */ int gen_last_composed; /* the last composed vmon generation */ int redraw_needed; /* if a redraw is required (like when the window is resized...) */ -} vwm_overlay_t; +} vwm_chart_t; /* space we need for every process being monitored */ typedef struct _vwm_perproc_ctxt_t { @@ -110,14 +110,14 @@ static float sampling_intervals[] = { .025, /* ~40Hz */ .01666}; /* ~60Hz */ -static XRenderColor overlay_visible_color = { 0xffff, 0xffff, 0xffff, 0xffff }, - overlay_shadow_color = { 0x0000, 0x0000, 0x0000, 0x8800}, - overlay_bg_color = { 0x0, 0x1000, 0x0, 0x9000}, - overlay_div_color = { 0x2000, 0x3000, 0x2000, 0x9000}, - overlay_snowflakes_visible_color = { 0xd000, 0xd000, 0xd000, 0x8000 }, - overlay_trans_color = {0x00, 0x00, 0x00, 0x00}, - overlay_grapha_color = { 0xff00, 0x0000, 0x0000, 0x3000 }, /* ~red */ - overlay_graphb_color = { 0x0000, 0xffff, 0xffff, 0x3000 }; /* ~cyan */ +static XRenderColor chart_visible_color = { 0xffff, 0xffff, 0xffff, 0xffff }, + chart_shadow_color = { 0x0000, 0x0000, 0x0000, 0x8800}, + chart_bg_color = { 0x0, 0x1000, 0x0, 0x9000}, + chart_div_color = { 0x2000, 0x3000, 0x2000, 0x9000}, + chart_snowflakes_visible_color = { 0xd000, 0xd000, 0xd000, 0x8000 }, + chart_trans_color = {0x00, 0x00, 0x00, 0x00}, + chart_grapha_color = { 0xff00, 0x0000, 0x0000, 0x3000 }, /* ~red */ + chart_graphb_color = { 0x0000, 0xffff, 0xffff, 0x3000 }; /* ~cyan */ static XRenderPictureAttributes pa_repeat = { .repeat = 1 }; static XRenderPictureAttributes pa_no_repeat = { .repeat = 0 }; @@ -125,16 +125,16 @@ static XRenderPictureAttributes pa_no_repeat = { .repeat = 0 }; /* this callback gets invoked at sample time once "per sys" */ static void sample_callback(vmon_t *vmon, void *arg) { - vwm_overlays_t *overlays = arg; + vwm_charts_t *charts = arg; vmon_sys_stat_t *sys_stat = vmon->stores[VMON_STORE_SYS_STAT]; - overlays->this_total = sys_stat->user + sys_stat->nice + sys_stat->system + + charts->this_total = sys_stat->user + sys_stat->nice + sys_stat->system + sys_stat->idle + sys_stat->iowait + sys_stat->irq + sys_stat->softirq + sys_stat->steal + sys_stat->guest; - overlays->total_delta = overlays->this_total - overlays->last_total; - overlays->idle_delta = sys_stat->idle - overlays->last_idle; - overlays->iowait_delta = sys_stat->iowait - overlays->last_iowait; + charts->total_delta = charts->this_total - charts->last_total; + charts->idle_delta = sys_stat->idle - charts->last_idle; + charts->iowait_delta = sys_stat->iowait - charts->last_iowait; } @@ -157,18 +157,18 @@ static void vmon_dtor_cb(vmon_t *vmon, vmon_proc_t *proc) /* convenience helper for creating a pixmap */ -static Pixmap create_pixmap(vwm_overlays_t *overlays, unsigned width, unsigned height, unsigned depth) +static Pixmap create_pixmap(vwm_charts_t *charts, unsigned width, unsigned height, unsigned depth) { - vwm_xserver_t *xserver = overlays->xserver; + vwm_xserver_t *xserver = charts->xserver; return XCreatePixmap(xserver->display, XSERVER_XROOT(xserver), width, height, depth); } /* convenience helper for creating a picture, supply res_pixmap to keep a reference to the pixmap drawable. */ -static Picture create_picture(vwm_overlays_t *overlays, unsigned width, unsigned height, unsigned depth, unsigned long attr_mask, XRenderPictureAttributes *attr, Pixmap *res_pixmap) +static Picture create_picture(vwm_charts_t *charts, unsigned width, unsigned height, unsigned depth, unsigned long attr_mask, XRenderPictureAttributes *attr, Pixmap *res_pixmap) { - vwm_xserver_t *xserver = overlays->xserver; + vwm_xserver_t *xserver = charts->xserver; Pixmap pixmap; Picture picture; int format; @@ -185,7 +185,7 @@ static Picture create_picture(vwm_overlays_t *overlays, unsigned width, unsigned assert(0); } - pixmap = create_pixmap(overlays, width, height, depth); + pixmap = create_pixmap(charts, width, height, depth); picture = XRenderCreatePicture(xserver->display, pixmap, XRenderFindStandardFormat(xserver->display, format), attr_mask, attr); if (res_pixmap) { @@ -199,143 +199,143 @@ static Picture create_picture(vwm_overlays_t *overlays, unsigned width, unsigned /* convenience helper for creating a filled picture, supply res_pixmap to keep a reference to the pixmap drawable. */ -static Picture create_picture_fill(vwm_overlays_t *overlays, unsigned width, unsigned height, unsigned depth, unsigned long attrs_mask, XRenderPictureAttributes *attrs, XRenderColor *color, Pixmap *res_pixmap) +static Picture create_picture_fill(vwm_charts_t *charts, unsigned width, unsigned height, unsigned depth, unsigned long attrs_mask, XRenderPictureAttributes *attrs, XRenderColor *color, Pixmap *res_pixmap) { - vwm_xserver_t *xserver = overlays->xserver; + vwm_xserver_t *xserver = charts->xserver; Picture picture; - picture = create_picture(overlays, width, height, depth, attrs_mask, attrs, res_pixmap); + picture = create_picture(charts, width, height, depth, attrs_mask, attrs, res_pixmap); XRenderFillRectangle(xserver->display, PictOpSrc, picture, color, 0, 0, width, height); return picture; } -/* initialize overlays system */ -vwm_overlays_t * vwm_overlays_create(vwm_xserver_t *xserver) +/* initialize charts system */ +vwm_charts_t * vwm_charts_create(vwm_xserver_t *xserver) { - vwm_overlays_t *overlays; + vwm_charts_t *charts; Pixmap bitmask; - overlays = calloc(1, sizeof(vwm_overlays_t)); - if (!overlays) { - VWM_PERROR("unable to allocate vwm_overlays_t"); + charts = calloc(1, sizeof(vwm_charts_t)); + if (!charts) { + VWM_PERROR("unable to allocate vwm_charts_t"); goto _err; } - overlays->xserver = xserver; - overlays->prev_sampling_interval = overlays->sampling_interval = 0.1f; /* default to 10Hz */ + charts->xserver = xserver; + charts->prev_sampling_interval = charts->sampling_interval = 0.1f; /* default to 10Hz */ - if (!vmon_init(&overlays->vmon, VMON_FLAG_2PASS, OVERLAY_VMON_SYS_WANTS, OVERLAY_VMON_PROC_WANTS)) { + if (!vmon_init(&charts->vmon, VMON_FLAG_2PASS, CHART_VMON_SYS_WANTS, CHART_VMON_PROC_WANTS)) { VWM_ERROR("unable to initialize libvmon"); - goto _err_overlays; + goto _err_charts; } - overlays->vmon.proc_ctor_cb = vmon_ctor_cb; - overlays->vmon.proc_dtor_cb = vmon_dtor_cb; - overlays->vmon.sample_cb = sample_callback; - overlays->vmon.sample_cb_arg = overlays; - gettimeofday(&overlays->this_sample, NULL); + charts->vmon.proc_ctor_cb = vmon_ctor_cb; + charts->vmon.proc_dtor_cb = vmon_dtor_cb; + charts->vmon.sample_cb = sample_callback; + charts->vmon.sample_cb_arg = charts; + gettimeofday(&charts->this_sample, NULL); - /* get all the text and graphics stuff setup for overlays */ - overlays->overlay_font = XLoadQueryFont(xserver->display, OVERLAY_FIXED_FONT); - if (!overlays->overlay_font) { - VWM_ERROR("unable to load overlay font \"%s\"", OVERLAY_FIXED_FONT); + /* get all the text and graphics stuff setup for charts */ + charts->chart_font = XLoadQueryFont(xserver->display, CHART_FIXED_FONT); + if (!charts->chart_font) { + VWM_ERROR("unable to load chart font \"%s\"", CHART_FIXED_FONT); goto _err_vmon; } - /* create a GC for rendering the text using Xlib into the text overlay stencils */ - bitmask = create_pixmap(overlays, 1, 1, OVERLAY_MASK_DEPTH); - overlays->text_gc = XCreateGC(xserver->display, bitmask, 0, NULL); - XSetForeground(xserver->display, overlays->text_gc, WhitePixel(xserver->display, xserver->screen_num)); + /* create a GC for rendering the text using Xlib into the text chart stencils */ + bitmask = create_pixmap(charts, 1, 1, CHART_MASK_DEPTH); + charts->text_gc = XCreateGC(xserver->display, bitmask, 0, NULL); + XSetForeground(xserver->display, charts->text_gc, WhitePixel(xserver->display, xserver->screen_num)); XFreePixmap(xserver->display, bitmask); /* create some repeating source fill pictures for drawing through the text and graph stencils */ - overlays->text_fill = create_picture_fill(overlays, 1, 1, 32, CPRepeat, &pa_repeat, &overlay_visible_color, NULL); - overlays->shadow_fill = create_picture_fill(overlays, 1, 1, 32, CPRepeat, &pa_repeat, &overlay_shadow_color, NULL); + charts->text_fill = create_picture_fill(charts, 1, 1, 32, CPRepeat, &pa_repeat, &chart_visible_color, NULL); + charts->shadow_fill = create_picture_fill(charts, 1, 1, 32, CPRepeat, &pa_repeat, &chart_shadow_color, NULL); - overlays->bg_fill = create_picture(overlays, 1, OVERLAY_ROW_HEIGHT, 32, CPRepeat, &pa_repeat, NULL); - XRenderFillRectangle(xserver->display, PictOpSrc, overlays->bg_fill, &overlay_bg_color, 0, 0, 1, OVERLAY_ROW_HEIGHT); - XRenderFillRectangle(xserver->display, PictOpSrc, overlays->bg_fill, &overlay_div_color, 0, OVERLAY_ROW_HEIGHT - 1, 1, 1); + charts->bg_fill = create_picture(charts, 1, CHART_ROW_HEIGHT, 32, CPRepeat, &pa_repeat, NULL); + XRenderFillRectangle(xserver->display, PictOpSrc, charts->bg_fill, &chart_bg_color, 0, 0, 1, CHART_ROW_HEIGHT); + XRenderFillRectangle(xserver->display, PictOpSrc, charts->bg_fill, &chart_div_color, 0, CHART_ROW_HEIGHT - 1, 1, 1); - overlays->snowflakes_text_fill = create_picture_fill(overlays, 1, 1, 32, CPRepeat, &pa_repeat, &overlay_snowflakes_visible_color, NULL); - overlays->grapha_fill = create_picture_fill(overlays, 1, 1, 32, CPRepeat, &pa_repeat, &overlay_grapha_color, NULL); - overlays->graphb_fill = create_picture_fill(overlays, 1, 1, 32, CPRepeat, &pa_repeat, &overlay_graphb_color, NULL); + charts->snowflakes_text_fill = create_picture_fill(charts, 1, 1, 32, CPRepeat, &pa_repeat, &chart_snowflakes_visible_color, NULL); + charts->grapha_fill = create_picture_fill(charts, 1, 1, 32, CPRepeat, &pa_repeat, &chart_grapha_color, NULL); + charts->graphb_fill = create_picture_fill(charts, 1, 1, 32, CPRepeat, &pa_repeat, &chart_graphb_color, NULL); - overlays->finish_fill = create_picture(overlays, 1, 2, 32, CPRepeat, &pa_repeat, NULL); - XRenderFillRectangle(xserver->display, PictOpSrc, overlays->finish_fill, &overlay_visible_color, 0, 0, 1, 1); - XRenderFillRectangle(xserver->display, PictOpSrc, overlays->finish_fill, &overlay_trans_color, 0, 1, 1, 1); + charts->finish_fill = create_picture(charts, 1, 2, 32, CPRepeat, &pa_repeat, NULL); + XRenderFillRectangle(xserver->display, PictOpSrc, charts->finish_fill, &chart_visible_color, 0, 0, 1, 1); + XRenderFillRectangle(xserver->display, PictOpSrc, charts->finish_fill, &chart_trans_color, 0, 1, 1, 1); - return overlays; + return charts; _err_vmon: - vmon_destroy(&overlays->vmon); + vmon_destroy(&charts->vmon); -_err_overlays: - free(overlays); +_err_charts: + free(charts); _err: return NULL; } -/* teardown overlays system */ -void vwm_overlays_destroy(vwm_overlays_t *overlays) +/* teardown charts system */ +void vwm_charts_destroy(vwm_charts_t *charts) { /* TODO: free rest of stuff.. */ - free(overlays); + free(charts); } /* copies a row from src to dest */ -static void copy_row(vwm_overlays_t *overlays, vwm_overlay_t *overlay, int src_row, Picture src, int dest_row, Picture dest) +static void copy_row(vwm_charts_t *charts, vwm_chart_t *chart, int src_row, Picture src, int dest_row, Picture dest) { - XRenderComposite(overlays->xserver->display, PictOpSrc, src, None, dest, - 0, src_row * OVERLAY_ROW_HEIGHT, /* src */ + XRenderComposite(charts->xserver->display, PictOpSrc, src, None, dest, + 0, src_row * CHART_ROW_HEIGHT, /* src */ 0, 0, /* mask */ - 0, dest_row * OVERLAY_ROW_HEIGHT, /* dest */ - overlay->width, OVERLAY_ROW_HEIGHT); /* dimensions */ + 0, dest_row * CHART_ROW_HEIGHT, /* dest */ + chart->width, CHART_ROW_HEIGHT); /* dimensions */ } /* fills a row with the specified color */ -static void fill_row(vwm_overlays_t *overlays, vwm_overlay_t *overlay, int row, Picture pic, XRenderColor *color) +static void fill_row(vwm_charts_t *charts, vwm_chart_t *chart, int row, Picture pic, XRenderColor *color) { - XRenderFillRectangle(overlays->xserver->display, PictOpSrc, pic, color, - 0, row * OVERLAY_ROW_HEIGHT, /* dest */ - overlay->width, OVERLAY_ROW_HEIGHT); /* dimensions */ + XRenderFillRectangle(charts->xserver->display, PictOpSrc, pic, color, + 0, row * CHART_ROW_HEIGHT, /* dest */ + chart->width, CHART_ROW_HEIGHT); /* dimensions */ } /* copy what's below a given row up the specified amount within the same picture */ -static void shift_below_row_up(vwm_overlays_t *overlays, vwm_overlay_t *overlay, int row, Picture pic, int rows) +static void shift_below_row_up(vwm_charts_t *charts, vwm_chart_t *chart, int row, Picture pic, int rows) { - vwm_xserver_t *xserver = overlays->xserver; + vwm_xserver_t *xserver = charts->xserver; XRenderChangePicture(xserver->display, pic, CPRepeat, &pa_no_repeat); XRenderComposite(xserver->display, PictOpSrc, pic, None, pic, - 0, (rows + row) * OVERLAY_ROW_HEIGHT, /* src */ - 0, 0, /* mask */ - 0, row * OVERLAY_ROW_HEIGHT, /* dest */ - overlay->width, (rows + overlay->heirarchy_end) * OVERLAY_ROW_HEIGHT - (rows + row) * OVERLAY_ROW_HEIGHT); /* dimensions */ + 0, (rows + row) * CHART_ROW_HEIGHT, /* src */ + 0, 0, /* mask */ + 0, row * CHART_ROW_HEIGHT, /* dest */ + chart->width, (rows + chart->heirarchy_end) * CHART_ROW_HEIGHT - (rows + row) * CHART_ROW_HEIGHT); /* dimensions */ XRenderChangePicture(xserver->display, pic, CPRepeat, &pa_repeat); } /* moves what's below a given row up above it if specified, the row becoming discarded */ -static void snowflake_row(vwm_overlays_t *overlays, vwm_overlay_t *overlay, Picture pic, int copy, int row) +static void snowflake_row(vwm_charts_t *charts, vwm_chart_t *chart, Picture pic, int copy, int row) { - VWM_TRACE("pid=%i overlay=%p row=%i copy=%i heirarhcy_end=%i", overlay->monitor->pid, overlay, row, copy, overlay->heirarchy_end); + VWM_TRACE("pid=%i chart=%p row=%i copy=%i heirarhcy_end=%i", chart->monitor->pid, chart, row, copy, chart->heirarchy_end); if (copy) - copy_row(overlays, overlay, row, pic, 0, overlay->tmp_picture); + copy_row(charts, chart, row, pic, 0, chart->tmp_picture); - shift_below_row_up(overlays, overlay, row, pic, 1); + shift_below_row_up(charts, chart, row, pic, 1); if (copy) { - copy_row(overlays, overlay, 0, overlay->tmp_picture, overlay->heirarchy_end, pic); + copy_row(charts, chart, 0, chart->tmp_picture, chart->heirarchy_end, pic); } else { - fill_row(overlays, overlay, overlay->heirarchy_end, pic, &overlay_trans_color); + fill_row(charts, chart, chart->heirarchy_end, pic, &chart_trans_color); } } @@ -344,55 +344,55 @@ static void snowflake_row(vwm_overlays_t *overlays, vwm_overlay_t *overlay, Pict */ -static void shift_below_row_down(vwm_overlays_t *overlays, vwm_overlay_t *overlay, int row, Picture pic, int rows) +static void shift_below_row_down(vwm_charts_t *charts, vwm_chart_t *chart, int row, Picture pic, int rows) { - XRenderComposite(overlays->xserver->display, PictOpSrc, pic, None, pic, - 0, row * OVERLAY_ROW_HEIGHT, /* src */ - 0, 0, /* mask */ - 0, (row + rows) * OVERLAY_ROW_HEIGHT, /* dest */ - overlay->width, overlay->height - (rows + row) * OVERLAY_ROW_HEIGHT); /* dimensions */ + XRenderComposite(charts->xserver->display, PictOpSrc, pic, None, pic, + 0, row * CHART_ROW_HEIGHT, /* src */ + 0, 0, /* mask */ + 0, (row + rows) * CHART_ROW_HEIGHT, /* dest */ + chart->width, chart->height - (rows + row) * CHART_ROW_HEIGHT); /* dimensions */ } /* shifts what's below a given row down a row, and clears the row, preparing it for populating */ -static void allocate_row(vwm_overlays_t *overlays, vwm_overlay_t *overlay, Picture pic, int row) +static void allocate_row(vwm_charts_t *charts, vwm_chart_t *chart, Picture pic, int row) { - VWM_TRACE("pid=%i overlay=%p row=%i", overlay->monitor->pid, overlay, row); + VWM_TRACE("pid=%i chart=%p row=%i", chart->monitor->pid, chart, row); - shift_below_row_down(overlays, overlay, row, pic, 1); - fill_row(overlays, overlay, row, pic, &overlay_trans_color); + shift_below_row_down(charts, chart, row, pic, 1); + fill_row(charts, chart, row, pic, &chart_trans_color); } /* shadow a row from the text layer in the shadow layer */ -static void shadow_row(vwm_overlays_t *overlays, vwm_overlay_t *overlay, int row) +static void shadow_row(vwm_charts_t *charts, vwm_chart_t *chart, int row) { - vwm_xserver_t *xserver = overlays->xserver; + vwm_xserver_t *xserver = charts->xserver; /* the current technique for creating the shadow is to simply render the text at +1/-1 pixel offsets on both axis in translucent black */ - XRenderComposite(xserver->display, PictOpSrc, overlays->shadow_fill, overlay->text_picture, overlay->shadow_picture, + XRenderComposite(xserver->display, PictOpSrc, charts->shadow_fill, chart->text_picture, chart->shadow_picture, 0, 0, - -1, row * OVERLAY_ROW_HEIGHT, - 0, row * OVERLAY_ROW_HEIGHT, - overlay->visible_width, OVERLAY_ROW_HEIGHT); + -1, row * CHART_ROW_HEIGHT, + 0, row * CHART_ROW_HEIGHT, + chart->visible_width, CHART_ROW_HEIGHT); - XRenderComposite(xserver->display, PictOpOver, overlays->shadow_fill, overlay->text_picture, overlay->shadow_picture, + XRenderComposite(xserver->display, PictOpOver, charts->shadow_fill, chart->text_picture, chart->shadow_picture, 0, 0, - 0, -1 + row * OVERLAY_ROW_HEIGHT, - 0, row * OVERLAY_ROW_HEIGHT, - overlay->visible_width, OVERLAY_ROW_HEIGHT); + 0, -1 + row * CHART_ROW_HEIGHT, + 0, row * CHART_ROW_HEIGHT, + chart->visible_width, CHART_ROW_HEIGHT); - XRenderComposite(xserver->display, PictOpOver, overlays->shadow_fill, overlay->text_picture, overlay->shadow_picture, + XRenderComposite(xserver->display, PictOpOver, charts->shadow_fill, chart->text_picture, chart->shadow_picture, 0, 0, - 1, row * OVERLAY_ROW_HEIGHT, - 0, row * OVERLAY_ROW_HEIGHT, - overlay->visible_width, OVERLAY_ROW_HEIGHT); + 1, row * CHART_ROW_HEIGHT, + 0, row * CHART_ROW_HEIGHT, + chart->visible_width, CHART_ROW_HEIGHT); - XRenderComposite(xserver->display, PictOpOver, overlays->shadow_fill, overlay->text_picture, overlay->shadow_picture, + XRenderComposite(xserver->display, PictOpOver, charts->shadow_fill, chart->text_picture, chart->shadow_picture, 0, 0, - 0, 1 + row * OVERLAY_ROW_HEIGHT, - 0, row * OVERLAY_ROW_HEIGHT, - overlay->visible_width, OVERLAY_ROW_HEIGHT); + 0, 1 + row * CHART_ROW_HEIGHT, + 0, row * CHART_ROW_HEIGHT, + chart->visible_width, CHART_ROW_HEIGHT); } @@ -403,8 +403,8 @@ static void argv2xtext(vmon_proc_t *proc, XTextItem *items, int max_items, int * int nr = 0; if (proc->is_thread) { /* stick the thread marker at the start of threads */ - items[0].nchars = sizeof(OVERLAY_ISTHREAD_ARGV) - 1; - items[0].chars = OVERLAY_ISTHREAD_ARGV; + items[0].nchars = sizeof(CHART_ISTHREAD_ARGV) - 1; + items[0].chars = CHART_ISTHREAD_ARGV; items[0].delta = 4; items[0].font = None; nr++; @@ -415,8 +415,8 @@ static void argv2xtext(vmon_proc_t *proc, XTextItem *items, int max_items, int * items[nr].chars = ((vmon_proc_stat_t *)proc->stores[VMON_STORE_PROC_STAT])->comm.array; } else { /* sometimes a process is so ephemeral we don't manage to sample its comm, XXX TODO: we always have a pid, stringify it? */ - items[nr].nchars = sizeof(OVERLAY_NOCOMM_ARGV) - 1; - items[nr].chars = OVERLAY_NOCOMM_ARGV; + items[nr].nchars = sizeof(CHART_NOCOMM_ARGV) - 1; + items[nr].chars = CHART_NOCOMM_ARGV; } items[nr].delta = 4; items[nr].font = None; @@ -476,14 +476,14 @@ static int proc_heirarchy_changed(vmon_proc_t *proc) /* helper for drawing the vertical bars in the graph layers */ -static void draw_bars(vwm_overlays_t *overlays, vwm_overlay_t *overlay, int row, double a_fraction, double a_total, double b_fraction, double b_total) +static void draw_bars(vwm_charts_t *charts, vwm_chart_t *chart, int row, double a_fraction, double a_total, double b_fraction, double b_total) { - vwm_xserver_t *xserver = overlays->xserver; + vwm_xserver_t *xserver = charts->xserver; int a_height, b_height; /* compute the bar heights for this sample */ - a_height = (a_fraction / a_total * (double)(OVERLAY_ROW_HEIGHT - 1)); /* give up 1 pixel for the div */ - b_height = (b_fraction / b_total * (double)(OVERLAY_ROW_HEIGHT - 1)); + a_height = (a_fraction / a_total * (double)(CHART_ROW_HEIGHT - 1)); /* give up 1 pixel for the div */ + b_height = (b_fraction / b_total * (double)(CHART_ROW_HEIGHT - 1)); /* round up to 1 pixel when the scaled result is a fraction less than 1, * I want to at least see 1 pixel blips for the slightest cpu utilization */ @@ -494,51 +494,51 @@ static void draw_bars(vwm_overlays_t *overlays, vwm_overlay_t *overlay, int row, b_height = 1; /* draw the two bars for this sample at the current phase in the graphs, note the first is ceiling-based, second floor-based */ - XRenderFillRectangle(xserver->display, PictOpSrc, overlay->grapha_picture, &overlay_visible_color, - overlay->phase, row * OVERLAY_ROW_HEIGHT, /* dst x, y */ - 1, a_height); /* dst w, h */ - XRenderFillRectangle(xserver->display, PictOpSrc, overlay->graphb_picture, &overlay_visible_color, - overlay->phase, row * OVERLAY_ROW_HEIGHT + (OVERLAY_ROW_HEIGHT - b_height) - 1, /* dst x, y */ + XRenderFillRectangle(xserver->display, PictOpSrc, chart->grapha_picture, &chart_visible_color, + chart->phase, row * CHART_ROW_HEIGHT, /* dst x, y */ + 1, a_height); /* dst w, h */ + XRenderFillRectangle(xserver->display, PictOpSrc, chart->graphb_picture, &chart_visible_color, + chart->phase, row * CHART_ROW_HEIGHT + (CHART_ROW_HEIGHT - b_height) - 1, /* dst x, y */ 1, b_height); /* dst w, h */ } /* helper for marking a finish line at the current phase for the specified row */ -static void mark_finish(vwm_overlays_t *overlays, vwm_overlay_t *overlay, int row) +static void mark_finish(vwm_charts_t *charts, vwm_chart_t *chart, int row) { - vwm_xserver_t *xserver = overlays->xserver; - - XRenderComposite(xserver->display, PictOpSrc, overlays->finish_fill, None, overlay->grapha_picture, - 0, 0, /* src x, y */ - 0, 0, /* mask x, y */ - overlay->phase, row * OVERLAY_ROW_HEIGHT, /* dst x, y */ - 1, OVERLAY_ROW_HEIGHT - 1); - XRenderComposite(xserver->display, PictOpSrc, overlays->finish_fill, None, overlay->graphb_picture, - 0, 0, /* src x, y */ - 0, 0, /* mask x, y */ - overlay->phase, row * OVERLAY_ROW_HEIGHT, /* dst x, y */ - 1, OVERLAY_ROW_HEIGHT - 1); + vwm_xserver_t *xserver = charts->xserver; + + XRenderComposite(xserver->display, PictOpSrc, charts->finish_fill, None, chart->grapha_picture, + 0, 0, /* src x, y */ + 0, 0, /* mask x, y */ + chart->phase, row * CHART_ROW_HEIGHT, /* dst x, y */ + 1, CHART_ROW_HEIGHT - 1); + XRenderComposite(xserver->display, PictOpSrc, charts->finish_fill, None, chart->graphb_picture, + 0, 0, /* src x, y */ + 0, 0, /* mask x, y */ + chart->phase, row * CHART_ROW_HEIGHT, /* dst x, y */ + 1, CHART_ROW_HEIGHT - 1); } -/* helper for drawing a proc's argv @ specified x offset and row on the overlay */ -static void print_argv(vwm_overlays_t *overlays, vwm_overlay_t *overlay, int x, int row, vmon_proc_t *proc) +/* helper for drawing a proc's argv @ specified x offset and row on the chart */ +static void print_argv(vwm_charts_t *charts, vwm_chart_t *chart, int x, int row, vmon_proc_t *proc) { - vwm_xserver_t *xserver = overlays->xserver; - XTextItem items[OVERLAY_MAX_ARGC]; + vwm_xserver_t *xserver = charts->xserver; + XTextItem items[CHART_MAX_ARGC]; int nr_items; argv2xtext(proc, items, NELEMS(items), &nr_items); - XDrawText(xserver->display, overlay->text_pixmap, overlays->text_gc, - x, (row + 1) * OVERLAY_ROW_HEIGHT - 3, /* dst x, y */ + XDrawText(xserver->display, chart->text_pixmap, charts->text_gc, + x, (row + 1) * CHART_ROW_HEIGHT - 3, /* dst x, y */ items, nr_items); } /* draws proc in a row of the process heirarchy */ -static void draw_heirarchy_row(vwm_overlays_t *overlays, vwm_overlay_t *overlay, vmon_proc_t *proc, int depth, int row, int heirarchy_changed) +static void draw_heirarchy_row(vwm_charts_t *charts, vwm_chart_t *chart, vmon_proc_t *proc, int depth, int row, int heirarchy_changed) { - vwm_xserver_t *xserver = overlays->xserver; + vwm_xserver_t *xserver = charts->xserver; vmon_proc_stat_t *proc_stat = proc->stores[VMON_STORE_PROC_STAT]; vmon_proc_t *child; char str[256]; @@ -547,7 +547,7 @@ static void draw_heirarchy_row(vwm_overlays_t *overlays, vwm_overlay_t *overlay, /* process heirarchy text and accompanying per-process details like wchan/pid/state... */ /* skip if obviously unnecessary (this can be further improved, but this makes a big difference as-is) */ - if (!overlay->redraw_needed && + if (!chart->redraw_needed && !heirarchy_changed && !BITTEST(proc_stat->changed, VMON_PROC_STAT_WCHAN) && !BITTEST(proc_stat->changed, VMON_PROC_STAT_PID) && @@ -558,9 +558,9 @@ static void draw_heirarchy_row(vwm_overlays_t *overlays, vwm_overlay_t *overlay, /* TODO: make the columns interactively configurable @ runtime */ if (!proc->is_new) /* XXX for now always clear the row, this should be capable of being optimized in the future (if the datums driving the text haven't changed...) */ - XRenderFillRectangle(xserver->display, PictOpSrc, overlay->text_picture, &overlay_trans_color, - 0, row * OVERLAY_ROW_HEIGHT, /* dst x, y */ - overlay->width, OVERLAY_ROW_HEIGHT); /* dst w, h */ + XRenderFillRectangle(xserver->display, PictOpSrc, chart->text_picture, &chart_trans_color, + 0, row * CHART_ROW_HEIGHT, /* dst x, y */ + chart->width, CHART_ROW_HEIGHT); /* dst w, h */ /* put the process' wchan, state, and PID columns @ the far right */ if (proc->is_thread || list_empty(&proc->threads)) { /* only threads or non-threaded processes include the wchan and state */ @@ -573,42 +573,42 @@ static void draw_heirarchy_row(vwm_overlays_t *overlays, vwm_overlay_t *overlay, } else { /* we're a process having threads, suppress the wchan and state, as they will be displayed for the thread of same pid */ snprintf(str, sizeof(str), " %5i %n", proc->pid, &str_len); } - str_width = XTextWidth(overlays->overlay_font, str, str_len); + str_width = XTextWidth(charts->chart_font, str, str_len); /* the process' comm label indented according to depth, followed with their respective argv's */ - print_argv(overlays, overlay, depth * (OVERLAY_ROW_HEIGHT / 2), row, proc); + print_argv(charts, chart, depth * (CHART_ROW_HEIGHT / 2), row, proc); /* ensure the area for the rest of the stuff is cleared, we don't put much text into thread rows so skip it for those. */ if (!proc->is_thread) - XRenderFillRectangle(xserver->display, PictOpSrc, overlay->text_picture, &overlay_trans_color, - overlay->visible_width - str_width, row * OVERLAY_ROW_HEIGHT, /* dst x,y */ - overlay->width - (overlay->visible_width - str_width), OVERLAY_ROW_HEIGHT); /* dst w,h */ + XRenderFillRectangle(xserver->display, PictOpSrc, chart->text_picture, &chart_trans_color, + chart->visible_width - str_width, row * CHART_ROW_HEIGHT, /* dst x,y */ + chart->width - (chart->visible_width - str_width), CHART_ROW_HEIGHT); /* dst w,h */ - XDrawString(xserver->display, overlay->text_pixmap, overlays->text_gc, - overlay->visible_width - str_width, (row + 1) * OVERLAY_ROW_HEIGHT - 3, /* dst x, y */ + XDrawString(xserver->display, chart->text_pixmap, charts->text_gc, + chart->visible_width - str_width, (row + 1) * CHART_ROW_HEIGHT - 3, /* dst x, y */ str, str_len); /* only if this process isn't the root process @ the window shall we consider all relational drawing conditions */ - if (proc != overlay->monitor) { + if (proc != chart->monitor) { vmon_proc_t *ancestor, *sibling, *last_sibling = NULL; struct list_head *rem; int needs_tee = 0; - int bar_x = 0, bar_y = (row + 1) * OVERLAY_ROW_HEIGHT; + int bar_x = 0, bar_y = (row + 1) * CHART_ROW_HEIGHT; int sub; - /* XXX: everything done in this code block only dirties _this_ process' row in the rendered overlay output */ + /* XXX: everything done in this code block only dirties _this_ process' row in the rendered chart output */ - /* walk up the ancestors until reaching overlay->monitor, any ancestors we encounter which have more siblings we draw a vertical bar for */ + /* walk up the ancestors until reaching chart->monitor, any ancestors we encounter which have more siblings we draw a vertical bar for */ /* this draws the |'s in something like: | | | | comm */ - for (sub = 1, ancestor = proc->parent; ancestor && ancestor != overlay->monitor; ancestor = ancestor->parent) { + for (sub = 1, ancestor = proc->parent; ancestor && ancestor != chart->monitor; ancestor = ancestor->parent) { sub++; - bar_x = (depth - sub) * (OVERLAY_ROW_HEIGHT / 2) + 4; + bar_x = (depth - sub) * (CHART_ROW_HEIGHT / 2) + 4; /* determine if the ancestor has remaining siblings which are not stale, if so, draw a connecting bar at its depth */ for (rem = ancestor->siblings.next; rem != &ancestor->parent->children; rem = rem->next) { if (!(list_entry(rem, vmon_proc_t, siblings)->is_stale)) { - XDrawLine(xserver->display, overlay->text_pixmap, overlays->text_gc, - bar_x, bar_y - OVERLAY_ROW_HEIGHT, /* dst x1, y1 */ + XDrawLine(xserver->display, chart->text_pixmap, charts->text_gc, + bar_x, bar_y - CHART_ROW_HEIGHT, /* dst x1, y1 */ bar_x, bar_y); /* dst x2, y2 (vertical line) */ break; /* stop looking for more siblings at this ancestor when we find one that isn't stale */ } @@ -654,20 +654,20 @@ static void draw_heirarchy_row(vwm_overlays_t *overlays, vwm_overlay_t *overlay, /* found a tee is necessary, all that's left is to determine if the tee is a corner and draw it accordingly, stopping the search. */ if (needs_tee) { - bar_x = (depth - 1) * (OVERLAY_ROW_HEIGHT / 2) + 4; + bar_x = (depth - 1) * (CHART_ROW_HEIGHT / 2) + 4; /* if we're the last sibling, corner the tee by shortening the vbar */ if (proc == last_sibling) { - XDrawLine(xserver->display, overlay->text_pixmap, overlays->text_gc, - bar_x, bar_y - OVERLAY_ROW_HEIGHT, /* dst x1, y1 */ + XDrawLine(xserver->display, chart->text_pixmap, charts->text_gc, + bar_x, bar_y - CHART_ROW_HEIGHT, /* dst x1, y1 */ bar_x, bar_y - 4); /* dst x2, y2 (vertical bar) */ } else { - XDrawLine(xserver->display, overlay->text_pixmap, overlays->text_gc, - bar_x, bar_y - OVERLAY_ROW_HEIGHT, /* dst x1, y1 */ + XDrawLine(xserver->display, chart->text_pixmap, charts->text_gc, + bar_x, bar_y - CHART_ROW_HEIGHT, /* dst x1, y1 */ bar_x, bar_y); /* dst x2, y2 (vertical bar) */ } - XDrawLine(xserver->display, overlay->text_pixmap, overlays->text_gc, + XDrawLine(xserver->display, chart->text_pixmap, charts->text_gc, bar_x, bar_y - 4, /* dst x1, y1 */ bar_x + 2, bar_y - 4); /* dst x2, y2 (horizontal bar) */ @@ -677,12 +677,12 @@ static void draw_heirarchy_row(vwm_overlays_t *overlays, vwm_overlay_t *overlay, } } - shadow_row(overlays, overlay, row); + shadow_row(charts, chart, row); } -/* recursive draw function for "rest" of overlay: the per-process rows (heirarchy, argv, state, wchan, pid...) */ -static void draw_overlay_rest(vwm_overlays_t *overlays, vwm_overlay_t *overlay, vmon_proc_t *proc, int *depth, int *row, int heirarchy_changed) +/* recursive draw function for "rest" of chart: the per-process rows (heirarchy, argv, state, wchan, pid...) */ +static void draw_chart_rest(vwm_charts_t *charts, vwm_chart_t *chart, vmon_proc_t *proc, int *depth, int *row, int heirarchy_changed) { vmon_proc_stat_t *proc_stat = proc->stores[VMON_STORE_PROC_STAT]; vwm_perproc_ctxt_t *proc_ctxt = proc->foo; @@ -691,7 +691,7 @@ static void draw_overlay_rest(vwm_overlays_t *overlays, vwm_overlay_t *overlay, /* Some parts of this we must do on every sample to maintain coherence in the graphs, since they're incrementally kept * in sync with the process heirarchy, allocating and shifting the rows as processes are created and destroyed. Everything - * else we should be able to skip doing unless overlay.redraw_needed or their contents changed. + * else we should be able to skip doing unless chart.redraw_needed or their contents changed. */ if (proc->is_stale) { @@ -704,20 +704,20 @@ static void draw_overlay_rest(vwm_overlays_t *overlays, vwm_overlay_t *overlay, /* This does require that I do a separate forward recursion to determine the number of rows * so I can correctly snowflake in reverse */ if (!in_stale) { - VWM_TRACE("entered stale at overlay=%p depth=%i row=%i", overlay, *depth, *row); + VWM_TRACE("entered stale at chart=%p depth=%i row=%i", chart, *depth, *row); in_stale_entrypoint = in_stale = 1; (*row) += count_rows(proc) - 1; } (*depth)++; list_for_each_entry_prev(child, &proc->children, siblings) { - draw_overlay_rest(overlays, overlay, child, depth, row, heirarchy_changed); + draw_chart_rest(charts, chart, child, depth, row, heirarchy_changed); (*row)--; } if (!proc->is_thread) { list_for_each_entry_prev(child, &proc->threads, threads) { - draw_overlay_rest(overlays, overlay, child, depth, row, heirarchy_changed); + draw_chart_rest(charts, chart, child, depth, row, heirarchy_changed); (*row)--; } } @@ -728,23 +728,23 @@ static void draw_overlay_rest(vwm_overlays_t *overlays, vwm_overlay_t *overlay, ((vmon_proc_stat_t *)proc->stores[VMON_STORE_PROC_STAT])->comm.array, (*depth), (*row), proc->is_thread); - mark_finish(overlays, overlay, (*row)); + mark_finish(charts, chart, (*row)); /* extract the row from the various layers */ - snowflake_row(overlays, overlay, overlay->grapha_picture, 1, (*row)); - snowflake_row(overlays, overlay, overlay->graphb_picture, 1, (*row)); - snowflake_row(overlays, overlay, overlay->text_picture, 0, (*row)); - snowflake_row(overlays, overlay, overlay->shadow_picture, 0, (*row)); - overlay->snowflakes_cnt++; + snowflake_row(charts, chart, chart->grapha_picture, 1, (*row)); + snowflake_row(charts, chart, chart->graphb_picture, 1, (*row)); + snowflake_row(charts, chart, chart->text_picture, 0, (*row)); + snowflake_row(charts, chart, chart->shadow_picture, 0, (*row)); + chart->snowflakes_cnt++; - /* stamp the name (and whatever else we include) into overlay.text_picture */ - print_argv(overlays, overlay, 5, overlay->heirarchy_end, proc); - shadow_row(overlays, overlay, overlay->heirarchy_end); + /* stamp the name (and whatever else we include) into chart.text_picture */ + print_argv(charts, chart, 5, chart->heirarchy_end, proc); + shadow_row(charts, chart, chart->heirarchy_end); - overlay->heirarchy_end--; + chart->heirarchy_end--; if (in_stale_entrypoint) { - VWM_TRACE("exited stale at overlay=%p depth=%i row=%i", overlay, *depth, *row); + VWM_TRACE("exited stale at chart=%p depth=%i row=%i", chart, *depth, *row); in_stale = 0; } @@ -753,37 +753,37 @@ static void draw_overlay_rest(vwm_overlays_t *overlays, vwm_overlay_t *overlay, /* what to do when a process has been introduced */ VWM_TRACE("%i is new", proc->pid); - allocate_row(overlays, overlay, overlay->grapha_picture, (*row)); - allocate_row(overlays, overlay, overlay->graphb_picture, (*row)); - allocate_row(overlays, overlay, overlay->text_picture, (*row)); - allocate_row(overlays, overlay, overlay->shadow_picture, (*row)); + allocate_row(charts, chart, chart->grapha_picture, (*row)); + allocate_row(charts, chart, chart->graphb_picture, (*row)); + allocate_row(charts, chart, chart->text_picture, (*row)); + allocate_row(charts, chart, chart->shadow_picture, (*row)); - overlay->heirarchy_end++; + chart->heirarchy_end++; } /* CPU utilization graphs */ /* use the generation number to avoid recomputing this stuff for callbacks recurring on the same process in the same sample */ - if (proc_ctxt->generation != overlays->vmon.generation) { + if (proc_ctxt->generation != charts->vmon.generation) { proc_ctxt->stime_delta = proc_stat->stime - proc_ctxt->last_stime; proc_ctxt->utime_delta = proc_stat->utime - proc_ctxt->last_utime; proc_ctxt->last_utime = proc_stat->utime; proc_ctxt->last_stime = proc_stat->stime; - proc_ctxt->generation = overlays->vmon.generation; + proc_ctxt->generation = charts->vmon.generation; } if (proc->is_new) { /* we need a minimum of two samples before we can compute a delta to plot, * so we suppress that and instead mark the start of monitoring with an impossible 100% of both graph contexts, a starting line. */ - stime_delta = utime_delta = overlays->total_delta; + stime_delta = utime_delta = charts->total_delta; } else { stime_delta = proc_ctxt->stime_delta; utime_delta = proc_ctxt->utime_delta; } - draw_bars(overlays, overlay, *row, stime_delta, overlays->total_delta, utime_delta, overlays->total_delta); + draw_bars(charts, chart, *row, stime_delta, charts->total_delta, utime_delta, charts->total_delta); - draw_heirarchy_row(overlays, overlay, proc, *depth, *row, heirarchy_changed); + draw_heirarchy_row(charts, chart, proc, *depth, *row, heirarchy_changed); (*row)++; @@ -791,83 +791,83 @@ static void draw_overlay_rest(vwm_overlays_t *overlays, vwm_overlay_t *overlay, (*depth)++; if (!proc->is_thread) { /* XXX: the threads member serves as the list head only when not a thread */ list_for_each_entry(child, &proc->threads, threads) { - draw_overlay_rest(overlays, overlay, child, depth, row, heirarchy_changed); + draw_chart_rest(charts, chart, child, depth, row, heirarchy_changed); } } list_for_each_entry(child, &proc->children, siblings) { - draw_overlay_rest(overlays, overlay, child, depth, row, heirarchy_changed); + draw_chart_rest(charts, chart, child, depth, row, heirarchy_changed); } (*depth)--; } -/* recursive draw function entrypoint, draws the IOWait/Idle/HZ row, then enters draw_overlay_rest() */ -static void draw_overlay(vwm_overlays_t *overlays, vwm_overlay_t *overlay, vmon_proc_t *proc, int *depth, int *row) +/* recursive draw function entrypoint, draws the IOWait/Idle/HZ row, then enters draw_chart_rest() */ +static void draw_chart(vwm_charts_t *charts, vwm_chart_t *chart, vmon_proc_t *proc, int *depth, int *row) { - vwm_xserver_t *xserver = overlays->xserver; + vwm_xserver_t *xserver = charts->xserver; int heirarchy_changed = 0; int str_len, str_width; char str[256]; /* CPU utilization graphs */ /* IOWait and Idle % @ row 0 */ - draw_bars(overlays, overlay, *row, overlays->iowait_delta, overlays->total_delta, overlays->idle_delta, overlays->total_delta); + draw_bars(charts, chart, *row, charts->iowait_delta, charts->total_delta, charts->idle_delta, charts->total_delta); /* only draw the \/\/\ and HZ if necessary */ - if (overlay->redraw_needed || overlays->prev_sampling_interval != overlays->sampling_interval) { - snprintf(str, sizeof(str), "\\/\\/\\ %2iHz %n", (int)(overlays->sampling_interval == INFINITY ? 0 : 1 / overlays->sampling_interval), &str_len); - XRenderFillRectangle(xserver->display, PictOpSrc, overlay->text_picture, &overlay_trans_color, + if (chart->redraw_needed || charts->prev_sampling_interval != charts->sampling_interval) { + snprintf(str, sizeof(str), "\\/\\/\\ %2iHz %n", (int)(charts->sampling_interval == INFINITY ? 0 : 1 / charts->sampling_interval), &str_len); + XRenderFillRectangle(xserver->display, PictOpSrc, chart->text_picture, &chart_trans_color, 0, 0, /* dst x, y */ - overlay->visible_width, OVERLAY_ROW_HEIGHT); /* dst w, h */ - str_width = XTextWidth(overlays->overlay_font, str, str_len); - XDrawString(xserver->display, overlay->text_pixmap, overlays->text_gc, - overlay->visible_width - str_width, OVERLAY_ROW_HEIGHT - 3, /* dst x, y */ + chart->visible_width, CHART_ROW_HEIGHT); /* dst w, h */ + str_width = XTextWidth(charts->chart_font, str, str_len); + XDrawString(xserver->display, chart->text_pixmap, charts->text_gc, + chart->visible_width - str_width, CHART_ROW_HEIGHT - 3, /* dst x, y */ str, str_len); - shadow_row(overlays, overlay, 0); + shadow_row(charts, chart, 0); } (*row)++; - if (!overlay->redraw_needed) + if (!chart->redraw_needed) heirarchy_changed = proc_heirarchy_changed(proc); - draw_overlay_rest(overlays, overlay, proc, depth, row, heirarchy_changed); + draw_chart_rest(charts, chart, proc, depth, row, heirarchy_changed); - overlay->redraw_needed = 0; + chart->redraw_needed = 0; return; } -/* consolidated version of overlay text and graph rendering, makes snowflakes integration cleaner, this always gets called regardless of the overlays mode */ -static void maintain_overlay(vwm_overlays_t *overlays, vwm_overlay_t *overlay) +/* consolidated version of chart text and graph rendering, makes snowflakes integration cleaner, this always gets called regardless of the charts mode */ +static void maintain_chart(vwm_charts_t *charts, vwm_chart_t *chart) { - vwm_xserver_t *xserver = overlays->xserver; + vwm_xserver_t *xserver = charts->xserver; int row = 0, depth = 0; - if (!overlay->monitor || !overlay->monitor->stores[VMON_STORE_PROC_STAT]) + if (!chart->monitor || !chart->monitor->stores[VMON_STORE_PROC_STAT]) return; /* TODO: * A side effect of responding to window resizes in this function is there's a latency proportional to the current sample_interval. - * Something to fix is to resize the overlays when the window resizes. - * However, simply resizing the overlays is insufficient. Their contents need to be redrawn in the new dimensions, this is where it - * gets annoying. The current maintain/draw_overlay makes assumptions about being run from the periodic vmon per-process callback. - * There needs to be a redraw mode added where draw_overlay is just reconstructing the current state, which requires that we suppress - * the phase advance and in maintain_overlay() and just enter draw_overlay() to redraw everything for the same generation. - * So this probably requires some tweaking of draw_overlay() as well as maintain_overlay(). I want to be able tocall mainta_overlays() + * Something to fix is to resize the charts when the window resizes. + * However, simply resizing the charts is insufficient. Their contents need to be redrawn in the new dimensions, this is where it + * gets annoying. The current maintain/draw_chart makes assumptions about being run from the periodic vmon per-process callback. + * There needs to be a redraw mode added where draw_chart is just reconstructing the current state, which requires that we suppress + * the phase advance and in maintain_chart() and just enter draw_chart() to redraw everything for the same generation. + * So this probably requires some tweaking of draw_chart() as well as maintain_chart(). I want to be able tocall mainta_charts() * from anywhere, and have it detect if it's being called on the same generation or if the generation has advanced. * For now, the monitors will just be a little latent in window resizes which is pretty harmless artifact. */ - overlay->phase += (overlay->width - 1); /* simply change this to .phase++ to scroll the other direction */ - overlay->phase %= overlay->width; - XRenderFillRectangle(xserver->display, PictOpSrc, overlay->grapha_picture, &overlay_trans_color, overlay->phase, 0, 1, overlay->height); - XRenderFillRectangle(xserver->display, PictOpSrc, overlay->graphb_picture, &overlay_trans_color, overlay->phase, 0, 1, overlay->height); + chart->phase += (chart->width - 1); /* simply change this to .phase++ to scroll the other direction */ + chart->phase %= chart->width; + XRenderFillRectangle(xserver->display, PictOpSrc, chart->grapha_picture, &chart_trans_color, chart->phase, 0, 1, chart->height); + XRenderFillRectangle(xserver->display, PictOpSrc, chart->graphb_picture, &chart_trans_color, chart->phase, 0, 1, chart->height); - /* recursively draw the monitored processes to the overlay */ - draw_overlay(overlays, overlay, overlay->monitor, &depth, &row); + /* recursively draw the monitored processes to the chart */ + draw_chart(charts, chart, chart->monitor, &depth, &row); } @@ -876,60 +876,60 @@ static void maintain_overlay(vwm_overlays_t *overlays, vwm_overlay_t *overlay) * It's also where we compose the graphs and text for visible windows into a picture ready for compositing with the window contents */ static void proc_sample_callback(vmon_t *vmon, void *sys_cb_arg, vmon_proc_t *proc, void *proc_cb_arg) { - vwm_overlays_t *overlays = sys_cb_arg; - vwm_overlay_t *overlay = proc_cb_arg; + vwm_charts_t *charts = sys_cb_arg; + vwm_chart_t *chart = proc_cb_arg; - VWM_TRACE("proc=%p overlay=%p", proc, overlay); + VWM_TRACE("proc=%p chart=%p", proc, chart); - /* render the various always-updated overlays, this is the component we do regardless of the overlays mode and window visibility, + /* render the various always-updated charts, this is the component we do regardless of the charts mode and window visibility, * essentially the incrementally rendered/historic components */ - maintain_overlay(overlays, overlay); + maintain_chart(charts, chart); - /* XXX TODO: we used to mark repaint as being needed if this overlay's window was mapped, but - * since extricating overlays from windows that's no longer convenient, and repaint is + /* XXX TODO: we used to mark repaint as being needed if this chart's window was mapped, but + * since extricating charts from windows that's no longer convenient, and repaint is * always performed after a sample. Make sure the repainting isn't costly when nothing - * overlayed is mapped (the case that code optimized) + * charted is mapped (the case that code optimized) */ } -/* return the composed height of the overlay */ -static int vwm_overlay_composed_height(vwm_overlays_t *overlays, vwm_overlay_t *overlay) +/* return the composed height of the chart */ +static int vwm_chart_composed_height(vwm_charts_t *charts, vwm_chart_t *chart) { - int snowflakes = overlay->snowflakes_cnt ? 1 + overlay->snowflakes_cnt : 0; /* don't include the separator row if there are no snowflakes */ + int snowflakes = chart->snowflakes_cnt ? 1 + chart->snowflakes_cnt : 0; /* don't include the separator row if there are no snowflakes */ - return MIN((overlay->heirarchy_end + snowflakes) * OVERLAY_ROW_HEIGHT, overlay->visible_height); + return MIN((chart->heirarchy_end + snowflakes) * CHART_ROW_HEIGHT, chart->visible_height); } -/* reset snowflakes on the specified overlay */ -void vwm_overlay_reset_snowflakes(vwm_overlays_t *overlays, vwm_overlay_t *overlay) +/* reset snowflakes on the specified chart */ +void vwm_chart_reset_snowflakes(vwm_charts_t *charts, vwm_chart_t *chart) { - if (overlay->snowflakes_cnt) { - overlay->snowflakes_cnt = 0; - overlay->redraw_needed = 1; + if (chart->snowflakes_cnt) { + chart->snowflakes_cnt = 0; + chart->redraw_needed = 1; } } -static void free_overlay_pictures(vwm_overlays_t *overlays, vwm_overlay_t *overlay) +static void free_chart_pictures(vwm_charts_t *charts, vwm_chart_t *chart) { - vwm_xserver_t *xserver = overlays->xserver; + vwm_xserver_t *xserver = charts->xserver; - XRenderFreePicture(xserver->display, overlay->grapha_picture); - XRenderFreePicture(xserver->display, overlay->graphb_picture); - XRenderFreePicture(xserver->display, overlay->tmp_picture); - XRenderFreePicture(xserver->display, overlay->text_picture); - XFreePixmap(xserver->display, overlay->text_pixmap); - XRenderFreePicture(xserver->display, overlay->shadow_picture); - XRenderFreePicture(xserver->display, overlay->picture); + XRenderFreePicture(xserver->display, chart->grapha_picture); + XRenderFreePicture(xserver->display, chart->graphb_picture); + XRenderFreePicture(xserver->display, chart->tmp_picture); + XRenderFreePicture(xserver->display, chart->text_picture); + XFreePixmap(xserver->display, chart->text_pixmap); + XRenderFreePicture(xserver->display, chart->shadow_picture); + XRenderFreePicture(xserver->display, chart->picture); } -static void copy_overlay_pictures(vwm_overlays_t *overlays, vwm_overlay_t *src, vwm_overlay_t *dest) +static void copy_chart_pictures(vwm_charts_t *charts, vwm_chart_t *src, vwm_chart_t *dest) { - vwm_xserver_t *xserver = overlays->xserver; + vwm_xserver_t *xserver = charts->xserver; if (!src->width) return; @@ -963,190 +963,190 @@ static void copy_overlay_pictures(vwm_overlays_t *overlays, vwm_overlay_t *src, } -/* (re)size the specified overlay's visible dimensions */ -int vwm_overlay_set_visible_size(vwm_overlays_t *overlays, vwm_overlay_t *overlay, int width, int height) +/* (re)size the specified chart's visible dimensions */ +int vwm_chart_set_visible_size(vwm_charts_t *charts, vwm_chart_t *chart, int width, int height) { - if (width != overlay->visible_width || height != overlay->visible_height) - overlay->redraw_needed = 1; + if (width != chart->visible_width || height != chart->visible_height) + chart->redraw_needed = 1; - /* TODO error handling: if a create failed but we had an overlay, free whatever we created and leave it be, succeed. + /* TODO error handling: if a create failed but we had an chart, free whatever we created and leave it be, succeed. * if none existed it's a hard error and we must propagate it. */ - /* if larger than the overlays currently are, enlarge them */ - if (width > overlay->width || height > overlay->height) { - vwm_overlay_t existing = *overlay; + /* if larger than the charts currently are, enlarge them */ + if (width > chart->width || height > chart->height) { + vwm_chart_t existing = *chart; - overlay->width = MAX(overlay->width, MAX(width, OVERLAY_GRAPH_MIN_WIDTH)); - overlay->height = MAX(overlay->height, MAX(height, OVERLAY_GRAPH_MIN_HEIGHT)); + chart->width = MAX(chart->width, MAX(width, CHART_GRAPH_MIN_WIDTH)); + chart->height = MAX(chart->height, MAX(height, CHART_GRAPH_MIN_HEIGHT)); - overlay->grapha_picture = create_picture_fill(overlays, overlay->width, overlay->height, OVERLAY_MASK_DEPTH, CPRepeat, &pa_repeat, &overlay_trans_color, NULL); - overlay->graphb_picture = create_picture_fill(overlays, overlay->width, overlay->height, OVERLAY_MASK_DEPTH, CPRepeat, &pa_repeat, &overlay_trans_color, NULL); - overlay->tmp_picture = create_picture(overlays, overlay->width, OVERLAY_ROW_HEIGHT, OVERLAY_MASK_DEPTH, 0, NULL, NULL); + chart->grapha_picture = create_picture_fill(charts, chart->width, chart->height, CHART_MASK_DEPTH, CPRepeat, &pa_repeat, &chart_trans_color, NULL); + chart->graphb_picture = create_picture_fill(charts, chart->width, chart->height, CHART_MASK_DEPTH, CPRepeat, &pa_repeat, &chart_trans_color, NULL); + chart->tmp_picture = create_picture(charts, chart->width, CHART_ROW_HEIGHT, CHART_MASK_DEPTH, 0, NULL, NULL); /* keep the text_pixmap reference around for XDrawText usage */ - overlay->text_picture = create_picture_fill(overlays, overlay->width, overlay->height, OVERLAY_MASK_DEPTH, 0, NULL, &overlay_trans_color, &overlay->text_pixmap); + chart->text_picture = create_picture_fill(charts, chart->width, chart->height, CHART_MASK_DEPTH, 0, NULL, &chart_trans_color, &chart->text_pixmap); - overlay->shadow_picture = create_picture_fill(overlays, overlay->width, overlay->height, OVERLAY_MASK_DEPTH, 0, NULL, &overlay_trans_color, NULL); - overlay->picture = create_picture(overlays, overlay->width, overlay->height, 32, 0, NULL, NULL); + chart->shadow_picture = create_picture_fill(charts, chart->width, chart->height, CHART_MASK_DEPTH, 0, NULL, &chart_trans_color, NULL); + chart->picture = create_picture(charts, chart->width, chart->height, 32, 0, NULL, NULL); - copy_overlay_pictures(overlays, &existing, overlay); - free_overlay_pictures(overlays, &existing); + copy_chart_pictures(charts, &existing, chart); + free_chart_pictures(charts, &existing); } - overlay->visible_width = width; - overlay->visible_height = height; + chart->visible_width = width; + chart->visible_height = height; return 1; } -/* create an overlay and start monitoring for the supplied pid */ -vwm_overlay_t * vwm_overlay_create(vwm_overlays_t *overlays, int pid, int width, int height) +/* create an chart and start monitoring for the supplied pid */ +vwm_chart_t * vwm_chart_create(vwm_charts_t *charts, int pid, int width, int height) { - vwm_overlay_t *overlay; + vwm_chart_t *chart; - overlay = calloc(1, sizeof(vwm_overlay_t)); - if (!overlay) { - VWM_PERROR("Unable to allocate vwm_overlay_t"); + chart = calloc(1, sizeof(vwm_chart_t)); + if (!chart) { + VWM_PERROR("Unable to allocate vwm_chart_t"); goto _err; } /* add the client process to the monitoring heirarchy */ /* XXX note libvmon here maintains a unique callback for each unique callback+xwin pair, so multi-window processes work */ - overlay->monitor = vmon_proc_monitor(&overlays->vmon, NULL, pid, VMON_WANT_PROC_INHERIT, (void (*)(vmon_t *, void *, vmon_proc_t *, void *))proc_sample_callback, overlay); - if (!overlay->monitor) { + chart->monitor = vmon_proc_monitor(&charts->vmon, NULL, pid, VMON_WANT_PROC_INHERIT, (void (*)(vmon_t *, void *, vmon_proc_t *, void *))proc_sample_callback, chart); + if (!chart->monitor) { VWM_ERROR("Unable to establish proc monitor"); goto _err_free; } /* FIXME: count_rows() isn't returning the right count sometimes (off by ~1), it seems to be related to racing with the automatic child monitoring */ /* the result is an extra row sometimes appearing below the process heirarchy */ - overlay->heirarchy_end = 1 + count_rows(overlay->monitor); - overlay->gen_last_composed = -1; + chart->heirarchy_end = 1 + count_rows(chart->monitor); + chart->gen_last_composed = -1; - if (!vwm_overlay_set_visible_size(overlays, overlay, width, height)) { - VWM_ERROR("Unable to set initial overlay size"); + if (!vwm_chart_set_visible_size(charts, chart, width, height)) { + VWM_ERROR("Unable to set initial chart size"); goto _err_unmonitor; } - return overlay; + return chart; _err_unmonitor: - vmon_proc_unmonitor(&overlays->vmon, overlay->monitor, (void (*)(vmon_t *, void *, vmon_proc_t *, void *))proc_sample_callback, overlay); + vmon_proc_unmonitor(&charts->vmon, chart->monitor, (void (*)(vmon_t *, void *, vmon_proc_t *, void *))proc_sample_callback, chart); _err_free: - free(overlay); + free(chart); _err: return NULL; } -/* stop monitoring and destroy the supplied overlay */ -void vwm_overlay_destroy(vwm_overlays_t *overlays, vwm_overlay_t *overlay) +/* stop monitoring and destroy the supplied chart */ +void vwm_chart_destroy(vwm_charts_t *charts, vwm_chart_t *chart) { - vmon_proc_unmonitor(&overlays->vmon, overlay->monitor, (void (*)(vmon_t *, void *, vmon_proc_t *, void *))proc_sample_callback, overlay); - free_overlay_pictures(overlays, overlay); - free(overlay); + vmon_proc_unmonitor(&charts->vmon, chart->monitor, (void (*)(vmon_t *, void *, vmon_proc_t *, void *))proc_sample_callback, chart); + free_chart_pictures(charts, chart); + free(chart); } -/* this composes the maintained overlay into the base overlay picture, this gets called from paint_all() on every repaint of xwin */ +/* this composes the maintained chart into the base chart picture, this gets called from paint_all() on every repaint of xwin */ /* we noop the call if the gen_last_composed and monitor->proc.generation numbers match, indicating there's nothing new to compose. */ -void vwm_overlay_compose(vwm_overlays_t *overlays, vwm_overlay_t *overlay, XserverRegion *res_damaged_region) +void vwm_chart_compose(vwm_charts_t *charts, vwm_chart_t *chart, XserverRegion *res_damaged_region) { - vwm_xserver_t *xserver = overlays->xserver; + vwm_xserver_t *xserver = charts->xserver; int height; - if (!overlay->width || !overlay->height) + if (!chart->width || !chart->height) return; - if (overlay->gen_last_composed == overlay->monitor->generation) + if (chart->gen_last_composed == chart->monitor->generation) return; /* noop if no sampling occurred since last compose */ - overlay->gen_last_composed = overlay->monitor->generation; /* remember this generation */ + chart->gen_last_composed = chart->monitor->generation; /* remember this generation */ - //VWM_TRACE("composing %p", overlay); + //VWM_TRACE("composing %p", chart); - height = vwm_overlay_composed_height(overlays, overlay); + height = vwm_chart_composed_height(charts, chart); - /* fill the overlay picture with the background */ - XRenderComposite(xserver->display, PictOpSrc, overlays->bg_fill, None, overlay->picture, + /* fill the chart picture with the background */ + XRenderComposite(xserver->display, PictOpSrc, charts->bg_fill, None, chart->picture, 0, 0, 0, 0, 0, 0, - overlay->visible_width, height); + chart->visible_width, height); - /* draw the graphs into the overlay through the stencils being maintained by the sample callbacks */ - XRenderComposite(xserver->display, PictOpOver, overlays->grapha_fill, overlay->grapha_picture, overlay->picture, + /* draw the graphs into the chart through the stencils being maintained by the sample callbacks */ + XRenderComposite(xserver->display, PictOpOver, charts->grapha_fill, chart->grapha_picture, chart->picture, 0, 0, - overlay->phase, 0, + chart->phase, 0, 0, 0, - overlay->visible_width, height); - XRenderComposite(xserver->display, PictOpOver, overlays->graphb_fill, overlay->graphb_picture, overlay->picture, + chart->visible_width, height); + XRenderComposite(xserver->display, PictOpOver, charts->graphb_fill, chart->graphb_picture, chart->picture, 0, 0, - overlay->phase, 0, + chart->phase, 0, 0, 0, - overlay->visible_width, height); + chart->visible_width, height); - /* draw the shadow into the overlay picture using a translucent black source drawn through the shadow mask */ - XRenderComposite(xserver->display, PictOpOver, overlays->shadow_fill, overlay->shadow_picture, overlay->picture, + /* draw the shadow into the chart picture using a translucent black source drawn through the shadow mask */ + XRenderComposite(xserver->display, PictOpOver, charts->shadow_fill, chart->shadow_picture, chart->picture, 0, 0, 0, 0, 0, 0, - overlay->visible_width, height); + chart->visible_width, height); - /* render overlay text into the overlay picture using a white source drawn through the overlay text as a mask, on top of everything */ - XRenderComposite(xserver->display, PictOpOver, overlays->text_fill, overlay->text_picture, overlay->picture, + /* render chart text into the chart picture using a white source drawn through the chart text as a mask, on top of everything */ + XRenderComposite(xserver->display, PictOpOver, charts->text_fill, chart->text_picture, chart->picture, 0, 0, 0, 0, 0, 0, - overlay->visible_width, (overlay->heirarchy_end * OVERLAY_ROW_HEIGHT)); + chart->visible_width, (chart->heirarchy_end * CHART_ROW_HEIGHT)); - XRenderComposite(xserver->display, PictOpOver, overlays->snowflakes_text_fill, overlay->text_picture, overlay->picture, + XRenderComposite(xserver->display, PictOpOver, charts->snowflakes_text_fill, chart->text_picture, chart->picture, 0, 0, - 0, overlay->heirarchy_end * OVERLAY_ROW_HEIGHT, - 0, overlay->heirarchy_end * OVERLAY_ROW_HEIGHT, - overlay->visible_width, height - (overlay->heirarchy_end * OVERLAY_ROW_HEIGHT)); + 0, chart->heirarchy_end * CHART_ROW_HEIGHT, + 0, chart->heirarchy_end * CHART_ROW_HEIGHT, + chart->visible_width, height - (chart->heirarchy_end * CHART_ROW_HEIGHT)); - /* damage the window to ensure the updated overlay is drawn (TODO: this can be done more selectively/efficiently) */ + /* damage the window to ensure the updated chart is drawn (TODO: this can be done more selectively/efficiently) */ if (res_damaged_region) { XRectangle damage = {}; - damage.width = overlay->visible_width; - damage.height = overlay->visible_height; + damage.width = chart->visible_width; + damage.height = chart->visible_height; *res_damaged_region = XFixesCreateRegion(xserver->display, &damage, 1); } } -/* render the overlay into a picture at the specified coordinates and dimensions */ -void vwm_overlay_render(vwm_overlays_t *overlays, vwm_overlay_t *overlay, int op, Picture dest, int x, int y, int width, int height) +/* render the chart into a picture at the specified coordinates and dimensions */ +void vwm_chart_render(vwm_charts_t *charts, vwm_chart_t *chart, int op, Picture dest, int x, int y, int width, int height) { - vwm_xserver_t *xserver = overlays->xserver; + vwm_xserver_t *xserver = charts->xserver; - if (!overlay->width || !overlay->height) + if (!chart->width || !chart->height) return; - /* draw the monitoring overlay atop dest, note we stay within the window borders here. */ - XRenderComposite(xserver->display, op, overlay->picture, None, dest, - 0, 0, 0, 0, /* src x,y, maxk x, y */ - x, /* dst x */ - y, /* dst y */ - width, MIN(vwm_overlay_composed_height(overlays, overlay), height) /* FIXME */); /* w, h */ + /* draw the monitoring chart atop dest, note we stay within the window borders here. */ + XRenderComposite(xserver->display, op, chart->picture, None, dest, + 0, 0, 0, 0, /* src x,y, maxk x, y */ + x, /* dst x */ + y, /* dst y */ + width, MIN(vwm_chart_composed_height(charts, chart), height) /* FIXME */); /* w, h */ } /* increase the sample rate relative to current using the table of intervals */ -void vwm_overlays_rate_increase(vwm_overlays_t *overlays) +void vwm_charts_rate_increase(vwm_charts_t *charts) { int i; - assert(overlays); + assert(charts); for (i = 0; i < NELEMS(sampling_intervals); i++) { - if (sampling_intervals[i] < overlays->sampling_interval) { - overlays->sampling_interval = sampling_intervals[i]; + if (sampling_intervals[i] < charts->sampling_interval) { + charts->sampling_interval = sampling_intervals[i]; break; } } @@ -1154,15 +1154,15 @@ void vwm_overlays_rate_increase(vwm_overlays_t *overlays) /* decrease the sample rate relative to current using the table of intervals */ -void vwm_overlays_rate_decrease(vwm_overlays_t *overlays) +void vwm_charts_rate_decrease(vwm_charts_t *charts) { int i; - assert(overlays); + assert(charts); for (i = NELEMS(sampling_intervals) - 1; i >= 0; i--) { - if (sampling_intervals[i] > overlays->sampling_interval) { - overlays->sampling_interval = sampling_intervals[i]; + if (sampling_intervals[i] > charts->sampling_interval) { + charts->sampling_interval = sampling_intervals[i]; break; } } @@ -1170,12 +1170,12 @@ void vwm_overlays_rate_decrease(vwm_overlays_t *overlays) /* set an arbitrary sample rate rather than using one of the presets, 0 to pause */ -void vwm_overlays_rate_set(vwm_overlays_t *overlays, unsigned hertz) +void vwm_charts_rate_set(vwm_charts_t *charts, unsigned hertz) { - assert(overlays); + assert(charts); /* XXX: note floating point divide by 0 simply results in infinity */ - overlays->sampling_interval = 1.0f / (float)hertz; + charts->sampling_interval = 1.0f / (float)hertz; } @@ -1195,36 +1195,36 @@ static float delta(struct timeval *cur, struct timeval *prev) } -/* update the overlays if necessary, return if updating occurred, and duration before another update needed in *desired_delay */ -int vwm_overlays_update(vwm_overlays_t *overlays, int *desired_delay) +/* update the charts if necessary, return if updating occurred, and duration before another update needed in *desired_delay */ +int vwm_charts_update(vwm_charts_t *charts, int *desired_delay) { float this_delta = 0.0f; int ret = 0; - gettimeofday(&overlays->maybe_sample, NULL); - if ((overlays->sampling_interval == INFINITY && !overlays->sampling_paused) || /* XXX this is kind of a kludge to get the 0 Hz indicator drawn before pausing */ - (overlays->sampling_interval != INFINITY && ((this_delta = delta(&overlays->maybe_sample, &overlays->this_sample)) >= overlays->sampling_interval))) { + gettimeofday(&charts->maybe_sample, NULL); + if ((charts->sampling_interval == INFINITY && !charts->sampling_paused) || /* XXX this is kind of a kludge to get the 0 Hz indicator drawn before pausing */ + (charts->sampling_interval != INFINITY && ((this_delta = delta(&charts->maybe_sample, &charts->this_sample)) >= charts->sampling_interval))) { vmon_sys_stat_t *sys_stat; /* automatically lower the sample rate if we can't keep up with the current sample rate */ - if (overlays->sampling_interval < INFINITY && - overlays->sampling_interval <= overlays->prev_sampling_interval && - this_delta >= (overlays->sampling_interval * 1.5)) { + if (charts->sampling_interval < INFINITY && + charts->sampling_interval <= charts->prev_sampling_interval && + this_delta >= (charts->sampling_interval * 1.5)) { /* require > 1 contiguous drops before lowering the rate, tolerates spurious one-off stalls */ - if (++overlays->contiguous_drops > 2) - vwm_overlays_rate_decrease(overlays); + if (++charts->contiguous_drops > 2) + vwm_charts_rate_decrease(charts); } else { - overlays->contiguous_drops = 0; + charts->contiguous_drops = 0; } /* age the sys-wide sample data into "last" variables, before the new sample overwrites them. */ - overlays->last_sample = overlays->this_sample; - overlays->this_sample = overlays->maybe_sample; - if ((sys_stat = overlays->vmon.stores[VMON_STORE_SYS_STAT])) { - overlays->last_user_cpu = sys_stat->user; - overlays->last_system_cpu = sys_stat->system; - overlays->last_total = sys_stat->user + + charts->last_sample = charts->this_sample; + charts->this_sample = charts->maybe_sample; + if ((sys_stat = charts->vmon.stores[VMON_STORE_SYS_STAT])) { + charts->last_user_cpu = sys_stat->user; + charts->last_system_cpu = sys_stat->system; + charts->last_total = sys_stat->user + sys_stat->nice + sys_stat->system + sys_stat->idle + @@ -1234,19 +1234,19 @@ int vwm_overlays_update(vwm_overlays_t *overlays, int *desired_delay) sys_stat->steal + sys_stat->guest; - overlays->last_idle = sys_stat->idle; - overlays->last_iowait = sys_stat->iowait; + charts->last_idle = sys_stat->idle; + charts->last_iowait = sys_stat->iowait; } - ret = vmon_sample(&overlays->vmon); /* XXX: calls proc_sample_callback() for explicitly monitored processes after sampling their descendants */ + ret = vmon_sample(&charts->vmon); /* XXX: calls proc_sample_callback() for explicitly monitored processes after sampling their descendants */ /* XXX: also calls sample_callback() per invocation after sampling the sys wants */ - overlays->sampling_paused = (overlays->sampling_interval == INFINITY); - overlays->prev_sampling_interval = overlays->sampling_interval; + charts->sampling_paused = (charts->sampling_interval == INFINITY); + charts->prev_sampling_interval = charts->sampling_interval; } /* TODO: make some effort to compute how long to sleep, but this is perfectly fine for now. */ - *desired_delay = overlays->sampling_interval == INFINITY ? -1 : overlays->sampling_interval * 300.0; + *desired_delay = charts->sampling_interval == INFINITY ? -1 : charts->sampling_interval * 300.0; return ret; } |