]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/bootchart/svg.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bootchart: check return of strftime
[thirdparty/systemd.git] / src / bootchart / svg.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright (C) 2009-2013 Intel Corporation
7
8 Authors:
9 Auke Kok <auke-jan.h.kok@intel.com>
10
11 systemd is free software; you can redistribute it and/or modify it
12 under the terms of the GNU Lesser General Public License as published by
13 the Free Software Foundation; either version 2.1 of the License, or
14 (at your option) any later version.
15
16 systemd is distributed in the hope that it will be useful, but
17 WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 Lesser General Public License for more details.
20
21 You should have received a copy of the GNU Lesser General Public License
22 along with systemd; If not, see <http://www.gnu.org/licenses/>.
23 ***/
24
25 #include <stdio.h>
26 #include <stdarg.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <time.h>
30 #include <limits.h>
31 #include <unistd.h>
32 #include <sys/utsname.h>
33 #include <sys/stat.h>
34 #include <fcntl.h>
35
36 #include "util.h"
37 #include "macro.h"
38 #include "store.h"
39 #include "svg.h"
40 #include "bootchart.h"
41 #include "list.h"
42
43 #define time_to_graph(t) ((t) * arg_scale_x)
44 #define ps_to_graph(n) ((n) * arg_scale_y)
45 #define kb_to_graph(m) ((m) * arg_scale_y * 0.0001)
46 #define to_color(n) (192.0 - ((n) * 192.0))
47
48 static char str[8092];
49
50 #define svg(a...) do { snprintf(str, 8092, ## a); fputs(str, of); fflush(of); } while (0)
51
52 static const char * const colorwheel[12] = {
53 "rgb(255,32,32)", // red
54 "rgb(32,192,192)", // cyan
55 "rgb(255,128,32)", // orange
56 "rgb(128,32,192)", // blue-violet
57 "rgb(255,255,32)", // yellow
58 "rgb(192,32,128)", // red-violet
59 "rgb(32,255,32)", // green
60 "rgb(255,64,32)", // red-orange
61 "rgb(32,32,255)", // blue
62 "rgb(255,192,32)", // yellow-orange
63 "rgb(192,32,192)", // violet
64 "rgb(32,192,32)" // yellow-green
65 };
66
67 static double idletime = -1.0;
68 static int pfiltered = 0;
69 static int pcount = 0;
70 static int kcount = 0;
71 static double psize = 0;
72 static double ksize = 0;
73 static double esize = 0;
74 static struct list_sample_data *sampledata;
75 static struct list_sample_data *prev_sampledata;
76 extern struct list_sample_data *head;
77
78 static void svg_header(void) {
79 double w;
80 double h;
81 struct list_sample_data *sampledata_last;
82
83 assert(head);
84
85 sampledata = head;
86 LIST_FIND_TAIL(link, sampledata, head);
87 sampledata_last = head;
88 LIST_FOREACH_BEFORE(link, sampledata, head) {
89 sampledata_last = sampledata;
90 }
91
92 /* min width is about 1600px due to the label */
93 w = 150.0 + 10.0 + time_to_graph(sampledata_last->sampletime - graph_start);
94 w = ((w < 1600.0) ? 1600.0 : w);
95
96 /* height is variable based on pss, psize, ksize */
97 h = 400.0 + (arg_scale_y * 30.0) /* base graphs and title */
98 + (arg_pss ? (100.0 * arg_scale_y) + (arg_scale_y * 7.0) : 0.0) /* pss estimate */
99 + psize + ksize + esize;
100
101 svg("<?xml version=\"1.0\" standalone=\"no\"?>\n");
102 svg("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" ");
103 svg("\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n");
104
105 //svg("<g transform=\"translate(10,%d)\">\n", 1000 + 150 + (pcount * 20));
106 svg("<svg width=\"%.0fpx\" height=\"%.0fpx\" version=\"1.1\" ",
107 w, h);
108 svg("xmlns=\"http://www.w3.org/2000/svg\">\n\n");
109
110 /* write some basic info as a comment, including some help */
111 svg("<!-- This file is a bootchart SVG file. It is best rendered in a browser -->\n");
112 svg("<!-- such as Chrome, Chromium, or Firefox. Other applications that -->\n");
113 svg("<!-- render these files properly but more slowly are ImageMagick, gimp, -->\n");
114 svg("<!-- inkscape, etc. To display the files on your system, just point -->\n");
115 svg("<!-- your browser to file:///run/log/ and click. This bootchart was -->\n\n");
116
117 svg("<!-- generated by bootchart version %s, running with options: -->\n", VERSION);
118 svg("<!-- hz=\"%f\" n=\"%d\" -->\n", arg_hz, arg_samples_len);
119 svg("<!-- x=\"%f\" y=\"%f\" -->\n", arg_scale_x, arg_scale_y);
120 svg("<!-- rel=\"%d\" f=\"%d\" -->\n", arg_relative, arg_filter);
121 svg("<!-- p=\"%d\" e=\"%d\" -->\n", arg_pss, arg_entropy);
122 svg("<!-- o=\"%s\" i=\"%s\" -->\n\n", arg_output_path, arg_init_path);
123
124 /* style sheet */
125 svg("<defs>\n <style type=\"text/css\">\n <![CDATA[\n");
126
127 svg(" rect { stroke-width: 1; }\n");
128 svg(" rect.bg { fill: rgb(255,255,255); }\n");
129 svg(" rect.cpu { fill: rgb(64,64,240); stroke-width: 0; fill-opacity: 0.7; }\n");
130 svg(" rect.wait { fill: rgb(240,240,0); stroke-width: 0; fill-opacity: 0.7; }\n");
131 svg(" rect.bi { fill: rgb(240,128,128); stroke-width: 0; fill-opacity: 0.7; }\n");
132 svg(" rect.bo { fill: rgb(192,64,64); stroke-width: 0; fill-opacity: 0.7; }\n");
133 svg(" rect.ps { fill: rgb(192,192,192); stroke: rgb(128,128,128); fill-opacity: 0.7; }\n");
134 svg(" rect.krnl { fill: rgb(240,240,0); stroke: rgb(128,128,128); fill-opacity: 0.7; }\n");
135 svg(" rect.box { fill: rgb(240,240,240); stroke: rgb(192,192,192); }\n");
136 svg(" rect.clrw { stroke-width: 0; fill-opacity: 0.7;}\n");
137 svg(" line { stroke: rgb(64,64,64); stroke-width: 1; }\n");
138 svg("// line.sec1 { }\n");
139 svg(" line.sec5 { stroke-width: 2; }\n");
140 svg(" line.sec01 { stroke: rgb(224,224,224); stroke-width: 1; }\n");
141 svg(" line.dot { stroke-dasharray: 2 4; }\n");
142 svg(" line.idle { stroke: rgb(64,64,64); stroke-dasharray: 10 6; stroke-opacity: 0.7; }\n");
143
144 svg(" .run { font-size: 8; font-style: italic; }\n");
145 svg(" text { font-family: Verdana, Helvetica; font-size: 10; }\n");
146 svg(" text.sec { font-size: 8; }\n");
147 svg(" text.t1 { font-size: 24; }\n");
148 svg(" text.t2 { font-size: 12; }\n");
149 svg(" text.idle { font-size: 18; }\n");
150
151 svg(" ]]>\n </style>\n</defs>\n\n");
152 }
153
154 static void svg_title(const char *build) {
155 char cmdline[256] = "";
156 char filename[PATH_MAX];
157 char buf[256];
158 char rootbdev[16] = "Unknown";
159 char model[256] = "Unknown";
160 char date[256] = "Unknown";
161 char cpu[256] = "Unknown";
162 char *c;
163 FILE *f;
164 time_t t;
165 int fd, r;
166 struct utsname uts;
167
168 /* grab /proc/cmdline */
169 fd = openat(procfd, "cmdline", O_RDONLY);
170 f = fdopen(fd, "r");
171 if (f) {
172 if (!fgets(cmdline, 255, f))
173 sprintf(cmdline, "Unknown");
174 fclose(f);
175 }
176
177 /* extract root fs so we can find disk model name in sysfs */
178 /* FIXME: this works only in the simple case */
179 c = strstr(cmdline, "root=/dev/");
180 if (c) {
181 strncpy(rootbdev, &c[10], 3);
182 rootbdev[3] = '\0';
183 sprintf(filename, "block/%s/device/model", rootbdev);
184 fd = openat(sysfd, filename, O_RDONLY);
185 f = fdopen(fd, "r");
186 if (f) {
187 if (!fgets(model, 255, f))
188 fprintf(stderr, "Error reading disk model for %s\n", rootbdev);
189 fclose(f);
190 }
191 }
192
193 /* various utsname parameters */
194 if (uname(&uts))
195 fprintf(stderr, "Error getting uname info\n");
196
197 /* date */
198 t = time(NULL);
199 r = strftime(date, sizeof(date), "%a, %d %b %Y %H:%M:%S %z", localtime(&t));
200 assert_se(r > 0);
201
202 /* CPU type */
203 fd = openat(procfd, "cpuinfo", O_RDONLY);
204 f = fdopen(fd, "r");
205 if (f) {
206 while (fgets(buf, 255, f)) {
207 if (strstr(buf, "model name")) {
208 strncpy(cpu, &buf[13], 255);
209 break;
210 }
211 }
212 fclose(f);
213 }
214
215 svg("<text class=\"t1\" x=\"0\" y=\"30\">Bootchart for %s - %s</text>\n",
216 uts.nodename, date);
217 svg("<text class=\"t2\" x=\"20\" y=\"50\">System: %s %s %s %s</text>\n",
218 uts.sysname, uts.release, uts.version, uts.machine);
219 svg("<text class=\"t2\" x=\"20\" y=\"65\">CPU: %s</text>\n",
220 cpu);
221 svg("<text class=\"t2\" x=\"20\" y=\"80\">Disk: %s</text>\n",
222 model);
223 svg("<text class=\"t2\" x=\"20\" y=\"95\">Boot options: %s</text>\n",
224 cmdline);
225 svg("<text class=\"t2\" x=\"20\" y=\"110\">Build: %s</text>\n",
226 build);
227 svg("<text class=\"t2\" x=\"20\" y=\"125\">Log start time: %.03fs</text>\n", log_start);
228 svg("<text class=\"t2\" x=\"20\" y=\"140\">Idle time: ");
229
230 if (idletime >= 0.0)
231 svg("%.03fs", idletime);
232 else
233 svg("Not detected");
234 svg("</text>\n");
235 svg("<text class=\"sec\" x=\"20\" y=\"155\">Graph data: %.03f samples/sec, recorded %i total, dropped %i samples, %i processes, %i filtered</text>\n",
236 arg_hz, arg_samples_len, overrun, pscount, pfiltered);
237 }
238
239 static void svg_graph_box(int height) {
240 double d = 0.0;
241 int i = 0;
242 double finalsample = 0.0;
243 struct list_sample_data *sampledata_last;
244
245 sampledata_last = head;
246 LIST_FOREACH_BEFORE(link, sampledata, head) {
247 sampledata_last = sampledata;
248 }
249
250 finalsample = sampledata_last->sampletime;
251
252 /* outside box, fill */
253 svg("<rect class=\"box\" x=\"%.03f\" y=\"0\" width=\"%.03f\" height=\"%.03f\" />\n",
254 time_to_graph(0.0),
255 time_to_graph(finalsample - graph_start),
256 ps_to_graph(height));
257
258 for (d = graph_start; d <= finalsample;
259 d += (arg_scale_x < 2.0 ? 60.0 : arg_scale_x < 10.0 ? 1.0 : 0.1)) {
260 /* lines for each second */
261 if (i % 50 == 0)
262 svg(" <line class=\"sec5\" x1=\"%.03f\" y1=\"0\" x2=\"%.03f\" y2=\"%.03f\" />\n",
263 time_to_graph(d - graph_start),
264 time_to_graph(d - graph_start),
265 ps_to_graph(height));
266 else if (i % 10 == 0)
267 svg(" <line class=\"sec1\" x1=\"%.03f\" y1=\"0\" x2=\"%.03f\" y2=\"%.03f\" />\n",
268 time_to_graph(d - graph_start),
269 time_to_graph(d - graph_start),
270 ps_to_graph(height));
271 else
272 svg(" <line class=\"sec01\" x1=\"%.03f\" y1=\"0\" x2=\"%.03f\" y2=\"%.03f\" />\n",
273 time_to_graph(d - graph_start),
274 time_to_graph(d - graph_start),
275 ps_to_graph(height));
276
277 /* time label */
278 if (i % 10 == 0)
279 svg(" <text class=\"sec\" x=\"%.03f\" y=\"%.03f\" >%.01fs</text>\n",
280 time_to_graph(d - graph_start),
281 -5.0,
282 d - graph_start);
283
284 i++;
285 }
286 }
287
288 /* xml comments must not contain "--" */
289 static char* xml_comment_encode(const char* name) {
290 char *enc_name, *p;
291
292 enc_name = strdup(name);
293 if (!enc_name)
294 return NULL;
295
296 for (p = enc_name; *p; p++)
297 if (p[0] == '-' && p[1] == '-')
298 p[1] = '_';
299
300 return enc_name;
301 }
302
303 static void svg_pss_graph(void) {
304 struct ps_struct *ps;
305 int i;
306 struct list_sample_data *sampledata_last;
307
308 sampledata_last = head;
309 LIST_FOREACH_BEFORE(link, sampledata, head) {
310 sampledata_last = sampledata;
311 }
312
313
314 svg("\n\n<!-- Pss memory size graph -->\n");
315
316 svg("\n <text class=\"t2\" x=\"5\" y=\"-15\">Memory allocation - Pss</text>\n");
317
318 /* vsize 1000 == 1000mb */
319 svg_graph_box(100);
320 /* draw some hlines for usable memory sizes */
321 for (i = 100000; i < 1000000; i += 100000) {
322 svg(" <line class=\"sec01\" x1=\"%.03f\" y1=\"%.0f\" x2=\"%.03f\" y2=\"%.0f\"/>\n",
323 time_to_graph(.0),
324 kb_to_graph(i),
325 time_to_graph(sampledata_last->sampletime - graph_start),
326 kb_to_graph(i));
327 svg(" <text class=\"sec\" x=\"%.03f\" y=\"%.0f\">%dM</text>\n",
328 time_to_graph(sampledata_last->sampletime - graph_start) + 5,
329 kb_to_graph(i), (1000000 - i) / 1000);
330 }
331 svg("\n");
332
333 /* now plot the graph itself */
334 i = 1;
335 prev_sampledata = head;
336 LIST_FOREACH_BEFORE(link, sampledata, head) {
337 int bottom;
338 int top;
339 struct ps_sched_struct *cross_place;
340
341 bottom = 0;
342 top = 0;
343
344 /* put all the small pss blocks into the bottom */
345 ps = ps_first;
346 while (ps->next_ps) {
347 ps = ps->next_ps;
348 if (!ps)
349 continue;
350 ps->sample = ps->first;
351 while (ps->sample->next) {
352 ps->sample = ps->sample->next;
353 if (ps->sample->sampledata == sampledata)
354 break;
355 }
356 if (ps->sample->sampledata == sampledata) {
357 if (ps->sample->pss <= (100 * arg_scale_y))
358 top += ps->sample->pss;
359 break;
360 }
361 }
362 while (ps->sample->cross) {
363 cross_place = ps->sample->cross;
364 ps = ps->sample->cross->ps_new;
365 ps->sample = cross_place;
366 if (ps->sample->pss <= (100 * arg_scale_y))
367 top += ps->sample->pss;
368 }
369
370 svg(" <rect class=\"clrw\" style=\"fill: %s\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
371 "rgb(64,64,64)",
372 time_to_graph(prev_sampledata->sampletime - graph_start),
373 kb_to_graph(1000000.0 - top),
374 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
375 kb_to_graph(top - bottom));
376 bottom = top;
377
378 /* now plot the ones that are of significant size */
379 ps = ps_first;
380 while (ps->next_ps) {
381 ps = ps->next_ps;
382 if (!ps)
383 continue;
384 ps->sample = ps->first;
385 while (ps->sample->next) {
386 ps->sample = ps->sample->next;
387 if (ps->sample->sampledata == sampledata)
388 break;
389 }
390 /* don't draw anything smaller than 2mb */
391 if (ps->sample->sampledata == sampledata) {
392 if (ps->sample->pss > (100 * arg_scale_y)) {
393 top = bottom + ps->sample->pss;
394 svg(" <rect class=\"clrw\" style=\"fill: %s\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
395 colorwheel[ps->pid % 12],
396 time_to_graph(prev_sampledata->sampletime - graph_start),
397 kb_to_graph(1000000.0 - top),
398 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
399 kb_to_graph(top - bottom));
400 bottom = top;
401 }
402 break;
403 }
404 }
405 while ((cross_place = ps->sample->cross)) {
406 ps = ps->sample->cross->ps_new;
407 ps->sample = cross_place;
408 if (ps->sample->pss > (100 * arg_scale_y)) {
409 top = bottom + ps->sample->pss;
410 svg(" <rect class=\"clrw\" style=\"fill: %s\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
411 colorwheel[ps->pid % 12],
412 time_to_graph(prev_sampledata->sampletime - graph_start),
413 kb_to_graph(1000000.0 - top),
414 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
415 kb_to_graph(top - bottom));
416 bottom = top;
417 }
418 }
419 prev_sampledata = sampledata;
420 i++;
421 }
422
423 /* overlay all the text labels */
424 i = 1;
425 LIST_FOREACH_BEFORE(link, sampledata, head) {
426 int bottom;
427 int top = 0;
428 struct ps_sched_struct *prev_sample;
429 struct ps_sched_struct *cross_place;
430
431 /* put all the small pss blocks into the bottom */
432 ps = ps_first->next_ps;
433 while (ps->next_ps) {
434 ps = ps->next_ps;
435 if (!ps)
436 continue;
437 ps->sample = ps->first;
438 while (ps->sample->next) {
439 ps->sample = ps->sample->next;
440 if (ps->sample->sampledata == sampledata)
441 break;
442 }
443 if (ps->sample->sampledata == sampledata) {
444 if (ps->sample->pss <= (100 * arg_scale_y))
445 top += ps->sample->pss;
446 break;
447 }
448 }
449 while ((cross_place = ps->sample->cross)) {
450 ps = ps->sample->cross->ps_new;
451 ps->sample = cross_place;
452 if (ps->sample->pss <= (100 * arg_scale_y))
453 top += ps->sample->pss;
454 }
455 bottom = top;
456
457 /* now plot the ones that are of significant size */
458 ps = ps_first;
459 while (ps->next_ps) {
460 prev_sample = ps->sample;
461 ps = ps->next_ps;
462 if (!ps)
463 continue;
464 ps->sample = ps->first;
465 while (ps->sample->next) {
466 prev_sample = ps->sample;
467 ps->sample = ps->sample->next;
468 if (ps->sample->sampledata == sampledata)
469 break;
470 }
471 /* don't draw anything smaller than 2mb */
472 if (ps->sample->sampledata == sampledata) {
473 if (ps->sample->pss > (100 * arg_scale_y)) {
474 top = bottom + ps->sample->pss;
475 /* draw a label with the process / PID */
476 if ((i == 1) || (prev_sample->pss <= (100 * arg_scale_y)))
477 svg(" <text x=\"%.03f\" y=\"%.03f\"><![CDATA[%s]]> [%i]</text>\n",
478 time_to_graph(sampledata->sampletime - graph_start),
479 kb_to_graph(1000000.0 - bottom - ((top - bottom) / 2)),
480 ps->name,
481 ps->pid);
482 bottom = top;
483 }
484 break;
485 }
486 }
487 while ((cross_place = ps->sample->cross)) {
488 ps = ps->sample->cross->ps_new;
489 ps->sample = cross_place;
490 prev_sample = ps->sample->prev;
491 if (ps->sample->pss > (100 * arg_scale_y)) {
492 top = bottom + ps->sample->pss;
493 /* draw a label with the process / PID */
494 if ((i == 1) || (prev_sample->pss <= (100 * arg_scale_y)))
495 svg(" <text x=\"%.03f\" y=\"%.03f\"><![CDATA[%s]]> [%i]</text>\n",
496 time_to_graph(sampledata->sampletime - graph_start),
497 kb_to_graph(1000000.0 - bottom - ((top - bottom) / 2)),
498 ps->name,
499 ps->pid);
500 bottom = top;
501 }
502 }
503 i++;
504 }
505
506 /* debug output - full data dump */
507 svg("\n\n<!-- PSS map - csv format -->\n");
508 ps = ps_first;
509 while (ps->next_ps) {
510 _cleanup_free_ char *enc_name = NULL;
511 ps = ps->next_ps;
512 if (!ps)
513 continue;
514
515 enc_name = xml_comment_encode(ps->name);
516 if (!enc_name)
517 continue;
518
519 svg("<!-- %s [%d] pss=", enc_name, ps->pid);
520
521 ps->sample = ps->first;
522 while (ps->sample->next) {
523 ps->sample = ps->sample->next;
524 svg("%d," , ps->sample->pss);
525 }
526 svg(" -->\n");
527 }
528
529 }
530
531 static void svg_io_bi_bar(void) {
532 double max = 0.0;
533 double range;
534 int max_here = 0;
535 int i;
536 int k;
537 struct list_sample_data *start_sampledata;
538 struct list_sample_data *stop_sampledata;
539
540 svg("<!-- IO utilization graph - In -->\n");
541
542 svg("<text class=\"t2\" x=\"5\" y=\"-15\">IO utilization - read</text>\n");
543
544 /*
545 * calculate rounding range
546 *
547 * We need to round IO data since IO block data is not updated on
548 * each poll. Applying a smoothing function loses some burst data,
549 * so keep the smoothing range short.
550 */
551 range = 0.25 / (1.0 / arg_hz);
552 if (range < 2.0)
553 range = 2.0; /* no smoothing */
554
555 /* surrounding box */
556 svg_graph_box(5);
557
558 /* find the max IO first */
559 i = 1;
560 LIST_FOREACH_BEFORE(link, sampledata, head) {
561 int start;
562 int stop;
563 int diff;
564 double tot;
565
566 start = MAX(i - ((range / 2) - 1), 0);
567 stop = MIN(i + (range / 2), samples - 1);
568 diff = (stop - start);
569
570 start_sampledata = sampledata;
571 stop_sampledata = sampledata;
572
573 for (k=0;(k<((range/2)-1))&&(start_sampledata->link_next);k++)
574 start_sampledata = start_sampledata->link_next;
575 for (k=0;(k<(range/2))&&(stop_sampledata->link_prev);k++)
576 stop_sampledata = stop_sampledata->link_prev;
577
578 tot = (double)(stop_sampledata->blockstat.bi - start_sampledata->blockstat.bi)
579 / diff;
580
581 if (tot > max) {
582 max = tot;
583 max_here = i;
584 }
585
586 tot = (double)(stop_sampledata->blockstat.bo - start_sampledata->blockstat.bo)
587 / diff;
588
589 if (tot > max)
590 max = tot;
591
592 i++;
593 }
594
595 /* plot bi */
596 i = 1;
597 prev_sampledata = head;
598 LIST_FOREACH_BEFORE(link, sampledata, head) {
599 int start;
600 int stop;
601 int diff;
602 double tot;
603 double pbi = 0;
604
605 start = MAX(i - ((range / 2) - 1), 0);
606 stop = MIN(i + (range / 2), samples);
607 diff = (stop - start);
608
609 start_sampledata = sampledata;
610 stop_sampledata = sampledata;
611
612 for (k=0;(k<((range/2)-1))&&(start_sampledata->link_next);k++)
613 start_sampledata = start_sampledata->link_next;
614 for (k=0;(k<(range/2))&&(stop_sampledata->link_prev);k++)
615 stop_sampledata = stop_sampledata->link_prev;
616
617 tot = (double)(stop_sampledata->blockstat.bi - start_sampledata->blockstat.bi)
618 / diff;
619
620 if (max > 0)
621 pbi = tot / max;
622
623 if (pbi > 0.001)
624 svg("<rect class=\"bi\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
625 time_to_graph(prev_sampledata->sampletime - graph_start),
626 (arg_scale_y * 5) - (pbi * (arg_scale_y * 5)),
627 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
628 pbi * (arg_scale_y * 5));
629
630 /* labels around highest value */
631 if (i == max_here) {
632 svg(" <text class=\"sec\" x=\"%.03f\" y=\"%.03f\">%0.2fmb/sec</text>\n",
633 time_to_graph(sampledata->sampletime - graph_start) + 5,
634 ((arg_scale_y * 5) - (pbi * (arg_scale_y * 5))) + 15,
635 max / 1024.0 / (interval / 1000000000.0));
636 }
637 i++;
638 prev_sampledata = sampledata;
639 }
640 }
641
642 static void svg_io_bo_bar(void) {
643 double max = 0.0;
644 double range;
645 int max_here = 0;
646 int i;
647 int k;
648 struct list_sample_data *start_sampledata;
649 struct list_sample_data *stop_sampledata;
650
651 svg("<!-- IO utilization graph - out -->\n");
652
653 svg("<text class=\"t2\" x=\"5\" y=\"-15\">IO utilization - write</text>\n");
654
655 /*
656 * calculate rounding range
657 *
658 * We need to round IO data since IO block data is not updated on
659 * each poll. Applying a smoothing function loses some burst data,
660 * so keep the smoothing range short.
661 */
662 range = 0.25 / (1.0 / arg_hz);
663 if (range < 2.0)
664 range = 2.0; /* no smoothing */
665
666 /* surrounding box */
667 svg_graph_box(5);
668
669 /* find the max IO first */
670 i = 0;
671 LIST_FOREACH_BEFORE(link, sampledata, head) {
672 int start;
673 int stop;
674 int diff;
675 double tot;
676
677 start = MAX(i - ((range / 2) - 1), 0);
678 stop = MIN(i + (range / 2), samples - 1);
679 diff = (stop - start);
680
681 start_sampledata = sampledata;
682 stop_sampledata = sampledata;
683
684 for (k=0;(k<((range/2)-1))&&(start_sampledata->link_next);k++)
685 start_sampledata = start_sampledata->link_next;
686 for (k=0;(k<(range/2))&&(stop_sampledata->link_prev);k++)
687 stop_sampledata = stop_sampledata->link_prev;
688
689 tot = (double)(stop_sampledata->blockstat.bi - start_sampledata->blockstat.bi)
690 / diff;
691 if (tot > max)
692 max = tot;
693 tot = (double)(stop_sampledata->blockstat.bo - start_sampledata->blockstat.bo)
694 / diff;
695 if (tot > max) {
696 max = tot;
697 max_here = i;
698 }
699 i++;
700 }
701
702 /* plot bo */
703 prev_sampledata = head;
704 i=1;
705 LIST_FOREACH_BEFORE(link, sampledata, head) {
706 int start;
707 int stop;
708 int diff;
709 double tot;
710 double pbo;
711
712 pbo = 0;
713
714 start = MAX(i - ((range / 2) - 1), 0);
715 stop = MIN(i + (range / 2), samples);
716 diff = (stop - start);
717
718 start_sampledata = sampledata;
719 stop_sampledata = sampledata;
720
721 for (k=0;(k<((range/2)-1))&&(start_sampledata->link_next);k++)
722 start_sampledata = start_sampledata->link_next;
723 for (k=0;(k<(range/2))&&(stop_sampledata->link_prev);k++)
724 stop_sampledata = stop_sampledata->link_prev;
725
726 tot = (double)(stop_sampledata->blockstat.bo - start_sampledata->blockstat.bo)
727 / diff;
728
729 if (max > 0)
730 pbo = tot / max;
731
732 if (pbo > 0.001)
733 svg("<rect class=\"bo\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
734 time_to_graph(prev_sampledata->sampletime - graph_start),
735 (arg_scale_y * 5) - (pbo * (arg_scale_y * 5)),
736 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
737 pbo * (arg_scale_y * 5));
738
739 /* labels around highest bo value */
740 if (i == max_here) {
741 svg(" <text class=\"sec\" x=\"%.03f\" y=\"%.03f\">%0.2fmb/sec</text>\n",
742 time_to_graph(sampledata->sampletime - graph_start) + 5,
743 ((arg_scale_y * 5) - (pbo * (arg_scale_y * 5))),
744 max / 1024.0 / (interval / 1000000000.0));
745 }
746 i++;
747 prev_sampledata = sampledata;
748 }
749 }
750
751 static void svg_cpu_bar(void) {
752
753 svg("<!-- CPU utilization graph -->\n");
754
755 svg("<text class=\"t2\" x=\"5\" y=\"-15\">CPU utilization</text>\n");
756 /* surrounding box */
757 svg_graph_box(5);
758
759 /* bars for each sample, proportional to the CPU util. */
760 prev_sampledata = head;
761 LIST_FOREACH_BEFORE(link, sampledata, head) {
762 int c;
763 double trt;
764 double ptrt;
765
766 ptrt = trt = 0.0;
767
768 for (c = 0; c < cpus; c++)
769 trt += sampledata->runtime[c] - prev_sampledata->runtime[c];
770
771 trt = trt / 1000000000.0;
772
773 trt = trt / (double)cpus;
774
775 if (trt > 0.0)
776 ptrt = trt / (sampledata->sampletime - prev_sampledata->sampletime);
777
778 if (ptrt > 1.0)
779 ptrt = 1.0;
780
781 if (ptrt > 0.001) {
782 svg("<rect class=\"cpu\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
783 time_to_graph(prev_sampledata->sampletime - graph_start),
784 (arg_scale_y * 5) - (ptrt * (arg_scale_y * 5)),
785 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
786 ptrt * (arg_scale_y * 5));
787 }
788 prev_sampledata = sampledata;
789 }
790 }
791
792 static void svg_wait_bar(void) {
793
794 svg("<!-- Wait time aggregation box -->\n");
795
796 svg("<text class=\"t2\" x=\"5\" y=\"-15\">CPU wait</text>\n");
797
798 /* surrounding box */
799 svg_graph_box(5);
800
801 /* bars for each sample, proportional to the CPU util. */
802 prev_sampledata = head;
803 LIST_FOREACH_BEFORE(link, sampledata, head) {
804 int c;
805 double twt;
806 double ptwt;
807
808 ptwt = twt = 0.0;
809
810 for (c = 0; c < cpus; c++)
811 twt += sampledata->waittime[c] - prev_sampledata->waittime[c];
812
813 twt = twt / 1000000000.0;
814
815 twt = twt / (double)cpus;
816
817 if (twt > 0.0)
818 ptwt = twt / (sampledata->sampletime - prev_sampledata->sampletime);
819
820 if (ptwt > 1.0)
821 ptwt = 1.0;
822
823 if (ptwt > 0.001) {
824 svg("<rect class=\"wait\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
825 time_to_graph(prev_sampledata->sampletime - graph_start),
826 ((arg_scale_y * 5) - (ptwt * (arg_scale_y * 5))),
827 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
828 ptwt * (arg_scale_y * 5));
829 }
830 prev_sampledata = sampledata;
831 }
832 }
833
834
835 static void svg_entropy_bar(void) {
836
837 svg("<!-- entropy pool graph -->\n");
838
839 svg("<text class=\"t2\" x=\"5\" y=\"-15\">Entropy pool size</text>\n");
840 /* surrounding box */
841 svg_graph_box(5);
842
843 /* bars for each sample, scale 0-4096 */
844 prev_sampledata = head;
845 LIST_FOREACH_BEFORE(link, sampledata, head) {
846 /* svg("<!-- entropy %.03f %i -->\n", sampletime[i], entropy_avail[i]); */
847 svg("<rect class=\"cpu\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
848 time_to_graph(prev_sampledata->sampletime - graph_start),
849 ((arg_scale_y * 5) - ((sampledata->entropy_avail / 4096.) * (arg_scale_y * 5))),
850 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
851 (sampledata->entropy_avail / 4096.) * (arg_scale_y * 5));
852 prev_sampledata = sampledata;
853 }
854 }
855
856 static struct ps_struct *get_next_ps(struct ps_struct *ps) {
857 /*
858 * walk the list of processes and return the next one to be
859 * painted
860 */
861 if (ps == ps_first)
862 return ps->next_ps;
863
864 /* go deep */
865 if (ps->children)
866 return ps->children;
867
868 /* find siblings */
869 if (ps->next)
870 return ps->next;
871
872 /* go back for parent siblings */
873 while (1) {
874 if (ps->parent)
875 if (ps->parent->next)
876 return ps->parent->next;
877 ps = ps->parent;
878 if (!ps)
879 return ps;
880 }
881
882 return NULL;
883 }
884
885 static bool ps_filter(struct ps_struct *ps) {
886 if (!arg_filter)
887 return false;
888
889 /* can't draw data when there is only 1 sample (need start + stop) */
890 if (ps->first == ps->last)
891 return true;
892
893 /* don't filter kthreadd */
894 if (ps->pid == 2)
895 return false;
896
897 /* drop stuff that doesn't use any real CPU time */
898 if (ps->total <= 0.001)
899 return true;
900
901 return 0;
902 }
903
904 static void svg_do_initcall(int count_only) {
905 _cleanup_pclose_ FILE *f = NULL;
906 double t;
907 char func[256];
908 int ret;
909 int usecs;
910
911 /* can't plot initcall when disabled or in relative mode */
912 if (!initcall || arg_relative) {
913 kcount = 0;
914 return;
915 }
916
917 if (!count_only) {
918 svg("<!-- initcall -->\n");
919
920 svg("<text class=\"t2\" x=\"5\" y=\"-15\">Kernel init threads</text>\n");
921 /* surrounding box */
922 svg_graph_box(kcount);
923 }
924
925 kcount = 0;
926
927 /*
928 * Initcall graphing - parses dmesg buffer and displays kernel threads
929 * This somewhat uses the same methods and scaling to show processes
930 * but looks a lot simpler. It's overlaid entirely onto the PS graph
931 * when appropriate.
932 */
933
934 f = popen("dmesg", "r");
935 if (!f)
936 return;
937
938 while (!feof(f)) {
939 int c;
940 int z = 0;
941 char l[256];
942
943 if (fgets(l, sizeof(l) - 1, f) == NULL)
944 continue;
945
946 c = sscanf(l, "[%lf] initcall %s %*s %d %*s %d %*s",
947 &t, func, &ret, &usecs);
948 if (c != 4) {
949 /* also parse initcalls done by module loading */
950 c = sscanf(l, "[%lf] initcall %s %*s %*s %d %*s %d %*s",
951 &t, func, &ret, &usecs);
952 if (c != 4)
953 continue;
954 }
955
956 /* chop the +0xXX/0xXX stuff */
957 while(func[z] != '+')
958 z++;
959 func[z] = 0;
960
961 if (count_only) {
962 /* filter out irrelevant stuff */
963 if (usecs >= 1000)
964 kcount++;
965 continue;
966 }
967
968 svg("<!-- thread=\"%s\" time=\"%.3f\" elapsed=\"%d\" result=\"%d\" -->\n",
969 func, t, usecs, ret);
970
971 if (usecs < 1000)
972 continue;
973
974 /* rect */
975 svg(" <rect class=\"krnl\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
976 time_to_graph(t - (usecs / 1000000.0)),
977 ps_to_graph(kcount),
978 time_to_graph(usecs / 1000000.0),
979 ps_to_graph(1));
980
981 /* label */
982 svg(" <text x=\"%.03f\" y=\"%.03f\">%s <tspan class=\"run\">%.03fs</tspan></text>\n",
983 time_to_graph(t - (usecs / 1000000.0)) + 5,
984 ps_to_graph(kcount) + 15,
985 func,
986 usecs / 1000000.0);
987
988 kcount++;
989 }
990 }
991
992 static void svg_ps_bars(void) {
993 struct ps_struct *ps;
994 int i = 0;
995 int j = 0;
996 int pid;
997 double w = 0.0;
998
999 svg("<!-- Process graph -->\n");
1000
1001 svg("<text class=\"t2\" x=\"5\" y=\"-15\">Processes</text>\n");
1002
1003 /* surrounding box */
1004 svg_graph_box(pcount);
1005
1006 /* pass 2 - ps boxes */
1007 ps = ps_first;
1008 while ((ps = get_next_ps(ps))) {
1009 _cleanup_free_ char *enc_name = NULL;
1010 double endtime;
1011 double starttime;
1012 int t;
1013
1014 enc_name = xml_comment_encode(ps->name);
1015 if (!enc_name)
1016 continue;
1017
1018 /* leave some trace of what we actually filtered etc. */
1019 svg("<!-- %s [%i] ppid=%i runtime=%.03fs -->\n", enc_name, ps->pid,
1020 ps->ppid, ps->total);
1021
1022 starttime = ps->first->sampledata->sampletime;
1023
1024 if (!ps_filter(ps)) {
1025 /* remember where _to_ our children need to draw a line */
1026 ps->pos_x = time_to_graph(starttime - graph_start);
1027 ps->pos_y = ps_to_graph(j+1); /* bottom left corner */
1028 } else if (ps->parent){
1029 /* hook children to our parent coords instead */
1030 ps->pos_x = ps->parent->pos_x;
1031 ps->pos_y = ps->parent->pos_y;
1032
1033 /* if this is the last child, we might still need to draw a connecting line */
1034 if ((!ps->next) && (ps->parent))
1035 svg(" <line class=\"dot\" x1=\"%.03f\" y1=\"%.03f\" x2=\"%.03f\" y2=\"%.03f\" />\n",
1036 ps->parent->pos_x,
1037 ps_to_graph(j-1) + 10.0, /* whee, use the last value here */
1038 ps->parent->pos_x,
1039 ps->parent->pos_y);
1040 continue;
1041 }
1042
1043 endtime = ps->last->sampledata->sampletime;
1044 svg(" <rect class=\"ps\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
1045 time_to_graph(starttime - graph_start),
1046 ps_to_graph(j),
1047 time_to_graph(ps->last->sampledata->sampletime - starttime),
1048 ps_to_graph(1));
1049
1050 /* paint cpu load over these */
1051 ps->sample = ps->first;
1052 t = 1;
1053 while (ps->sample->next) {
1054 double rt, prt;
1055 double wt, wrt;
1056 struct ps_sched_struct *prev;
1057
1058 prev = ps->sample;
1059 ps->sample = ps->sample->next;
1060
1061 /* calculate over interval */
1062 rt = ps->sample->runtime - prev->runtime;
1063 wt = ps->sample->waittime - prev->waittime;
1064
1065 prt = (rt / 1000000000) / (ps->sample->sampledata->sampletime - prev->sampledata->sampletime);
1066 wrt = (wt / 1000000000) / (ps->sample->sampledata->sampletime - prev->sampledata->sampletime);
1067
1068 /* this can happen if timekeeping isn't accurate enough */
1069 if (prt > 1.0)
1070 prt = 1.0;
1071 if (wrt > 1.0)
1072 wrt = 1.0;
1073
1074 if ((prt < 0.1) && (wrt < 0.1)) /* =~ 26 (color threshold) */
1075 continue;
1076
1077 svg(" <rect class=\"wait\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
1078 time_to_graph(prev->sampledata->sampletime - graph_start),
1079 ps_to_graph(j),
1080 time_to_graph(ps->sample->sampledata->sampletime - prev->sampledata->sampletime),
1081 ps_to_graph(wrt));
1082
1083 /* draw cpu over wait - TODO figure out how/why run + wait > interval */
1084 svg(" <rect class=\"cpu\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
1085 time_to_graph(prev->sampledata->sampletime - graph_start),
1086 ps_to_graph(j + (1.0 - prt)),
1087 time_to_graph(ps->sample->sampledata->sampletime - prev->sampledata->sampletime),
1088 ps_to_graph(prt));
1089 t++;
1090 }
1091
1092 /* determine where to display the process name */
1093 if ((endtime - starttime) < 1.5)
1094 /* too small to fit label inside the box */
1095 w = endtime;
1096 else
1097 w = starttime;
1098
1099 /* text label of process name */
1100 svg(" <text x=\"%.03f\" y=\"%.03f\"><![CDATA[%s]]> [%i]<tspan class=\"run\">%.03fs</tspan> %s</text>\n",
1101 time_to_graph(w - graph_start) + 5.0,
1102 ps_to_graph(j) + 14.0,
1103 ps->name,
1104 ps->pid,
1105 (ps->last->runtime - ps->first->runtime) / 1000000000.0,
1106 arg_show_cgroup ? ps->cgroup : "");
1107 /* paint lines to the parent process */
1108 if (ps->parent) {
1109 /* horizontal part */
1110 svg(" <line class=\"dot\" x1=\"%.03f\" y1=\"%.03f\" x2=\"%.03f\" y2=\"%.03f\" />\n",
1111 time_to_graph(starttime - graph_start),
1112 ps_to_graph(j) + 10.0,
1113 ps->parent->pos_x,
1114 ps_to_graph(j) + 10.0);
1115
1116 /* one vertical line connecting all the horizontal ones up */
1117 if (!ps->next)
1118 svg(" <line class=\"dot\" x1=\"%.03f\" y1=\"%.03f\" x2=\"%.03f\" y2=\"%.03f\" />\n",
1119 ps->parent->pos_x,
1120 ps_to_graph(j) + 10.0,
1121 ps->parent->pos_x,
1122 ps->parent->pos_y);
1123 }
1124
1125 j++; /* count boxes */
1126
1127 svg("\n");
1128 }
1129
1130 /* last pass - determine when idle */
1131 pid = getpid();
1132 /* make sure we start counting from the point where we actually have
1133 * data: assume that bootchart's first sample is when data started
1134 */
1135
1136 ps = ps_first;
1137 while (ps->next_ps) {
1138 ps = ps->next_ps;
1139 if (ps->pid == pid)
1140 break;
1141 }
1142
1143 /* need to know last node first */
1144 ps->sample = ps->first;
1145 i = ps->sample->next->sampledata->counter;
1146
1147 while (ps->sample->next && i<(samples-(arg_hz/2))) {
1148 double crt;
1149 double brt;
1150 int c;
1151 int ii;
1152 struct ps_sched_struct *sample_hz;
1153
1154 ps->sample = ps->sample->next;
1155 sample_hz = ps->sample;
1156 for (ii=0;((ii<(int)arg_hz/2)&&(ps->sample->next));ii++)
1157 sample_hz = sample_hz->next;
1158
1159 /* subtract bootchart cpu utilization from total */
1160 crt = 0.0;
1161 for (c = 0; c < cpus; c++)
1162 crt += sample_hz->sampledata->runtime[c] - ps->sample->sampledata->runtime[c];
1163 brt = sample_hz->runtime - ps->sample->runtime;
1164 /*
1165 * our definition of "idle":
1166 *
1167 * if for (hz / 2) we've used less CPU than (interval / 2) ...
1168 * defaults to 4.0%, which experimentally, is where atom idles
1169 */
1170 if ((crt - brt) < (interval / 2.0)) {
1171 idletime = ps->sample->sampledata->sampletime - graph_start;
1172 svg("\n<!-- idle detected at %.03f seconds -->\n",
1173 idletime);
1174 svg("<line class=\"idle\" x1=\"%.03f\" y1=\"%.03f\" x2=\"%.03f\" y2=\"%.03f\" />\n",
1175 time_to_graph(idletime),
1176 -arg_scale_y,
1177 time_to_graph(idletime),
1178 ps_to_graph(pcount) + arg_scale_y);
1179 svg("<text class=\"idle\" x=\"%.03f\" y=\"%.03f\">%.01fs</text>\n",
1180 time_to_graph(idletime) + 5.0,
1181 ps_to_graph(pcount) + arg_scale_y,
1182 idletime);
1183 break;
1184 }
1185 i++;
1186 }
1187 }
1188
1189 static void svg_top_ten_cpu(void) {
1190 struct ps_struct *top[10];
1191 struct ps_struct emptyps = {};
1192 struct ps_struct *ps;
1193 int n, m;
1194
1195 for (n = 0; n < (int) ELEMENTSOF(top); n++)
1196 top[n] = &emptyps;
1197
1198 /* walk all ps's and setup ptrs */
1199 ps = ps_first;
1200 while ((ps = get_next_ps(ps))) {
1201 for (n = 0; n < 10; n++) {
1202 if (ps->total <= top[n]->total)
1203 continue;
1204 /* cascade insert */
1205 for (m = 9; m > n; m--)
1206 top[m] = top[m-1];
1207 top[n] = ps;
1208 break;
1209 }
1210 }
1211
1212 svg("<text class=\"t2\" x=\"20\" y=\"0\">Top CPU consumers:</text>\n");
1213 for (n = 0; n < 10; n++)
1214 svg("<text class=\"t3\" x=\"20\" y=\"%d\">%3.03fs - <![CDATA[%s]]> [%d]</text>\n",
1215 20 + (n * 13),
1216 top[n]->total,
1217 top[n]->name,
1218 top[n]->pid);
1219 }
1220
1221 static void svg_top_ten_pss(void) {
1222 struct ps_struct *top[10];
1223 struct ps_struct emptyps = {};
1224 struct ps_struct *ps;
1225 int n, m;
1226
1227 for (n = 0; n < (int) ELEMENTSOF(top); n++)
1228 top[n] = &emptyps;
1229
1230 /* walk all ps's and setup ptrs */
1231 ps = ps_first;
1232 while ((ps = get_next_ps(ps))) {
1233 for (n = 0; n < 10; n++) {
1234 if (ps->pss_max <= top[n]->pss_max)
1235 continue;
1236 /* cascade insert */
1237 for (m = 9; m > n; m--)
1238 top[m] = top[m-1];
1239 top[n] = ps;
1240 break;
1241 }
1242 }
1243
1244 svg("<text class=\"t2\" x=\"20\" y=\"0\">Top PSS consumers:</text>\n");
1245 for (n = 0; n < 10; n++)
1246 svg("<text class=\"t3\" x=\"20\" y=\"%d\">%dK - <![CDATA[%s]]> [%d]</text>\n",
1247 20 + (n * 13),
1248 top[n]->pss_max,
1249 top[n]->name,
1250 top[n]->pid);
1251 }
1252
1253 void svg_do(const char *build) {
1254 struct ps_struct *ps;
1255
1256 memzero(&str, sizeof(str));
1257
1258 ps = ps_first;
1259
1260 /* count initcall thread count first */
1261 svg_do_initcall(1);
1262 ksize = (kcount ? ps_to_graph(kcount) + (arg_scale_y * 2) : 0);
1263
1264 /* then count processes */
1265 while ((ps = get_next_ps(ps))) {
1266 if (!ps_filter(ps))
1267 pcount++;
1268 else
1269 pfiltered++;
1270 }
1271 psize = ps_to_graph(pcount) + (arg_scale_y * 2);
1272
1273 esize = (arg_entropy ? arg_scale_y * 7 : 0);
1274
1275 /* after this, we can draw the header with proper sizing */
1276 svg_header();
1277 svg("<rect class=\"bg\" width=\"100%%\" height=\"100%%\" />\n\n");
1278
1279 svg("<g transform=\"translate(10,400)\">\n");
1280 svg_io_bi_bar();
1281 svg("</g>\n\n");
1282
1283 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * 7.0));
1284 svg_io_bo_bar();
1285 svg("</g>\n\n");
1286
1287 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * 14.0));
1288 svg_cpu_bar();
1289 svg("</g>\n\n");
1290
1291 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * 21.0));
1292 svg_wait_bar();
1293 svg("</g>\n\n");
1294
1295 if (kcount) {
1296 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * 28.0));
1297 svg_do_initcall(0);
1298 svg("</g>\n\n");
1299 }
1300
1301 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * 28.0) + ksize);
1302 svg_ps_bars();
1303 svg("</g>\n\n");
1304
1305 svg("<g transform=\"translate(10, 0)\">\n");
1306 svg_title(build);
1307 svg("</g>\n\n");
1308
1309 svg("<g transform=\"translate(10,200)\">\n");
1310 svg_top_ten_cpu();
1311 svg("</g>\n\n");
1312
1313 if (arg_entropy) {
1314 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * 28.0) + ksize + psize);
1315 svg_entropy_bar();
1316 svg("</g>\n\n");
1317 }
1318
1319 if (arg_pss) {
1320 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * 28.0) + ksize + psize + esize);
1321 svg_pss_graph();
1322 svg("</g>\n\n");
1323
1324 svg("<g transform=\"translate(410,200)\">\n");
1325 svg_top_ten_pss();
1326 svg("</g>\n\n");
1327 }
1328
1329 /* svg footer */
1330 svg("\n</svg>\n");
1331 }
Unnamed repository; edit this file 'description' to name the repository.