X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Fbootchart%2Fsvg.c;h=c63fd0406e3154ecd091260b37d44c352a5da87c;hb=af672f03eccd2df655edb585af25f4b8f3e153ac;hp=9fee810795b30afb471d4a6fc40a54cba622aed1;hpb=1f3523baf7418adf3b2738b3917ef956a8414ab7;p=elogind.git diff --git a/src/bootchart/svg.c b/src/bootchart/svg.c index 9fee81079..c63fd0406 100644 --- a/src/bootchart/svg.c +++ b/src/bootchart/svg.c @@ -1,7 +1,9 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + /*** - bootchart.c - This file is part of systemd-bootchart + This file is part of systemd. - Copyright (C) 2009-2013 Intel Coproration + Copyright (C) 2009-2013 Intel Corporation Authors: Auke Kok @@ -21,34 +23,28 @@ ***/ #include -#include -#include #include #include #include #include #include -#include #include -#include "bootchart.h" #include "util.h" +#include "fileio.h" #include "macro.h" +#include "store.h" +#include "svg.h" +#include "bootchart.h" +#include "list.h" +#include "utf8.h" - -#define time_to_graph(t) ((t) * scale_x) -#define ps_to_graph(n) ((n) * scale_y) -#define kb_to_graph(m) ((m) * scale_y * 0.0001) +#define time_to_graph(t) ((t) * arg_scale_x) +#define ps_to_graph(n) ((n) * arg_scale_y) +#define kb_to_graph(m) ((m) * arg_scale_y * 0.0001) #define to_color(n) (192.0 - ((n) * 192.0)) -#define max(x, y) (((x) > (y)) ? (x) : (y)) -#define min(x, y) (((x) < (y)) ? (x) : (y)) - -static char str[8092]; - -#define svg(a...) do { snprintf(str, 8092, ## a); fputs(str, of); fflush(of); } while (0) - -static const char *colorwheel[12] = { +static const char * const colorwheel[12] = { "rgb(255,32,32)", // red "rgb(32,192,192)", // cyan "rgb(255,128,32)", // orange @@ -67,201 +63,214 @@ static double idletime = -1.0; static int pfiltered = 0; static int pcount = 0; static int kcount = 0; -static float psize = 0; -static float ksize = 0; -static float esize = 0; - - -static void svg_header(void) -{ - float w; - float h; +static double psize = 0; +static double ksize = 0; +static double esize = 0; +static struct list_sample_data *sampledata; +static struct list_sample_data *prev_sampledata; + +static void svg_header(FILE *of, struct list_sample_data *head, double graph_start) { + double w; + double h; + struct list_sample_data *sampledata_last; + + assert(head); + + sampledata = head; + LIST_FIND_TAIL(link, sampledata, head); + sampledata_last = head; + LIST_FOREACH_BEFORE(link, sampledata, head) { + sampledata_last = sampledata; + } /* min width is about 1600px due to the label */ - w = 150.0 + 10.0 + time_to_graph(sampletime[samples-1] - graph_start); + w = 150.0 + 10.0 + time_to_graph(sampledata_last->sampletime - graph_start); w = ((w < 1600.0) ? 1600.0 : w); /* height is variable based on pss, psize, ksize */ - h = 400.0 + (scale_y * 30.0) /* base graphs and title */ - + (pss ? (100.0 * scale_y) + (scale_y * 7.0) : 0.0) /* pss estimate */ + h = 400.0 + (arg_scale_y * 30.0) /* base graphs and title */ + + (arg_pss ? (100.0 * arg_scale_y) + (arg_scale_y * 7.0) : 0.0) /* pss estimate */ + psize + ksize + esize; - svg("\n"); - svg("\n"); + fprintf(of, "\n"); + fprintf(of, "\n"); - //svg("\n", 1000 + 150 + (pcount * 20)); - svg("\n\n"); + //fprintf(of, "\n", 1000 + 150 + (pcount * 20)); + fprintf(of, "\n\n"); /* write some basic info as a comment, including some help */ - svg("\n"); - svg("\n"); - svg("\n"); - svg("\n"); - svg("\n\n"); - - svg("\n", VERSION); - svg("\n", hz, samples_len); - svg("\n", scale_x, scale_y); - svg("\n", relative, filter); - svg("\n", pss, entropy); - svg("\n\n", output_path, init_path); + fprintf(of, "\n"); + fprintf(of, "\n"); + fprintf(of, "\n"); + fprintf(of, "\n"); + fprintf(of, "\n\n"); + + fprintf(of, "\n", VERSION); + fprintf(of, "\n", arg_hz, arg_samples_len); + fprintf(of, "\n", arg_scale_x, arg_scale_y); + fprintf(of, "\n", arg_relative, arg_filter); + fprintf(of, "\n", arg_pss, arg_entropy); + fprintf(of, "\n\n", arg_output_path, arg_init_path); /* style sheet */ - svg("\n \n\n\n"); - + fprintf(of, "\n \n\n\n"); } - -static void svg_title(const char *build) -{ - char cmdline[256] = ""; - char filename[PATH_MAX]; - char buf[256]; - char rootbdev[16] = "Unknown"; - char model[256] = "Unknown"; +static int svg_title(FILE *of, const char *build, int pscount, double log_start, int overrun) { + _cleanup_free_ char *cmdline = NULL; + _cleanup_free_ char *model = NULL; + _cleanup_free_ char *buf = NULL; char date[256] = "Unknown"; - char cpu[256] = "Unknown"; + char *cpu; char *c; - FILE *f; time_t t; - int fd; + int r; struct utsname uts; - /* grab /proc/cmdline */ - fd = openat(procfd, "cmdline", O_RDONLY); - f = fdopen(fd, "r"); - if (f) { - if (!fgets(cmdline, 255, f)) - sprintf(cmdline, "Unknown"); - fclose(f); + r = read_one_line_file("/proc/cmdline", &cmdline); + if (r < 0) { + log_error_errno(r, "Unable to read cmdline: %m\n"); + return r; } /* extract root fs so we can find disk model name in sysfs */ /* FIXME: this works only in the simple case */ c = strstr(cmdline, "root=/dev/"); if (c) { - strncpy(rootbdev, &c[10], 3); + char rootbdev[4]; + char filename[32]; + + strncpy(rootbdev, &c[10], sizeof(rootbdev) - 1); rootbdev[3] = '\0'; - sprintf(filename, "block/%s/device/model", rootbdev); - fd = openat(sysfd, filename, O_RDONLY); - f = fdopen(fd, "r"); - if (f) { - if (!fgets(model, 255, f)) - fprintf(stderr, "Error reading disk model for %s\n", rootbdev); - fclose(f); - } + snprintf(filename, sizeof(filename), "/sys/block/%s/device/model", rootbdev); + + r = read_one_line_file(filename, &model); + if (r < 0) + log_warning("Error reading disk model for %s: %m\n", rootbdev); } /* various utsname parameters */ - if (uname(&uts)) - fprintf(stderr, "Error getting uname info\n"); + r = uname(&uts); + if (r < 0) { + log_error("Error getting uname info\n"); + return -errno; + } /* date */ t = time(NULL); - strftime(date, sizeof(date), "%a, %d %b %Y %H:%M:%S %z", localtime(&t)); + r = strftime(date, sizeof(date), "%a, %d %b %Y %H:%M:%S %z", localtime(&t)); + assert_se(r > 0); /* CPU type */ - fd = openat(procfd, "cpuinfo", O_RDONLY); - f = fdopen(fd, "r"); - if (f) { - while (fgets(buf, 255, f)) { - if (strstr(buf, "model name")) { - strncpy(cpu, &buf[13], 255); - break; - } - } - fclose(f); + r = read_full_file("/proc/cpuinfo", &buf, NULL); + if (r < 0) + return log_error_errno(r, "Unable to read cpuinfo: %m\n"); + + cpu = strstr(buf, "model name"); + if (!cpu) { + log_error("Unable to read module name from cpuinfo.\n"); + return -ENOENT; } - svg("Bootchart for %s - %s\n", - uts.nodename, date); - svg("System: %s %s %s %s\n", - uts.sysname, uts.release, uts.version, uts.machine); - svg("CPU: %s\n", - cpu); - svg("Disk: %s\n", - model); - svg("Boot options: %s\n", - cmdline); - svg("Build: %s\n", - build); - svg("Log start time: %.03fs\n", log_start); - svg("Idle time: "); + cpu += 13; + c = strchr(cpu, '\n'); + if (c) + *c = '\0'; + + fprintf(of, "Bootchart for %s - %s\n", + uts.nodename, date); + fprintf(of, "System: %s %s %s %s\n", + uts.sysname, uts.release, uts.version, uts.machine); + fprintf(of, "CPU: %s\n", cpu); + fprintf(of, "Disk: %s\n", model); + fprintf(of, "Boot options: %s\n", cmdline); + fprintf(of, "Build: %s\n", build); + fprintf(of, "Log start time: %.03fs\n", log_start); + fprintf(of, "Idle time: "); if (idletime >= 0.0) - svg("%.03fs", idletime); + fprintf(of, "%.03fs", idletime); else - svg("Not detected"); - svg("\n"); - svg("Graph data: %.03f samples/sec, recorded %i total, dropped %i samples, %i processes, %i filtered\n", - hz, samples_len, overrun, pscount, pfiltered); -} + fprintf(of, "Not detected"); + + fprintf(of, "\n"); + fprintf(of, "Graph data: %.03f samples/sec, recorded %i total, dropped %i samples, %i processes, %i filtered\n", + arg_hz, arg_samples_len, overrun, pscount, pfiltered); + return 0; +} -static void svg_graph_box(int height) -{ +static void svg_graph_box(FILE *of, struct list_sample_data *head, int height, double graph_start) { double d = 0.0; int i = 0; + double finalsample = 0.0; + struct list_sample_data *sampledata_last; + + sampledata_last = head; + LIST_FOREACH_BEFORE(link, sampledata, head) { + sampledata_last = sampledata; + } + + finalsample = sampledata_last->sampletime; /* outside box, fill */ - svg("\n", - time_to_graph(0.0), - time_to_graph(sampletime[samples-1] - graph_start), - ps_to_graph(height)); + fprintf(of, "\n", + time_to_graph(0.0), + time_to_graph(finalsample - graph_start), + ps_to_graph(height)); - for (d = graph_start; d <= sampletime[samples-1]; - d += (scale_x < 2.0 ? 60.0 : scale_x < 10.0 ? 1.0 : 0.1)) { + for (d = graph_start; d <= finalsample; + d += (arg_scale_x < 2.0 ? 60.0 : arg_scale_x < 10.0 ? 1.0 : 0.1)) { /* lines for each second */ if (i % 50 == 0) - svg(" \n", - time_to_graph(d - graph_start), - time_to_graph(d - graph_start), - ps_to_graph(height)); + fprintf(of, " \n", + time_to_graph(d - graph_start), + time_to_graph(d - graph_start), + ps_to_graph(height)); else if (i % 10 == 0) - svg(" \n", - time_to_graph(d - graph_start), - time_to_graph(d - graph_start), - ps_to_graph(height)); + fprintf(of, " \n", + time_to_graph(d - graph_start), + time_to_graph(d - graph_start), + ps_to_graph(height)); else - svg(" \n", - time_to_graph(d - graph_start), - time_to_graph(d - graph_start), - ps_to_graph(height)); + fprintf(of, " \n", + time_to_graph(d - graph_start), + time_to_graph(d - graph_start), + ps_to_graph(height)); /* time label */ if (i % 10 == 0) - svg(" %.01fs\n", - time_to_graph(d - graph_start), - -5.0, - d - graph_start); + fprintf(of, " %.01fs\n", + time_to_graph(d - graph_start), + -5.0, d - graph_start); i++; } @@ -282,34 +291,46 @@ static char* xml_comment_encode(const char* name) { return enc_name; } -static void svg_pss_graph(void) -{ +static void svg_pss_graph(FILE *of, + struct list_sample_data *head, + struct ps_struct *ps_first, + double graph_start) { struct ps_struct *ps; int i; + struct list_sample_data *sampledata_last; - svg("\n\n\n"); + sampledata_last = head; + LIST_FOREACH_BEFORE(link, sampledata, head) { + sampledata_last = sampledata; + } - svg("\n Memory allocation - Pss\n"); + + fprintf(of, "\n\n\n"); + + fprintf(of, "\n Memory allocation - Pss\n"); /* vsize 1000 == 1000mb */ - svg_graph_box(100); + svg_graph_box(of, head, 100, graph_start); /* draw some hlines for usable memory sizes */ for (i = 100000; i < 1000000; i += 100000) { - svg(" \n", + fprintf(of, " \n", time_to_graph(.0), kb_to_graph(i), - time_to_graph(sampletime[samples-1] - graph_start), + time_to_graph(sampledata_last->sampletime - graph_start), kb_to_graph(i)); - svg(" %dM\n", - time_to_graph(sampletime[samples-1] - graph_start) + 5, - kb_to_graph(i), (1000000 - i) / 1000); + fprintf(of, " %dM\n", + time_to_graph(sampledata_last->sampletime - graph_start) + 5, + kb_to_graph(i), (1000000 - i) / 1000); } - svg("\n"); + fprintf(of, "\n"); /* now plot the graph itself */ - for (i = 1; i < samples ; i++) { + i = 1; + prev_sampledata = head; + LIST_FOREACH_BEFORE(link, sampledata, head) { int bottom; int top; + struct ps_sched_struct *cross_place; bottom = 0; top = 0; @@ -320,16 +341,32 @@ static void svg_pss_graph(void) ps = ps->next_ps; if (!ps) continue; - if (ps->sample[i].pss <= (100 * scale_y)) - top += ps->sample[i].pss; - }; - svg(" \n", - "rgb(64,64,64)", - time_to_graph(sampletime[i - 1] - graph_start), - kb_to_graph(1000000.0 - top), - time_to_graph(sampletime[i] - sampletime[i - 1]), - kb_to_graph(top - bottom)); + ps->sample = ps->first; + while (ps->sample->next) { + ps->sample = ps->sample->next; + if (ps->sample->sampledata == sampledata) + break; + } + if (ps->sample->sampledata == sampledata) { + if (ps->sample->pss <= (100 * arg_scale_y)) + top += ps->sample->pss; + break; + } + } + while (ps->sample->cross) { + cross_place = ps->sample->cross; + ps = ps->sample->cross->ps_new; + ps->sample = cross_place; + if (ps->sample->pss <= (100 * arg_scale_y)) + top += ps->sample->pss; + } + fprintf(of, " \n", + "rgb(64,64,64)", + time_to_graph(prev_sampledata->sampletime - graph_start), + kb_to_graph(1000000.0 - top), + time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), + kb_to_graph(top - bottom)); bottom = top; /* now plot the ones that are of significant size */ @@ -338,94 +375,175 @@ static void svg_pss_graph(void) ps = ps->next_ps; if (!ps) continue; + ps->sample = ps->first; + while (ps->sample->next) { + ps->sample = ps->sample->next; + if (ps->sample->sampledata == sampledata) + break; + } /* don't draw anything smaller than 2mb */ - if (ps->sample[i].pss > (100 * scale_y)) { - top = bottom + ps->sample[i].pss; - svg(" \n", - colorwheel[ps->pid % 12], - time_to_graph(sampletime[i - 1] - graph_start), - kb_to_graph(1000000.0 - top), - time_to_graph(sampletime[i] - sampletime[i - 1]), - kb_to_graph(top - bottom)); + if (ps->sample->sampledata != sampledata) + continue; + if (ps->sample->pss > (100 * arg_scale_y)) { + top = bottom + ps->sample->pss; + fprintf(of, " \n", + colorwheel[ps->pid % 12], + time_to_graph(prev_sampledata->sampletime - graph_start), + kb_to_graph(1000000.0 - top), + time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), + kb_to_graph(top - bottom)); bottom = top; } + break; } + + while ((cross_place = ps->sample->cross)) { + ps = ps->sample->cross->ps_new; + ps->sample = cross_place; + if (ps->sample->pss > (100 * arg_scale_y)) { + top = bottom + ps->sample->pss; + fprintf(of, " \n", + colorwheel[ps->pid % 12], + time_to_graph(prev_sampledata->sampletime - graph_start), + kb_to_graph(1000000.0 - top), + time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), + kb_to_graph(top - bottom)); + bottom = top; + } + } + + prev_sampledata = sampledata; + i++; } /* overlay all the text labels */ - for (i = 1; i < samples ; i++) { + i = 1; + LIST_FOREACH_BEFORE(link, sampledata, head) { int bottom; - int top; - - bottom = 0; - top = 0; + int top = 0; + struct ps_sched_struct *prev_sample; + struct ps_sched_struct *cross_place; /* put all the small pss blocks into the bottom */ - ps = ps_first; + ps = ps_first->next_ps; while (ps->next_ps) { ps = ps->next_ps; if (!ps) continue; - if (ps->sample[i].pss <= (100 * scale_y)) - top += ps->sample[i].pss; - }; + ps->sample = ps->first; + while (ps->sample->next) { + ps->sample = ps->sample->next; + if (ps->sample->sampledata == sampledata) + break; + } + + if (ps->sample->sampledata == sampledata) { + if (ps->sample->pss <= (100 * arg_scale_y)) + top += ps->sample->pss; + + break; + } + } + + while ((cross_place = ps->sample->cross)) { + ps = ps->sample->cross->ps_new; + ps->sample = cross_place; + if (ps->sample->pss <= (100 * arg_scale_y)) + top += ps->sample->pss; + } bottom = top; /* now plot the ones that are of significant size */ ps = ps_first; while (ps->next_ps) { + prev_sample = ps->sample; ps = ps->next_ps; if (!ps) continue; + ps->sample = ps->first; + while (ps->sample->next) { + prev_sample = ps->sample; + ps->sample = ps->sample->next; + if (ps->sample->sampledata == sampledata) + break; + } /* don't draw anything smaller than 2mb */ - if (ps->sample[i].pss > (100 * scale_y)) { - top = bottom + ps->sample[i].pss; + if (ps->sample->sampledata == sampledata) { + if (ps->sample->pss > (100 * arg_scale_y)) { + top = bottom + ps->sample->pss; + /* draw a label with the process / PID */ + if ((i == 1) || (prev_sample->pss <= (100 * arg_scale_y))) + fprintf(of, " %s [%i]\n", + time_to_graph(sampledata->sampletime - graph_start), + kb_to_graph(1000000.0 - bottom - ((top - bottom) / 2)), + ps->name, ps->pid); + bottom = top; + } + break; + } + } + while ((cross_place = ps->sample->cross)) { + ps = ps->sample->cross->ps_new; + ps->sample = cross_place; + prev_sample = ps->sample->prev; + if (ps->sample->pss > (100 * arg_scale_y)) { + top = bottom + ps->sample->pss; /* draw a label with the process / PID */ - if ((i == 1) || (ps->sample[i - 1].pss <= (100 * scale_y))) - svg(" %s [%i]\n", - time_to_graph(sampletime[i] - graph_start), - kb_to_graph(1000000.0 - bottom - ((top - bottom) / 2)), - ps->name, - ps->pid); + if ((i == 1) || (prev_sample->pss <= (100 * arg_scale_y))) + fprintf(of, " %s [%i]\n", + time_to_graph(sampledata->sampletime - graph_start), + kb_to_graph(1000000.0 - bottom - ((top - bottom) / 2)), + ps->name, ps->pid); bottom = top; } } + + i++; } /* debug output - full data dump */ - svg("\n\n\n"); + fprintf(of, "\n\n\n"); ps = ps_first; while (ps->next_ps) { - char _cleanup_free_*enc_name; + _cleanup_free_ char *enc_name = NULL; ps = ps->next_ps; if (!ps) continue; enc_name = xml_comment_encode(ps->name); - if(!enc_name) + if (!enc_name) continue; - svg("\n"); + + fprintf(of, " -->\n"); } } -static void svg_io_bi_bar(void) -{ +static void svg_io_bi_bar(FILE *of, + struct list_sample_data *head, + int n_samples, + double graph_start, + double interval) { + double max = 0.0; double range; int max_here = 0; int i; + int k; + struct list_sample_data *start_sampledata; + struct list_sample_data *stop_sampledata; - svg("\n"); - - svg("IO utilization - read\n"); + fprintf(of, "\n"); + fprintf(of, "IO utilization - read\n"); /* * calculate rounding range @@ -434,75 +552,112 @@ static void svg_io_bi_bar(void) * each poll. Applying a smoothing function loses some burst data, * so keep the smoothing range short. */ - range = 0.25 / (1.0 / hz); + range = 0.25 / (1.0 / arg_hz); if (range < 2.0) range = 2.0; /* no smoothing */ /* surrounding box */ - svg_graph_box(5); + svg_graph_box(of, head, 5, graph_start); /* find the max IO first */ - for (i = 1; i < samples; i++) { + i = 1; + LIST_FOREACH_BEFORE(link, sampledata, head) { int start; int stop; + int diff; double tot; - start = max(i - ((range / 2) - 1), 0); - stop = min(i + (range / 2), samples - 1); + start = MAX(i - ((range / 2) - 1), 0); + stop = MIN(i + (range / 2), n_samples - 1); + diff = (stop - start); + + start_sampledata = sampledata; + stop_sampledata = sampledata; + + for (k = 0; k < ((range/2) - 1) && start_sampledata->link_next; k++) + start_sampledata = start_sampledata->link_next; + + for (k = 0; k < (range/2) && stop_sampledata->link_prev; k++) + stop_sampledata = stop_sampledata->link_prev; + + tot = (double)(stop_sampledata->blockstat.bi - start_sampledata->blockstat.bi) / diff; - tot = (double)(blockstat[stop].bi - blockstat[start].bi) - / (stop - start); if (tot > max) { max = tot; max_here = i; } - tot = (double)(blockstat[stop].bo - blockstat[start].bo) - / (stop - start); + + tot = (double)(stop_sampledata->blockstat.bo - start_sampledata->blockstat.bo) / diff; + if (tot > max) max = tot; + + i++; } /* plot bi */ - for (i = 1; i < samples; i++) { + i = 1; + prev_sampledata = head; + LIST_FOREACH_BEFORE(link, sampledata, head) { int start; int stop; + int diff; double tot; - double pbi; + double pbi = 0; + + start = MAX(i - ((range / 2) - 1), 0); + stop = MIN(i + (range / 2), n_samples); + diff = (stop - start); - start = max(i - ((range / 2) - 1), 0); - stop = min(i + (range / 2), samples); + start_sampledata = sampledata; + stop_sampledata = sampledata; - tot = (double)(blockstat[stop].bi - blockstat[start].bi) - / (stop - start); - pbi = tot / max; + for (k = 0; k < ((range/2)-1) && start_sampledata->link_next; k++) + start_sampledata = start_sampledata->link_next; + + for (k = 0; k < (range/2) && stop_sampledata->link_prev; k++) + stop_sampledata = stop_sampledata->link_prev; + + tot = (double)(stop_sampledata->blockstat.bi - start_sampledata->blockstat.bi) / diff; + + if (max > 0) + pbi = tot / max; if (pbi > 0.001) - svg("\n", - time_to_graph(sampletime[i - 1] - graph_start), - (scale_y * 5) - (pbi * (scale_y * 5)), - time_to_graph(sampletime[i] - sampletime[i - 1]), - pbi * (scale_y * 5)); + fprintf(of, "\n", + time_to_graph(prev_sampledata->sampletime - graph_start), + (arg_scale_y * 5) - (pbi * (arg_scale_y * 5)), + time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), + pbi * (arg_scale_y * 5)); /* labels around highest value */ if (i == max_here) { - svg(" %0.2fmb/sec\n", - time_to_graph(sampletime[i] - graph_start) + 5, - ((scale_y * 5) - (pbi * (scale_y * 5))) + 15, - max / 1024.0 / (interval / 1000000000.0)); + fprintf(of, " %0.2fmb/sec\n", + time_to_graph(sampledata->sampletime - graph_start) + 5, + ((arg_scale_y * 5) - (pbi * (arg_scale_y * 5))) + 15, + max / 1024.0 / (interval / 1000000000.0)); } + + i++; + prev_sampledata = sampledata; } } -static void svg_io_bo_bar(void) -{ +static void svg_io_bo_bar(FILE *of, + struct list_sample_data *head, + int n_samples, + double graph_start, + double interval) { double max = 0.0; double range; int max_here = 0; int i; + int k; + struct list_sample_data *start_sampledata; + struct list_sample_data *stop_sampledata; - svg("\n"); - - svg("IO utilization - write\n"); + fprintf(of, "\n"); + fprintf(of, "IO utilization - write\n"); /* * calculate rounding range @@ -511,174 +666,215 @@ static void svg_io_bo_bar(void) * each poll. Applying a smoothing function loses some burst data, * so keep the smoothing range short. */ - range = 0.25 / (1.0 / hz); + range = 0.25 / (1.0 / arg_hz); if (range < 2.0) range = 2.0; /* no smoothing */ /* surrounding box */ - svg_graph_box(5); + svg_graph_box(of, head, 5, graph_start); /* find the max IO first */ - for (i = 1; i < samples; i++) { + i = 0; + LIST_FOREACH_BEFORE(link, sampledata, head) { int start; int stop; + int diff; double tot; - start = max(i - ((range / 2) - 1), 0); - stop = min(i + (range / 2), samples - 1); + start = MAX(i - ((range / 2) - 1), 0); + stop = MIN(i + (range / 2), n_samples - 1); + diff = (stop - start); + + start_sampledata = sampledata; + stop_sampledata = sampledata; + + for (k = 0; k < (range/2) - 1 && start_sampledata->link_next; k++) + start_sampledata = start_sampledata->link_next; - tot = (double)(blockstat[stop].bi - blockstat[start].bi) - / (stop - start); + for (k = 0; k < (range/2) && stop_sampledata->link_prev; k++) + stop_sampledata = stop_sampledata->link_prev; + + tot = (double)(stop_sampledata->blockstat.bi - start_sampledata->blockstat.bi) / diff; if (tot > max) max = tot; - tot = (double)(blockstat[stop].bo - blockstat[start].bo) - / (stop - start); + + tot = (double)(stop_sampledata->blockstat.bo - start_sampledata->blockstat.bo) / diff; if (tot > max) { max = tot; max_here = i; } + + i++; } /* plot bo */ - for (i = 1; i < samples; i++) { - int start; - int stop; - double tot; - double pbo; + prev_sampledata = head; + i = 1; + + LIST_FOREACH_BEFORE(link, sampledata, head) { + int start, stop, diff; + double tot, pbo; + + pbo = 0; + + start = MAX(i - ((range / 2) - 1), 0); + stop = MIN(i + (range / 2), n_samples); + diff = (stop - start); + + start_sampledata = sampledata; + stop_sampledata = sampledata; + + for (k = 0; k < ((range/2)-1) && start_sampledata->link_next; k++) + start_sampledata = start_sampledata->link_next; + + for (k = 0; k < (range/2) && stop_sampledata->link_prev; k++) + stop_sampledata = stop_sampledata->link_prev; - start = max(i - ((range / 2) - 1), 0); - stop = min(i + (range / 2), samples); + tot = (double)(stop_sampledata->blockstat.bo - start_sampledata->blockstat.bo) + / diff; - tot = (double)(blockstat[stop].bo - blockstat[start].bo) - / (stop - start); - pbo = tot / max; + if (max > 0) + pbo = tot / max; if (pbo > 0.001) - svg("\n", - time_to_graph(sampletime[i - 1] - graph_start), - (scale_y * 5) - (pbo * (scale_y * 5)), - time_to_graph(sampletime[i] - sampletime[i - 1]), - pbo * (scale_y * 5)); + fprintf(of, "\n", + time_to_graph(prev_sampledata->sampletime - graph_start), + (arg_scale_y * 5) - (pbo * (arg_scale_y * 5)), + time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), + pbo * (arg_scale_y * 5)); /* labels around highest bo value */ if (i == max_here) { - svg(" %0.2fmb/sec\n", - time_to_graph(sampletime[i] - graph_start) + 5, - ((scale_y * 5) - (pbo * (scale_y * 5))), - max / 1024.0 / (interval / 1000000000.0)); + fprintf(of, " %0.2fmb/sec\n", + time_to_graph(sampledata->sampletime - graph_start) + 5, + ((arg_scale_y * 5) - (pbo * (arg_scale_y * 5))), + max / 1024.0 / (interval / 1000000000.0)); } + + i++; + prev_sampledata = sampledata; } } +static void svg_cpu_bar(FILE *of, struct list_sample_data *head, int n_cpus, int cpu_num, double graph_start) { -static void svg_cpu_bar(void) -{ - int i; + fprintf(of, "\n"); - svg("\n"); + if (cpu_num < 0) + fprintf(of, "CPU[overall] utilization\n"); + else + fprintf(of, "CPU[%d] utilization\n", cpu_num); - svg("CPU utilization\n"); /* surrounding box */ - svg_graph_box(5); + svg_graph_box(of, head, 5, graph_start); /* bars for each sample, proportional to the CPU util. */ - for (i = 1; i < samples; i++) { + prev_sampledata = head; + LIST_FOREACH_BEFORE(link, sampledata, head) { int c; double trt; double ptrt; ptrt = trt = 0.0; - for (c = 0; c < cpus; c++) - trt += cpustat[c].sample[i].runtime - cpustat[c].sample[i - 1].runtime; + if (cpu_num < 0) + for (c = 0; c < n_cpus; c++) + trt += sampledata->runtime[c] - prev_sampledata->runtime[c]; + else + trt = sampledata->runtime[cpu_num] - prev_sampledata->runtime[cpu_num]; trt = trt / 1000000000.0; - trt = trt / (double)cpus; + if (cpu_num < 0) + trt = trt / (double)n_cpus; if (trt > 0.0) - ptrt = trt / (sampletime[i] - sampletime[i - 1]); + ptrt = trt / (sampledata->sampletime - prev_sampledata->sampletime); if (ptrt > 1.0) ptrt = 1.0; - if (ptrt > 0.001) { - svg("\n", - time_to_graph(sampletime[i - 1] - graph_start), - (scale_y * 5) - (ptrt * (scale_y * 5)), - time_to_graph(sampletime[i] - sampletime[i - 1]), - ptrt * (scale_y * 5)); - } + if (ptrt > 0.001) + fprintf(of, "\n", + time_to_graph(prev_sampledata->sampletime - graph_start), + (arg_scale_y * 5) - (ptrt * (arg_scale_y * 5)), + time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), + ptrt * (arg_scale_y * 5)); + + prev_sampledata = sampledata; } } -static void svg_wait_bar(void) -{ - int i; +static void svg_wait_bar(FILE *of, struct list_sample_data *head, int n_cpus, int cpu_num, double graph_start) { - svg("\n"); + fprintf(of, "\n"); - svg("CPU wait\n"); + if (cpu_num < 0) + fprintf(of, "CPU[overall] wait\n"); + else + fprintf(of, "CPU[%d] wait\n", cpu_num); /* surrounding box */ - svg_graph_box(5); + svg_graph_box(of, head, 5, graph_start); /* bars for each sample, proportional to the CPU util. */ - for (i = 1; i < samples; i++) { + prev_sampledata = head; + LIST_FOREACH_BEFORE(link, sampledata, head) { int c; double twt; double ptwt; ptwt = twt = 0.0; - for (c = 0; c < cpus; c++) - twt += cpustat[c].sample[i].waittime - cpustat[c].sample[i - 1].waittime; + if (cpu_num < 0) + for (c = 0; c < n_cpus; c++) + twt += sampledata->waittime[c] - prev_sampledata->waittime[c]; + else + twt = sampledata->waittime[cpu_num] - prev_sampledata->waittime[cpu_num]; twt = twt / 1000000000.0; - twt = twt / (double)cpus; + if (cpu_num < 0) + twt = twt / (double)n_cpus; if (twt > 0.0) - ptwt = twt / (sampletime[i] - sampletime[i - 1]); + ptwt = twt / (sampledata->sampletime - prev_sampledata->sampletime); if (ptwt > 1.0) ptwt = 1.0; - if (ptwt > 0.001) { - svg("\n", - time_to_graph(sampletime[i - 1] - graph_start), - ((scale_y * 5) - (ptwt * (scale_y * 5))), - time_to_graph(sampletime[i] - sampletime[i - 1]), - ptwt * (scale_y * 5)); - } + if (ptwt > 0.001) + fprintf(of, "\n", + time_to_graph(prev_sampledata->sampletime - graph_start), + ((arg_scale_y * 5) - (ptwt * (arg_scale_y * 5))), + time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), + ptwt * (arg_scale_y * 5)); + + prev_sampledata = sampledata; } } +static void svg_entropy_bar(FILE *of, struct list_sample_data *head, double graph_start) { -static void svg_entropy_bar(void) -{ - int i; + fprintf(of, "\n"); - svg("\n"); - - svg("Entropy pool size\n"); + fprintf(of, "Entropy pool size\n"); /* surrounding box */ - svg_graph_box(5); + svg_graph_box(of, head, 5, graph_start); /* bars for each sample, scale 0-4096 */ - for (i = 1; i < samples; i++) { - /* svg("\n", sampletime[i], entropy_avail[i]); */ - svg("\n", - time_to_graph(sampletime[i - 1] - graph_start), - ((scale_y * 5) - ((entropy_avail[i] / 4096.) * (scale_y * 5))), - time_to_graph(sampletime[i] - sampletime[i - 1]), - (entropy_avail[i] / 4096.) * (scale_y * 5)); + prev_sampledata = head; + LIST_FOREACH_BEFORE(link, sampledata, head) { + fprintf(of, "\n", + time_to_graph(prev_sampledata->sampletime - graph_start), + ((arg_scale_y * 5) - ((sampledata->entropy_avail / 4096.) * (arg_scale_y * 5))), + time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), + (sampledata->entropy_avail / 4096.) * (arg_scale_y * 5)); + prev_sampledata = sampledata; } } - -static struct ps_struct *get_next_ps(struct ps_struct *ps) -{ +static struct ps_struct *get_next_ps(struct ps_struct *ps, struct ps_struct *ps_first) { /* * walk the list of processes and return the next one to be * painted @@ -696,9 +892,9 @@ static struct ps_struct *get_next_ps(struct ps_struct *ps) /* go back for parent siblings */ while (1) { - if (ps->parent) - if (ps->parent->next) - return ps->parent->next; + if (ps->parent && ps->parent->next) + return ps->parent->next; + ps = ps->parent; if (!ps) return ps; @@ -707,48 +903,43 @@ static struct ps_struct *get_next_ps(struct ps_struct *ps) return NULL; } - -static int ps_filter(struct ps_struct *ps) -{ - if (!filter) - return 0; +static bool ps_filter(struct ps_struct *ps) { + if (!arg_filter) + return false; /* can't draw data when there is only 1 sample (need start + stop) */ if (ps->first == ps->last) - return -1; + return true; /* don't filter kthreadd */ if (ps->pid == 2) - return 0; + return false; /* drop stuff that doesn't use any real CPU time */ if (ps->total <= 0.001) - return -1; + return true; return 0; } - -static void svg_do_initcall(int count_only) -{ - FILE _cleanup_pclose_ *f = NULL; +static void svg_do_initcall(FILE *of, struct list_sample_data *head, int count_only, double graph_start) { + _cleanup_pclose_ FILE *f = NULL; double t; char func[256]; int ret; int usecs; /* can't plot initcall when disabled or in relative mode */ - if (!initcall || relative) { + if (!arg_initcall || arg_relative) { kcount = 0; return; } if (!count_only) { - svg("\n"); - - svg("Kernel init threads\n"); + fprintf(of, "\n"); + fprintf(of, "Kernel init threads\n"); /* surrounding box */ - svg_graph_box(kcount); + svg_graph_box(of, head, kcount, graph_start); } kcount = 0; @@ -794,105 +985,113 @@ static void svg_do_initcall(int count_only) continue; } - svg("\n", - func, t, usecs, ret); + fprintf(of, "\n", + func, t, usecs, ret); if (usecs < 1000) continue; /* rect */ - svg(" \n", - time_to_graph(t - (usecs / 1000000.0)), - ps_to_graph(kcount), - time_to_graph(usecs / 1000000.0), - ps_to_graph(1)); + fprintf(of, " \n", + time_to_graph(t - (usecs / 1000000.0)), + ps_to_graph(kcount), + time_to_graph(usecs / 1000000.0), + ps_to_graph(1)); /* label */ - svg(" %s %.03fs\n", - time_to_graph(t - (usecs / 1000000.0)) + 5, - ps_to_graph(kcount) + 15, - func, - usecs / 1000000.0); + fprintf(of, " %s %.03fs\n", + time_to_graph(t - (usecs / 1000000.0)) + 5, + ps_to_graph(kcount) + 15, + func, usecs / 1000000.0); kcount++; } } +static void svg_ps_bars(FILE *of, + struct list_sample_data *head, + int n_samples, + int n_cpus, + struct ps_struct *ps_first, + double graph_start, + double interval) { -static void svg_ps_bars(void) -{ struct ps_struct *ps; int i = 0; int j = 0; - int w; int pid; + double w = 0.0; - svg("\n"); - - svg("Processes\n"); + fprintf(of, "\n"); + fprintf(of, "Processes\n"); /* surrounding box */ - svg_graph_box(pcount); + svg_graph_box(of, head, pcount, graph_start); /* pass 2 - ps boxes */ ps = ps_first; - while ((ps = get_next_ps(ps))) { - char _cleanup_free_*enc_name; - + while ((ps = get_next_ps(ps, ps_first))) { + _cleanup_free_ char *enc_name = NULL, *escaped = NULL; + double endtime; double starttime; int t; - if (!ps) - continue; + if (!utf8_is_printable(ps->name, strlen(ps->name))) + escaped = utf8_escape_non_printable(ps->name); - enc_name = xml_comment_encode(ps->name); - if(!enc_name) + enc_name = xml_comment_encode(escaped ? escaped : ps->name); + if (!enc_name) continue; /* leave some trace of what we actually filtered etc. */ - svg("\n", enc_name, ps->pid, - ps->ppid, ps->total); + fprintf(of, "\n", enc_name, ps->pid, + ps->ppid, ps->total); - /* it would be nice if we could use exec_start from /proc/pid/sched, - * but it's unreliable and gives bogus numbers */ - starttime = sampletime[ps->first]; + starttime = ps->first->sampledata->sampletime; if (!ps_filter(ps)) { /* remember where _to_ our children need to draw a line */ ps->pos_x = time_to_graph(starttime - graph_start); ps->pos_y = ps_to_graph(j+1); /* bottom left corner */ - } else { + } else if (ps->parent){ /* hook children to our parent coords instead */ ps->pos_x = ps->parent->pos_x; ps->pos_y = ps->parent->pos_y; /* if this is the last child, we might still need to draw a connecting line */ if ((!ps->next) && (ps->parent)) - svg(" \n", - ps->parent->pos_x, - ps_to_graph(j-1) + 10.0, /* whee, use the last value here */ - ps->parent->pos_x, - ps->parent->pos_y); + fprintf(of, " \n", + ps->parent->pos_x, + ps_to_graph(j-1) + 10.0, /* whee, use the last value here */ + ps->parent->pos_x, + ps->parent->pos_y); continue; } - svg(" \n", - time_to_graph(starttime - graph_start), - ps_to_graph(j), - time_to_graph(sampletime[ps->last] - starttime), - ps_to_graph(1)); + endtime = ps->last->sampledata->sampletime; + fprintf(of, " \n", + time_to_graph(starttime - graph_start), + ps_to_graph(j), + time_to_graph(ps->last->sampledata->sampletime - starttime), + ps_to_graph(1)); /* paint cpu load over these */ - for (t = ps->first + 1; t < ps->last; t++) { + ps->sample = ps->first; + t = 1; + while (ps->sample->next) { double rt, prt; double wt, wrt; + struct ps_sched_struct *prev; + + prev = ps->sample; + ps->sample = ps->sample->next; /* calculate over interval */ - rt = ps->sample[t].runtime - ps->sample[t-1].runtime; - wt = ps->sample[t].waittime - ps->sample[t-1].waittime; + rt = ps->sample->runtime - prev->runtime; + wt = ps->sample->waittime - prev->waittime; - prt = (rt / 1000000000) / (sampletime[t] - sampletime[t-1]); - wrt = (wt / 1000000000) / (sampletime[t] - sampletime[t-1]); + prt = (rt / 1000000000) / (ps->sample->sampledata->sampletime - prev->sampledata->sampletime); + wrt = (wt / 1000000000) / (ps->sample->sampledata->sampletime - prev->sampledata->sampletime); /* this can happen if timekeeping isn't accurate enough */ if (prt > 1.0) @@ -903,55 +1102,57 @@ static void svg_ps_bars(void) if ((prt < 0.1) && (wrt < 0.1)) /* =~ 26 (color threshold) */ continue; - svg(" \n", - time_to_graph(sampletime[t - 1] - graph_start), - ps_to_graph(j), - time_to_graph(sampletime[t] - sampletime[t - 1]), - ps_to_graph(wrt)); + fprintf(of, " \n", + time_to_graph(prev->sampledata->sampletime - graph_start), + ps_to_graph(j), + time_to_graph(ps->sample->sampledata->sampletime - prev->sampledata->sampletime), + ps_to_graph(wrt)); /* draw cpu over wait - TODO figure out how/why run + wait > interval */ - svg(" \n", - time_to_graph(sampletime[t - 1] - graph_start), - ps_to_graph(j + (1.0 - prt)), - time_to_graph(sampletime[t] - sampletime[t - 1]), - ps_to_graph(prt)); + fprintf(of, " \n", + time_to_graph(prev->sampledata->sampletime - graph_start), + ps_to_graph(j + (1.0 - prt)), + time_to_graph(ps->sample->sampledata->sampletime - prev->sampledata->sampletime), + ps_to_graph(prt)); + t++; } /* determine where to display the process name */ - if (sampletime[ps->last] - sampletime[ps->first] < 1.5) + if ((endtime - starttime) < 1.5) /* too small to fit label inside the box */ - w = ps->last; + w = endtime; else - w = ps->first; + w = starttime; /* text label of process name */ - svg(" %s [%i]%.03fs\n", - time_to_graph(sampletime[w] - graph_start) + 5.0, - ps_to_graph(j) + 14.0, - ps->name, - ps->pid, - (ps->sample[ps->last].runtime - ps->sample[ps->first].runtime) / 1000000000.0); + fprintf(of, " %s [%i]%.03fs %s\n", + time_to_graph(w - graph_start) + 5.0, + ps_to_graph(j) + 14.0, + escaped ? escaped : ps->name, + ps->pid, + (ps->last->runtime - ps->first->runtime) / 1000000000.0, + arg_show_cgroup ? ps->cgroup : ""); /* paint lines to the parent process */ if (ps->parent) { /* horizontal part */ - svg(" \n", - time_to_graph(starttime - graph_start), - ps_to_graph(j) + 10.0, - ps->parent->pos_x, - ps_to_graph(j) + 10.0); + fprintf(of, " \n", + time_to_graph(starttime - graph_start), + ps_to_graph(j) + 10.0, + ps->parent->pos_x, + ps_to_graph(j) + 10.0); /* one vertical line connecting all the horizontal ones up */ if (!ps->next) - svg(" \n", - ps->parent->pos_x, - ps_to_graph(j) + 10.0, - ps->parent->pos_x, - ps->parent->pos_y); + fprintf(of, " \n", + ps->parent->pos_x, + ps_to_graph(j) + 10.0, + ps->parent->pos_x, + ps->parent->pos_y); } j++; /* count boxes */ - svg("\n"); + fprintf(of, "\n"); } /* last pass - determine when idle */ @@ -959,6 +1160,7 @@ static void svg_ps_bars(void) /* make sure we start counting from the point where we actually have * data: assume that bootchart's first sample is when data started */ + ps = ps_first; while (ps->next_ps) { ps = ps->next_ps; @@ -966,17 +1168,28 @@ static void svg_ps_bars(void) break; } - for (i = ps->first; i < samples - (hz / 2); i++) { + /* need to know last node first */ + ps->sample = ps->first; + i = ps->sample->next->sampledata->counter; + + while (ps->sample->next && i<(n_samples-(arg_hz/2))) { double crt; double brt; int c; + int ii; + struct ps_sched_struct *sample_hz; + + ps->sample = ps->sample->next; + sample_hz = ps->sample; + for (ii = 0; (ii < (int)arg_hz/2) && sample_hz->next; ii++) + sample_hz = sample_hz->next; /* subtract bootchart cpu utilization from total */ crt = 0.0; - for (c = 0; c < cpus; c++) - crt += cpustat[c].sample[i + ((int)hz / 2)].runtime - cpustat[c].sample[i].runtime; - brt = ps->sample[i + ((int)hz / 2)].runtime - ps->sample[i].runtime; + for (c = 0; c < n_cpus; c++) + crt += sample_hz->sampledata->runtime[c] - ps->sample->sampledata->runtime[c]; + brt = sample_hz->runtime - ps->sample->runtime; /* * our definition of "idle": * @@ -984,38 +1197,36 @@ static void svg_ps_bars(void) * defaults to 4.0%, which experimentally, is where atom idles */ if ((crt - brt) < (interval / 2.0)) { - idletime = sampletime[i] - graph_start; - svg("\n\n", - idletime); - svg("\n", - time_to_graph(idletime), - -scale_y, - time_to_graph(idletime), - ps_to_graph(pcount) + scale_y); - svg("%.01fs\n", - time_to_graph(idletime) + 5.0, - ps_to_graph(pcount) + scale_y, - idletime); + idletime = ps->sample->sampledata->sampletime - graph_start; + fprintf(of, "\n\n", idletime); + fprintf(of, "\n", + time_to_graph(idletime), + -arg_scale_y, + time_to_graph(idletime), + ps_to_graph(pcount) + arg_scale_y); + fprintf(of, "%.01fs\n", + time_to_graph(idletime) + 5.0, + ps_to_graph(pcount) + arg_scale_y, + idletime); break; } + + i++; } } - -static void svg_top_ten_cpu(void) -{ +static void svg_top_ten_cpu(FILE *of, struct ps_struct *ps_first) { struct ps_struct *top[10]; - struct ps_struct emptyps; + struct ps_struct emptyps = {}; struct ps_struct *ps; int n, m; - memset(&emptyps, 0, sizeof(struct ps_struct)); - for (n=0; n < 10; n++) + for (n = 0; n < (int) ELEMENTSOF(top); n++) top[n] = &emptyps; /* walk all ps's and setup ptrs */ ps = ps_first; - while ((ps = get_next_ps(ps))) { + while ((ps = get_next_ps(ps, ps_first))) { for (n = 0; n < 10; n++) { if (ps->total <= top[n]->total) continue; @@ -1027,33 +1238,31 @@ static void svg_top_ten_cpu(void) } } - svg("Top CPU consumers:\n"); + fprintf(of, "Top CPU consumers:\n"); for (n = 0; n < 10; n++) - svg("%3.03fs - %s [%d]\n", - 20 + (n * 13), - top[n]->total, - top[n]->name, - top[n]->pid); + fprintf(of, "%3.03fs - %s [%d]\n", + 20 + (n * 13), + top[n]->total, + top[n]->name, + top[n]->pid); } - -static void svg_top_ten_pss(void) -{ +static void svg_top_ten_pss(FILE *of, struct ps_struct *ps_first) { struct ps_struct *top[10]; - struct ps_struct emptyps; + struct ps_struct emptyps = {}; struct ps_struct *ps; int n, m; - memset(&emptyps, 0, sizeof(struct ps_struct)); - for (n=0; n < 10; n++) + for (n = 0; n < (int) ELEMENTSOF(top); n++) top[n] = &emptyps; /* walk all ps's and setup ptrs */ ps = ps_first; - while ((ps = get_next_ps(ps))) { + while ((ps = get_next_ps(ps, ps_first))) { for (n = 0; n < 10; n++) { if (ps->pss_max <= top[n]->pss_max) continue; + /* cascade insert */ for (m = 9; m > n; m--) top[m] = top[m-1]; @@ -1062,92 +1271,113 @@ static void svg_top_ten_pss(void) } } - svg("Top PSS consumers:\n"); + fprintf(of, "Top PSS consumers:\n"); for (n = 0; n < 10; n++) - svg("%dK - %s [%d]\n", - 20 + (n * 13), - top[n]->pss_max, - top[n]->name, - top[n]->pid); + fprintf(of, "%dK - %s [%d]\n", + 20 + (n * 13), + top[n]->pss_max, + top[n]->name, + top[n]->pid); } +int svg_do(FILE *of, + const char *build, + struct list_sample_data *head, + struct ps_struct *ps_first, + int n_samples, + int pscount, + int n_cpus, + double graph_start, + double log_start, + double interval, + int overrun) { -void svg_do(const char *build) -{ struct ps_struct *ps; - - memset(&str, 0, sizeof(str)); + double offset = 7; + int r, c; ps = ps_first; /* count initcall thread count first */ - svg_do_initcall(1); - ksize = (kcount ? ps_to_graph(kcount) + (scale_y * 2) : 0); + svg_do_initcall(of, head, 1, graph_start); + ksize = kcount ? ps_to_graph(kcount) + (arg_scale_y * 2) : 0; /* then count processes */ - while ((ps = get_next_ps(ps))) { + while ((ps = get_next_ps(ps, ps_first))) { if (!ps_filter(ps)) pcount++; else pfiltered++; } - psize = ps_to_graph(pcount) + (scale_y * 2); + psize = ps_to_graph(pcount) + (arg_scale_y * 2); - esize = (entropy ? scale_y * 7 : 0); + esize = (arg_entropy ? arg_scale_y * 7 : 0); /* after this, we can draw the header with proper sizing */ - svg_header(); - - svg("\n"); - svg_io_bi_bar(); - svg("\n\n"); - - svg("\n", 400.0 + (scale_y * 7.0)); - svg_io_bo_bar(); - svg("\n\n"); - - svg("\n", 400.0 + (scale_y * 14.0)); - svg_cpu_bar(); - svg("\n\n"); - - svg("\n", 400.0 + (scale_y * 21.0)); - svg_wait_bar(); - svg("\n\n"); + svg_header(of, head, graph_start); + fprintf(of, "\n\n"); + + fprintf(of, "\n"); + svg_io_bi_bar(of, head, n_samples, graph_start, interval); + fprintf(of, "\n\n"); + + fprintf(of, "\n", 400.0 + (arg_scale_y * offset)); + svg_io_bo_bar(of, head, n_samples, graph_start, interval); + fprintf(of, "\n\n"); + + for (c = -1; c < (arg_percpu ? n_cpus : 0); c++) { + offset += 7; + fprintf(of, "\n", 400.0 + (arg_scale_y * offset)); + svg_cpu_bar(of, head, n_cpus, c, graph_start); + fprintf(of, "\n\n"); + + offset += 7; + fprintf(of, "\n", 400.0 + (arg_scale_y * offset)); + svg_wait_bar(of, head, n_cpus, c, graph_start); + fprintf(of, "\n\n"); + } if (kcount) { - svg("\n", 400.0 + (scale_y * 28.0)); - svg_do_initcall(0); - svg("\n\n"); + offset += 7; + fprintf(of, "\n", 400.0 + (arg_scale_y * offset)); + svg_do_initcall(of, head, 0, graph_start); + fprintf(of, "\n\n"); } - svg("\n", 400.0 + (scale_y * 28.0) + ksize); - svg_ps_bars(); - svg("\n\n"); + offset += 7; + fprintf(of, "\n", 400.0 + (arg_scale_y * offset) + ksize); + svg_ps_bars(of, head, n_samples, n_cpus, ps_first, graph_start, interval); + fprintf(of, "\n\n"); + + fprintf(of, "\n"); + r = svg_title(of, build, pscount, log_start, overrun); + fprintf(of, "\n\n"); - svg("\n"); - svg_title(build); - svg("\n\n"); + if (r < 0) + return r; - svg("\n"); - svg_top_ten_cpu(); - svg("\n\n"); + fprintf(of, "\n"); + svg_top_ten_cpu(of, ps_first); + fprintf(of, "\n\n"); - if (entropy) { - svg("\n", 400.0 + (scale_y * 28.0) + ksize + psize); - svg_entropy_bar(); - svg("\n\n"); + if (arg_entropy) { + fprintf(of, "\n", 400.0 + (arg_scale_y * offset) + ksize + psize); + svg_entropy_bar(of, head, graph_start); + fprintf(of, "\n\n"); } - if (pss) { - svg("\n", 400.0 + (scale_y * 28.0) + ksize + psize + esize); - svg_pss_graph(); - svg("\n\n"); + if (arg_pss) { + fprintf(of, "\n", 400.0 + (arg_scale_y * offset) + ksize + psize + esize); + svg_pss_graph(of, head, ps_first, graph_start); + fprintf(of, "\n\n"); - svg("\n"); - svg_top_ten_pss(); - svg("\n\n"); + fprintf(of, "\n"); + svg_top_ten_pss(of, ps_first); + fprintf(of, "\n\n"); } - /* svg footer */ - svg("\n\n"); + /* fprintf footer */ + fprintf(of, "\n\n"); + + return 0; }