Loading...
1/*
2 * svghelper.c - helper functions for outputting svg
3 *
4 * (C) Copyright 2009 Intel Corporation
5 *
6 * Authors:
7 * Arjan van de Ven <arjan@linux.intel.com>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; version 2
12 * of the License.
13 */
14
15#include <inttypes.h>
16#include <stdio.h>
17#include <stdlib.h>
18#include <unistd.h>
19#include <string.h>
20#include <linux/bitops.h>
21
22#include "perf.h"
23#include "svghelper.h"
24#include "util.h"
25#include "cpumap.h"
26
27static u64 first_time, last_time;
28static u64 turbo_frequency, max_freq;
29
30
31#define SLOT_MULT 30.0
32#define SLOT_HEIGHT 25.0
33
34int svg_page_width = 1000;
35u64 svg_highlight;
36const char *svg_highlight_name;
37
38#define MIN_TEXT_SIZE 0.01
39
40static u64 total_height;
41static FILE *svgfile;
42
43static double cpu2slot(int cpu)
44{
45 return 2 * cpu + 1;
46}
47
48static int *topology_map;
49
50static double cpu2y(int cpu)
51{
52 if (topology_map)
53 return cpu2slot(topology_map[cpu]) * SLOT_MULT;
54 else
55 return cpu2slot(cpu) * SLOT_MULT;
56}
57
58static double time2pixels(u64 __time)
59{
60 double X;
61
62 X = 1.0 * svg_page_width * (__time - first_time) / (last_time - first_time);
63 return X;
64}
65
66/*
67 * Round text sizes so that the svg viewer only needs a discrete
68 * number of renderings of the font
69 */
70static double round_text_size(double size)
71{
72 int loop = 100;
73 double target = 10.0;
74
75 if (size >= 10.0)
76 return size;
77 while (loop--) {
78 if (size >= target)
79 return target;
80 target = target / 2.0;
81 }
82 return size;
83}
84
85void open_svg(const char *filename, int cpus, int rows, u64 start, u64 end)
86{
87 int new_width;
88
89 svgfile = fopen(filename, "w");
90 if (!svgfile) {
91 fprintf(stderr, "Cannot open %s for output\n", filename);
92 return;
93 }
94 first_time = start;
95 first_time = first_time / 100000000 * 100000000;
96 last_time = end;
97
98 /*
99 * if the recording is short, we default to a width of 1000, but
100 * for longer recordings we want at least 200 units of width per second
101 */
102 new_width = (last_time - first_time) / 5000000;
103
104 if (new_width > svg_page_width)
105 svg_page_width = new_width;
106
107 total_height = (1 + rows + cpu2slot(cpus)) * SLOT_MULT;
108 fprintf(svgfile, "<?xml version=\"1.0\" standalone=\"no\"?> \n");
109 fprintf(svgfile, "<!DOCTYPE svg SYSTEM \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n");
110 fprintf(svgfile, "<svg width=\"%i\" height=\"%" PRIu64 "\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">\n", svg_page_width, total_height);
111
112 fprintf(svgfile, "<defs>\n <style type=\"text/css\">\n <![CDATA[\n");
113
114 fprintf(svgfile, " rect { stroke-width: 1; }\n");
115 fprintf(svgfile, " rect.process { fill:rgb(180,180,180); fill-opacity:0.9; stroke-width:1; stroke:rgb( 0, 0, 0); } \n");
116 fprintf(svgfile, " rect.process2 { fill:rgb(180,180,180); fill-opacity:0.9; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
117 fprintf(svgfile, " rect.sample { fill:rgb( 0, 0,255); fill-opacity:0.8; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
118 fprintf(svgfile, " rect.sample_hi{ fill:rgb(255,128, 0); fill-opacity:0.8; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
119 fprintf(svgfile, " rect.blocked { fill:rgb(255, 0, 0); fill-opacity:0.5; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
120 fprintf(svgfile, " rect.waiting { fill:rgb(224,214, 0); fill-opacity:0.8; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
121 fprintf(svgfile, " rect.WAITING { fill:rgb(255,214, 48); fill-opacity:0.6; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
122 fprintf(svgfile, " rect.cpu { fill:rgb(192,192,192); fill-opacity:0.2; stroke-width:0.5; stroke:rgb(128,128,128); } \n");
123 fprintf(svgfile, " rect.pstate { fill:rgb(128,128,128); fill-opacity:0.8; stroke-width:0; } \n");
124 fprintf(svgfile, " rect.c1 { fill:rgb(255,214,214); fill-opacity:0.5; stroke-width:0; } \n");
125 fprintf(svgfile, " rect.c2 { fill:rgb(255,172,172); fill-opacity:0.5; stroke-width:0; } \n");
126 fprintf(svgfile, " rect.c3 { fill:rgb(255,130,130); fill-opacity:0.5; stroke-width:0; } \n");
127 fprintf(svgfile, " rect.c4 { fill:rgb(255, 88, 88); fill-opacity:0.5; stroke-width:0; } \n");
128 fprintf(svgfile, " rect.c5 { fill:rgb(255, 44, 44); fill-opacity:0.5; stroke-width:0; } \n");
129 fprintf(svgfile, " rect.c6 { fill:rgb(255, 0, 0); fill-opacity:0.5; stroke-width:0; } \n");
130 fprintf(svgfile, " line.pstate { stroke:rgb(255,255, 0); stroke-opacity:0.8; stroke-width:2; } \n");
131
132 fprintf(svgfile, " ]]>\n </style>\n</defs>\n");
133}
134
135void svg_box(int Yslot, u64 start, u64 end, const char *type)
136{
137 if (!svgfile)
138 return;
139
140 fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"%s\"/>\n",
141 time2pixels(start), time2pixels(end)-time2pixels(start), Yslot * SLOT_MULT, SLOT_HEIGHT, type);
142}
143
144static char *time_to_string(u64 duration);
145void svg_blocked(int Yslot, int cpu, u64 start, u64 end, const char *backtrace)
146{
147 if (!svgfile)
148 return;
149
150 fprintf(svgfile, "<g>\n");
151 fprintf(svgfile, "<title>#%d blocked %s</title>\n", cpu,
152 time_to_string(end - start));
153 if (backtrace)
154 fprintf(svgfile, "<desc>Blocked on:\n%s</desc>\n", backtrace);
155 svg_box(Yslot, start, end, "blocked");
156 fprintf(svgfile, "</g>\n");
157}
158
159void svg_running(int Yslot, int cpu, u64 start, u64 end, const char *backtrace)
160{
161 double text_size;
162 const char *type;
163
164 if (!svgfile)
165 return;
166
167 if (svg_highlight && end - start > svg_highlight)
168 type = "sample_hi";
169 else
170 type = "sample";
171 fprintf(svgfile, "<g>\n");
172
173 fprintf(svgfile, "<title>#%d running %s</title>\n",
174 cpu, time_to_string(end - start));
175 if (backtrace)
176 fprintf(svgfile, "<desc>Switched because:\n%s</desc>\n", backtrace);
177 fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"%s\"/>\n",
178 time2pixels(start), time2pixels(end)-time2pixels(start), Yslot * SLOT_MULT, SLOT_HEIGHT,
179 type);
180
181 text_size = (time2pixels(end)-time2pixels(start));
182 if (cpu > 9)
183 text_size = text_size/2;
184 if (text_size > 1.25)
185 text_size = 1.25;
186 text_size = round_text_size(text_size);
187
188 if (text_size > MIN_TEXT_SIZE)
189 fprintf(svgfile, "<text x=\"%1.8f\" y=\"%1.8f\" font-size=\"%1.8fpt\">%i</text>\n",
190 time2pixels(start), Yslot * SLOT_MULT + SLOT_HEIGHT - 1, text_size, cpu + 1);
191
192 fprintf(svgfile, "</g>\n");
193}
194
195static char *time_to_string(u64 duration)
196{
197 static char text[80];
198
199 text[0] = 0;
200
201 if (duration < 1000) /* less than 1 usec */
202 return text;
203
204 if (duration < 1000 * 1000) { /* less than 1 msec */
205 sprintf(text, "%4.1f us", duration / 1000.0);
206 return text;
207 }
208 sprintf(text, "%4.1f ms", duration / 1000.0 / 1000);
209
210 return text;
211}
212
213void svg_waiting(int Yslot, int cpu, u64 start, u64 end, const char *backtrace)
214{
215 char *text;
216 const char *style;
217 double font_size;
218
219 if (!svgfile)
220 return;
221
222 style = "waiting";
223
224 if (end-start > 10 * 1000000) /* 10 msec */
225 style = "WAITING";
226
227 text = time_to_string(end-start);
228
229 font_size = 1.0 * (time2pixels(end)-time2pixels(start));
230
231 if (font_size > 3)
232 font_size = 3;
233
234 font_size = round_text_size(font_size);
235
236 fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\">\n", time2pixels(start), Yslot * SLOT_MULT);
237 fprintf(svgfile, "<title>#%d waiting %s</title>\n", cpu, time_to_string(end - start));
238 if (backtrace)
239 fprintf(svgfile, "<desc>Waiting on:\n%s</desc>\n", backtrace);
240 fprintf(svgfile, "<rect x=\"0\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
241 time2pixels(end)-time2pixels(start), SLOT_HEIGHT, style);
242 if (font_size > MIN_TEXT_SIZE)
243 fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%1.8fpt\"> %s</text>\n",
244 font_size, text);
245 fprintf(svgfile, "</g>\n");
246}
247
248static char *cpu_model(void)
249{
250 static char cpu_m[255];
251 char buf[256];
252 FILE *file;
253
254 cpu_m[0] = 0;
255 /* CPU type */
256 file = fopen("/proc/cpuinfo", "r");
257 if (file) {
258 while (fgets(buf, 255, file)) {
259 if (strstr(buf, "model name")) {
260 strncpy(cpu_m, &buf[13], 255);
261 break;
262 }
263 }
264 fclose(file);
265 }
266
267 /* CPU type */
268 file = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies", "r");
269 if (file) {
270 while (fgets(buf, 255, file)) {
271 unsigned int freq;
272 freq = strtoull(buf, NULL, 10);
273 if (freq > max_freq)
274 max_freq = freq;
275 }
276 fclose(file);
277 }
278 return cpu_m;
279}
280
281void svg_cpu_box(int cpu, u64 __max_freq, u64 __turbo_freq)
282{
283 char cpu_string[80];
284 if (!svgfile)
285 return;
286
287 max_freq = __max_freq;
288 turbo_frequency = __turbo_freq;
289
290 fprintf(svgfile, "<g>\n");
291
292 fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"cpu\"/>\n",
293 time2pixels(first_time),
294 time2pixels(last_time)-time2pixels(first_time),
295 cpu2y(cpu), SLOT_MULT+SLOT_HEIGHT);
296
297 sprintf(cpu_string, "CPU %i", (int)cpu);
298 fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\">%s</text>\n",
299 10+time2pixels(first_time), cpu2y(cpu) + SLOT_HEIGHT/2, cpu_string);
300
301 fprintf(svgfile, "<text transform=\"translate(%4.8f,%4.8f)\" font-size=\"1.25pt\">%s</text>\n",
302 10+time2pixels(first_time), cpu2y(cpu) + SLOT_MULT + SLOT_HEIGHT - 4, cpu_model());
303
304 fprintf(svgfile, "</g>\n");
305}
306
307void svg_process(int cpu, u64 start, u64 end, int pid, const char *name, const char *backtrace)
308{
309 double width;
310 const char *type;
311
312 if (!svgfile)
313 return;
314
315 if (svg_highlight && end - start >= svg_highlight)
316 type = "sample_hi";
317 else if (svg_highlight_name && strstr(name, svg_highlight_name))
318 type = "sample_hi";
319 else
320 type = "sample";
321
322 fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\">\n", time2pixels(start), cpu2y(cpu));
323 fprintf(svgfile, "<title>%d %s running %s</title>\n", pid, name, time_to_string(end - start));
324 if (backtrace)
325 fprintf(svgfile, "<desc>Switched because:\n%s</desc>\n", backtrace);
326 fprintf(svgfile, "<rect x=\"0\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
327 time2pixels(end)-time2pixels(start), SLOT_MULT+SLOT_HEIGHT, type);
328 width = time2pixels(end)-time2pixels(start);
329 if (width > 6)
330 width = 6;
331
332 width = round_text_size(width);
333
334 if (width > MIN_TEXT_SIZE)
335 fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%3.8fpt\">%s</text>\n",
336 width, name);
337
338 fprintf(svgfile, "</g>\n");
339}
340
341void svg_cstate(int cpu, u64 start, u64 end, int type)
342{
343 double width;
344 char style[128];
345
346 if (!svgfile)
347 return;
348
349
350 fprintf(svgfile, "<g>\n");
351
352 if (type > 6)
353 type = 6;
354 sprintf(style, "c%i", type);
355
356 fprintf(svgfile, "<rect class=\"%s\" x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\"/>\n",
357 style,
358 time2pixels(start), time2pixels(end)-time2pixels(start),
359 cpu2y(cpu), SLOT_MULT+SLOT_HEIGHT);
360
361 width = (time2pixels(end)-time2pixels(start))/2.0;
362 if (width > 6)
363 width = 6;
364
365 width = round_text_size(width);
366
367 if (width > MIN_TEXT_SIZE)
368 fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\" font-size=\"%3.8fpt\">C%i</text>\n",
369 time2pixels(start), cpu2y(cpu)+width, width, type);
370
371 fprintf(svgfile, "</g>\n");
372}
373
374static char *HzToHuman(unsigned long hz)
375{
376 static char buffer[1024];
377 unsigned long long Hz;
378
379 memset(buffer, 0, 1024);
380
381 Hz = hz;
382
383 /* default: just put the Number in */
384 sprintf(buffer, "%9lli", Hz);
385
386 if (Hz > 1000)
387 sprintf(buffer, " %6lli Mhz", (Hz+500)/1000);
388
389 if (Hz > 1500000)
390 sprintf(buffer, " %6.2f Ghz", (Hz+5000.0)/1000000);
391
392 if (Hz == turbo_frequency)
393 sprintf(buffer, "Turbo");
394
395 return buffer;
396}
397
398void svg_pstate(int cpu, u64 start, u64 end, u64 freq)
399{
400 double height = 0;
401
402 if (!svgfile)
403 return;
404
405 fprintf(svgfile, "<g>\n");
406
407 if (max_freq)
408 height = freq * 1.0 / max_freq * (SLOT_HEIGHT + SLOT_MULT);
409 height = 1 + cpu2y(cpu) + SLOT_MULT + SLOT_HEIGHT - height;
410 fprintf(svgfile, "<line x1=\"%4.8f\" x2=\"%4.8f\" y1=\"%4.1f\" y2=\"%4.1f\" class=\"pstate\"/>\n",
411 time2pixels(start), time2pixels(end), height, height);
412 fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\" font-size=\"0.25pt\">%s</text>\n",
413 time2pixels(start), height+0.9, HzToHuman(freq));
414
415 fprintf(svgfile, "</g>\n");
416}
417
418
419void svg_partial_wakeline(u64 start, int row1, char *desc1, int row2, char *desc2, const char *backtrace)
420{
421 double height;
422
423 if (!svgfile)
424 return;
425
426
427 fprintf(svgfile, "<g>\n");
428
429 fprintf(svgfile, "<title>%s wakes up %s</title>\n",
430 desc1 ? desc1 : "?",
431 desc2 ? desc2 : "?");
432
433 if (backtrace)
434 fprintf(svgfile, "<desc>%s</desc>\n", backtrace);
435
436 if (row1 < row2) {
437 if (row1) {
438 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
439 time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT, time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/32);
440 if (desc2)
441 fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s ></text></g>\n",
442 time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT + SLOT_HEIGHT/48, desc2);
443 }
444 if (row2) {
445 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
446 time2pixels(start), row2 * SLOT_MULT - SLOT_MULT/32, time2pixels(start), row2 * SLOT_MULT);
447 if (desc1)
448 fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s ></text></g>\n",
449 time2pixels(start), row2 * SLOT_MULT - SLOT_MULT/32, desc1);
450 }
451 } else {
452 if (row2) {
453 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
454 time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT, time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/32);
455 if (desc1)
456 fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s <</text></g>\n",
457 time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/48, desc1);
458 }
459 if (row1) {
460 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
461 time2pixels(start), row1 * SLOT_MULT - SLOT_MULT/32, time2pixels(start), row1 * SLOT_MULT);
462 if (desc2)
463 fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s <</text></g>\n",
464 time2pixels(start), row1 * SLOT_MULT - SLOT_HEIGHT/32, desc2);
465 }
466 }
467 height = row1 * SLOT_MULT;
468 if (row2 > row1)
469 height += SLOT_HEIGHT;
470 if (row1)
471 fprintf(svgfile, "<circle cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\" style=\"fill:rgb(32,255,32)\"/>\n",
472 time2pixels(start), height);
473
474 fprintf(svgfile, "</g>\n");
475}
476
477void svg_wakeline(u64 start, int row1, int row2, const char *backtrace)
478{
479 double height;
480
481 if (!svgfile)
482 return;
483
484
485 fprintf(svgfile, "<g>\n");
486
487 if (backtrace)
488 fprintf(svgfile, "<desc>%s</desc>\n", backtrace);
489
490 if (row1 < row2)
491 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
492 time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT, time2pixels(start), row2 * SLOT_MULT);
493 else
494 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
495 time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT, time2pixels(start), row1 * SLOT_MULT);
496
497 height = row1 * SLOT_MULT;
498 if (row2 > row1)
499 height += SLOT_HEIGHT;
500 fprintf(svgfile, "<circle cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\" style=\"fill:rgb(32,255,32)\"/>\n",
501 time2pixels(start), height);
502
503 fprintf(svgfile, "</g>\n");
504}
505
506void svg_interrupt(u64 start, int row, const char *backtrace)
507{
508 if (!svgfile)
509 return;
510
511 fprintf(svgfile, "<g>\n");
512
513 fprintf(svgfile, "<title>Wakeup from interrupt</title>\n");
514
515 if (backtrace)
516 fprintf(svgfile, "<desc>%s</desc>\n", backtrace);
517
518 fprintf(svgfile, "<circle cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\" style=\"fill:rgb(255,128,128)\"/>\n",
519 time2pixels(start), row * SLOT_MULT);
520 fprintf(svgfile, "<circle cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\" style=\"fill:rgb(255,128,128)\"/>\n",
521 time2pixels(start), row * SLOT_MULT + SLOT_HEIGHT);
522
523 fprintf(svgfile, "</g>\n");
524}
525
526void svg_text(int Yslot, u64 start, const char *text)
527{
528 if (!svgfile)
529 return;
530
531 fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\">%s</text>\n",
532 time2pixels(start), Yslot * SLOT_MULT+SLOT_HEIGHT/2, text);
533}
534
535static void svg_legenda_box(int X, const char *text, const char *style)
536{
537 double boxsize;
538 boxsize = SLOT_HEIGHT / 2;
539
540 fprintf(svgfile, "<rect x=\"%i\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
541 X, boxsize, boxsize, style);
542 fprintf(svgfile, "<text transform=\"translate(%4.8f, %4.8f)\" font-size=\"%4.8fpt\">%s</text>\n",
543 X + boxsize + 5, boxsize, 0.8 * boxsize, text);
544}
545
546void svg_legenda(void)
547{
548 if (!svgfile)
549 return;
550
551 fprintf(svgfile, "<g>\n");
552 svg_legenda_box(0, "Running", "sample");
553 svg_legenda_box(100, "Idle","c1");
554 svg_legenda_box(200, "Deeper Idle", "c3");
555 svg_legenda_box(350, "Deepest Idle", "c6");
556 svg_legenda_box(550, "Sleeping", "process2");
557 svg_legenda_box(650, "Waiting for cpu", "waiting");
558 svg_legenda_box(800, "Blocked on IO", "blocked");
559 fprintf(svgfile, "</g>\n");
560}
561
562void svg_time_grid(void)
563{
564 u64 i;
565
566 if (!svgfile)
567 return;
568
569 i = first_time;
570 while (i < last_time) {
571 int color = 220;
572 double thickness = 0.075;
573 if ((i % 100000000) == 0) {
574 thickness = 0.5;
575 color = 192;
576 }
577 if ((i % 1000000000) == 0) {
578 thickness = 2.0;
579 color = 128;
580 }
581
582 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%" PRIu64 "\" style=\"stroke:rgb(%i,%i,%i);stroke-width:%1.3f\"/>\n",
583 time2pixels(i), SLOT_MULT/2, time2pixels(i), total_height, color, color, color, thickness);
584
585 i += 10000000;
586 }
587}
588
589void svg_close(void)
590{
591 if (svgfile) {
592 fprintf(svgfile, "</svg>\n");
593 fclose(svgfile);
594 svgfile = NULL;
595 }
596}
597
598#define cpumask_bits(maskp) ((maskp)->bits)
599typedef struct { DECLARE_BITMAP(bits, MAX_NR_CPUS); } cpumask_t;
600
601struct topology {
602 cpumask_t *sib_core;
603 int sib_core_nr;
604 cpumask_t *sib_thr;
605 int sib_thr_nr;
606};
607
608static void scan_thread_topology(int *map, struct topology *t, int cpu, int *pos)
609{
610 int i;
611 int thr;
612
613 for (i = 0; i < t->sib_thr_nr; i++) {
614 if (!test_bit(cpu, cpumask_bits(&t->sib_thr[i])))
615 continue;
616
617 for_each_set_bit(thr,
618 cpumask_bits(&t->sib_thr[i]),
619 MAX_NR_CPUS)
620 if (map[thr] == -1)
621 map[thr] = (*pos)++;
622 }
623}
624
625static void scan_core_topology(int *map, struct topology *t)
626{
627 int pos = 0;
628 int i;
629 int cpu;
630
631 for (i = 0; i < t->sib_core_nr; i++)
632 for_each_set_bit(cpu,
633 cpumask_bits(&t->sib_core[i]),
634 MAX_NR_CPUS)
635 scan_thread_topology(map, t, cpu, &pos);
636}
637
638static int str_to_bitmap(char *s, cpumask_t *b)
639{
640 int i;
641 int ret = 0;
642 struct cpu_map *m;
643 int c;
644
645 m = cpu_map__new(s);
646 if (!m)
647 return -1;
648
649 for (i = 0; i < m->nr; i++) {
650 c = m->map[i];
651 if (c >= MAX_NR_CPUS) {
652 ret = -1;
653 break;
654 }
655
656 set_bit(c, cpumask_bits(b));
657 }
658
659 cpu_map__delete(m);
660
661 return ret;
662}
663
664int svg_build_topology_map(char *sib_core, int sib_core_nr,
665 char *sib_thr, int sib_thr_nr)
666{
667 int i;
668 struct topology t;
669
670 t.sib_core_nr = sib_core_nr;
671 t.sib_thr_nr = sib_thr_nr;
672 t.sib_core = calloc(sib_core_nr, sizeof(cpumask_t));
673 t.sib_thr = calloc(sib_thr_nr, sizeof(cpumask_t));
674
675 if (!t.sib_core || !t.sib_thr) {
676 fprintf(stderr, "topology: no memory\n");
677 goto exit;
678 }
679
680 for (i = 0; i < sib_core_nr; i++) {
681 if (str_to_bitmap(sib_core, &t.sib_core[i])) {
682 fprintf(stderr, "topology: can't parse siblings map\n");
683 goto exit;
684 }
685
686 sib_core += strlen(sib_core) + 1;
687 }
688
689 for (i = 0; i < sib_thr_nr; i++) {
690 if (str_to_bitmap(sib_thr, &t.sib_thr[i])) {
691 fprintf(stderr, "topology: can't parse siblings map\n");
692 goto exit;
693 }
694
695 sib_thr += strlen(sib_thr) + 1;
696 }
697
698 topology_map = malloc(sizeof(int) * MAX_NR_CPUS);
699 if (!topology_map) {
700 fprintf(stderr, "topology: no memory\n");
701 goto exit;
702 }
703
704 for (i = 0; i < MAX_NR_CPUS; i++)
705 topology_map[i] = -1;
706
707 scan_core_topology(topology_map, &t);
708
709 return 0;
710
711exit:
712 zfree(&t.sib_core);
713 zfree(&t.sib_thr);
714
715 return -1;
716}
1/*
2 * svghelper.c - helper functions for outputting svg
3 *
4 * (C) Copyright 2009 Intel Corporation
5 *
6 * Authors:
7 * Arjan van de Ven <arjan@linux.intel.com>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; version 2
12 * of the License.
13 */
14
15#include <inttypes.h>
16#include <stdio.h>
17#include <stdlib.h>
18#include <unistd.h>
19#include <string.h>
20
21#include "svghelper.h"
22
23static u64 first_time, last_time;
24static u64 turbo_frequency, max_freq;
25
26
27#define SLOT_MULT 30.0
28#define SLOT_HEIGHT 25.0
29
30int svg_page_width = 1000;
31
32#define MIN_TEXT_SIZE 0.01
33
34static u64 total_height;
35static FILE *svgfile;
36
37static double cpu2slot(int cpu)
38{
39 return 2 * cpu + 1;
40}
41
42static double cpu2y(int cpu)
43{
44 return cpu2slot(cpu) * SLOT_MULT;
45}
46
47static double time2pixels(u64 __time)
48{
49 double X;
50
51 X = 1.0 * svg_page_width * (__time - first_time) / (last_time - first_time);
52 return X;
53}
54
55/*
56 * Round text sizes so that the svg viewer only needs a discrete
57 * number of renderings of the font
58 */
59static double round_text_size(double size)
60{
61 int loop = 100;
62 double target = 10.0;
63
64 if (size >= 10.0)
65 return size;
66 while (loop--) {
67 if (size >= target)
68 return target;
69 target = target / 2.0;
70 }
71 return size;
72}
73
74void open_svg(const char *filename, int cpus, int rows, u64 start, u64 end)
75{
76 int new_width;
77
78 svgfile = fopen(filename, "w");
79 if (!svgfile) {
80 fprintf(stderr, "Cannot open %s for output\n", filename);
81 return;
82 }
83 first_time = start;
84 first_time = first_time / 100000000 * 100000000;
85 last_time = end;
86
87 /*
88 * if the recording is short, we default to a width of 1000, but
89 * for longer recordings we want at least 200 units of width per second
90 */
91 new_width = (last_time - first_time) / 5000000;
92
93 if (new_width > svg_page_width)
94 svg_page_width = new_width;
95
96 total_height = (1 + rows + cpu2slot(cpus)) * SLOT_MULT;
97 fprintf(svgfile, "<?xml version=\"1.0\" standalone=\"no\"?> \n");
98 fprintf(svgfile, "<svg width=\"%i\" height=\"%" PRIu64 "\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">\n", svg_page_width, total_height);
99
100 fprintf(svgfile, "<defs>\n <style type=\"text/css\">\n <![CDATA[\n");
101
102 fprintf(svgfile, " rect { stroke-width: 1; }\n");
103 fprintf(svgfile, " rect.process { fill:rgb(180,180,180); fill-opacity:0.9; stroke-width:1; stroke:rgb( 0, 0, 0); } \n");
104 fprintf(svgfile, " rect.process2 { fill:rgb(180,180,180); fill-opacity:0.9; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
105 fprintf(svgfile, " rect.sample { fill:rgb( 0, 0,255); fill-opacity:0.8; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
106 fprintf(svgfile, " rect.blocked { fill:rgb(255, 0, 0); fill-opacity:0.5; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
107 fprintf(svgfile, " rect.waiting { fill:rgb(224,214, 0); fill-opacity:0.8; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
108 fprintf(svgfile, " rect.WAITING { fill:rgb(255,214, 48); fill-opacity:0.6; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
109 fprintf(svgfile, " rect.cpu { fill:rgb(192,192,192); fill-opacity:0.2; stroke-width:0.5; stroke:rgb(128,128,128); } \n");
110 fprintf(svgfile, " rect.pstate { fill:rgb(128,128,128); fill-opacity:0.8; stroke-width:0; } \n");
111 fprintf(svgfile, " rect.c1 { fill:rgb(255,214,214); fill-opacity:0.5; stroke-width:0; } \n");
112 fprintf(svgfile, " rect.c2 { fill:rgb(255,172,172); fill-opacity:0.5; stroke-width:0; } \n");
113 fprintf(svgfile, " rect.c3 { fill:rgb(255,130,130); fill-opacity:0.5; stroke-width:0; } \n");
114 fprintf(svgfile, " rect.c4 { fill:rgb(255, 88, 88); fill-opacity:0.5; stroke-width:0; } \n");
115 fprintf(svgfile, " rect.c5 { fill:rgb(255, 44, 44); fill-opacity:0.5; stroke-width:0; } \n");
116 fprintf(svgfile, " rect.c6 { fill:rgb(255, 0, 0); fill-opacity:0.5; stroke-width:0; } \n");
117 fprintf(svgfile, " line.pstate { stroke:rgb(255,255, 0); stroke-opacity:0.8; stroke-width:2; } \n");
118
119 fprintf(svgfile, " ]]>\n </style>\n</defs>\n");
120}
121
122void svg_box(int Yslot, u64 start, u64 end, const char *type)
123{
124 if (!svgfile)
125 return;
126
127 fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"%s\"/>\n",
128 time2pixels(start), time2pixels(end)-time2pixels(start), Yslot * SLOT_MULT, SLOT_HEIGHT, type);
129}
130
131void svg_sample(int Yslot, int cpu, u64 start, u64 end)
132{
133 double text_size;
134 if (!svgfile)
135 return;
136
137 fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"sample\"/>\n",
138 time2pixels(start), time2pixels(end)-time2pixels(start), Yslot * SLOT_MULT, SLOT_HEIGHT);
139
140 text_size = (time2pixels(end)-time2pixels(start));
141 if (cpu > 9)
142 text_size = text_size/2;
143 if (text_size > 1.25)
144 text_size = 1.25;
145 text_size = round_text_size(text_size);
146
147 if (text_size > MIN_TEXT_SIZE)
148 fprintf(svgfile, "<text x=\"%1.8f\" y=\"%1.8f\" font-size=\"%1.8fpt\">%i</text>\n",
149 time2pixels(start), Yslot * SLOT_MULT + SLOT_HEIGHT - 1, text_size, cpu + 1);
150
151}
152
153static char *time_to_string(u64 duration)
154{
155 static char text[80];
156
157 text[0] = 0;
158
159 if (duration < 1000) /* less than 1 usec */
160 return text;
161
162 if (duration < 1000 * 1000) { /* less than 1 msec */
163 sprintf(text, "%4.1f us", duration / 1000.0);
164 return text;
165 }
166 sprintf(text, "%4.1f ms", duration / 1000.0 / 1000);
167
168 return text;
169}
170
171void svg_waiting(int Yslot, u64 start, u64 end)
172{
173 char *text;
174 const char *style;
175 double font_size;
176
177 if (!svgfile)
178 return;
179
180 style = "waiting";
181
182 if (end-start > 10 * 1000000) /* 10 msec */
183 style = "WAITING";
184
185 text = time_to_string(end-start);
186
187 font_size = 1.0 * (time2pixels(end)-time2pixels(start));
188
189 if (font_size > 3)
190 font_size = 3;
191
192 font_size = round_text_size(font_size);
193
194 fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\">\n", time2pixels(start), Yslot * SLOT_MULT);
195 fprintf(svgfile, "<rect x=\"0\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
196 time2pixels(end)-time2pixels(start), SLOT_HEIGHT, style);
197 if (font_size > MIN_TEXT_SIZE)
198 fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%1.8fpt\"> %s</text>\n",
199 font_size, text);
200 fprintf(svgfile, "</g>\n");
201}
202
203static char *cpu_model(void)
204{
205 static char cpu_m[255];
206 char buf[256];
207 FILE *file;
208
209 cpu_m[0] = 0;
210 /* CPU type */
211 file = fopen("/proc/cpuinfo", "r");
212 if (file) {
213 while (fgets(buf, 255, file)) {
214 if (strstr(buf, "model name")) {
215 strncpy(cpu_m, &buf[13], 255);
216 break;
217 }
218 }
219 fclose(file);
220 }
221
222 /* CPU type */
223 file = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies", "r");
224 if (file) {
225 while (fgets(buf, 255, file)) {
226 unsigned int freq;
227 freq = strtoull(buf, NULL, 10);
228 if (freq > max_freq)
229 max_freq = freq;
230 }
231 fclose(file);
232 }
233 return cpu_m;
234}
235
236void svg_cpu_box(int cpu, u64 __max_freq, u64 __turbo_freq)
237{
238 char cpu_string[80];
239 if (!svgfile)
240 return;
241
242 max_freq = __max_freq;
243 turbo_frequency = __turbo_freq;
244
245 fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"cpu\"/>\n",
246 time2pixels(first_time),
247 time2pixels(last_time)-time2pixels(first_time),
248 cpu2y(cpu), SLOT_MULT+SLOT_HEIGHT);
249
250 sprintf(cpu_string, "CPU %i", (int)cpu+1);
251 fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\">%s</text>\n",
252 10+time2pixels(first_time), cpu2y(cpu) + SLOT_HEIGHT/2, cpu_string);
253
254 fprintf(svgfile, "<text transform=\"translate(%4.8f,%4.8f)\" font-size=\"1.25pt\">%s</text>\n",
255 10+time2pixels(first_time), cpu2y(cpu) + SLOT_MULT + SLOT_HEIGHT - 4, cpu_model());
256}
257
258void svg_process(int cpu, u64 start, u64 end, const char *type, const char *name)
259{
260 double width;
261
262 if (!svgfile)
263 return;
264
265
266 fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\">\n", time2pixels(start), cpu2y(cpu));
267 fprintf(svgfile, "<rect x=\"0\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
268 time2pixels(end)-time2pixels(start), SLOT_MULT+SLOT_HEIGHT, type);
269 width = time2pixels(end)-time2pixels(start);
270 if (width > 6)
271 width = 6;
272
273 width = round_text_size(width);
274
275 if (width > MIN_TEXT_SIZE)
276 fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%3.8fpt\">%s</text>\n",
277 width, name);
278
279 fprintf(svgfile, "</g>\n");
280}
281
282void svg_cstate(int cpu, u64 start, u64 end, int type)
283{
284 double width;
285 char style[128];
286
287 if (!svgfile)
288 return;
289
290
291 if (type > 6)
292 type = 6;
293 sprintf(style, "c%i", type);
294
295 fprintf(svgfile, "<rect class=\"%s\" x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\"/>\n",
296 style,
297 time2pixels(start), time2pixels(end)-time2pixels(start),
298 cpu2y(cpu), SLOT_MULT+SLOT_HEIGHT);
299
300 width = (time2pixels(end)-time2pixels(start))/2.0;
301 if (width > 6)
302 width = 6;
303
304 width = round_text_size(width);
305
306 if (width > MIN_TEXT_SIZE)
307 fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\" font-size=\"%3.8fpt\">C%i</text>\n",
308 time2pixels(start), cpu2y(cpu)+width, width, type);
309}
310
311static char *HzToHuman(unsigned long hz)
312{
313 static char buffer[1024];
314 unsigned long long Hz;
315
316 memset(buffer, 0, 1024);
317
318 Hz = hz;
319
320 /* default: just put the Number in */
321 sprintf(buffer, "%9lli", Hz);
322
323 if (Hz > 1000)
324 sprintf(buffer, " %6lli Mhz", (Hz+500)/1000);
325
326 if (Hz > 1500000)
327 sprintf(buffer, " %6.2f Ghz", (Hz+5000.0)/1000000);
328
329 if (Hz == turbo_frequency)
330 sprintf(buffer, "Turbo");
331
332 return buffer;
333}
334
335void svg_pstate(int cpu, u64 start, u64 end, u64 freq)
336{
337 double height = 0;
338
339 if (!svgfile)
340 return;
341
342 if (max_freq)
343 height = freq * 1.0 / max_freq * (SLOT_HEIGHT + SLOT_MULT);
344 height = 1 + cpu2y(cpu) + SLOT_MULT + SLOT_HEIGHT - height;
345 fprintf(svgfile, "<line x1=\"%4.8f\" x2=\"%4.8f\" y1=\"%4.1f\" y2=\"%4.1f\" class=\"pstate\"/>\n",
346 time2pixels(start), time2pixels(end), height, height);
347 fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\" font-size=\"0.25pt\">%s</text>\n",
348 time2pixels(start), height+0.9, HzToHuman(freq));
349
350}
351
352
353void svg_partial_wakeline(u64 start, int row1, char *desc1, int row2, char *desc2)
354{
355 double height;
356
357 if (!svgfile)
358 return;
359
360
361 if (row1 < row2) {
362 if (row1) {
363 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
364 time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT, time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/32);
365 if (desc2)
366 fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s ></text></g>\n",
367 time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT + SLOT_HEIGHT/48, desc2);
368 }
369 if (row2) {
370 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
371 time2pixels(start), row2 * SLOT_MULT - SLOT_MULT/32, time2pixels(start), row2 * SLOT_MULT);
372 if (desc1)
373 fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s ></text></g>\n",
374 time2pixels(start), row2 * SLOT_MULT - SLOT_MULT/32, desc1);
375 }
376 } else {
377 if (row2) {
378 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
379 time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT, time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/32);
380 if (desc1)
381 fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s <</text></g>\n",
382 time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/48, desc1);
383 }
384 if (row1) {
385 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
386 time2pixels(start), row1 * SLOT_MULT - SLOT_MULT/32, time2pixels(start), row1 * SLOT_MULT);
387 if (desc2)
388 fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s <</text></g>\n",
389 time2pixels(start), row1 * SLOT_MULT - SLOT_HEIGHT/32, desc2);
390 }
391 }
392 height = row1 * SLOT_MULT;
393 if (row2 > row1)
394 height += SLOT_HEIGHT;
395 if (row1)
396 fprintf(svgfile, "<circle cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\" style=\"fill:rgb(32,255,32)\"/>\n",
397 time2pixels(start), height);
398}
399
400void svg_wakeline(u64 start, int row1, int row2)
401{
402 double height;
403
404 if (!svgfile)
405 return;
406
407
408 if (row1 < row2)
409 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
410 time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT, time2pixels(start), row2 * SLOT_MULT);
411 else
412 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
413 time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT, time2pixels(start), row1 * SLOT_MULT);
414
415 height = row1 * SLOT_MULT;
416 if (row2 > row1)
417 height += SLOT_HEIGHT;
418 fprintf(svgfile, "<circle cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\" style=\"fill:rgb(32,255,32)\"/>\n",
419 time2pixels(start), height);
420}
421
422void svg_interrupt(u64 start, int row)
423{
424 if (!svgfile)
425 return;
426
427 fprintf(svgfile, "<circle cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\" style=\"fill:rgb(255,128,128)\"/>\n",
428 time2pixels(start), row * SLOT_MULT);
429 fprintf(svgfile, "<circle cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\" style=\"fill:rgb(255,128,128)\"/>\n",
430 time2pixels(start), row * SLOT_MULT + SLOT_HEIGHT);
431}
432
433void svg_text(int Yslot, u64 start, const char *text)
434{
435 if (!svgfile)
436 return;
437
438 fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\">%s</text>\n",
439 time2pixels(start), Yslot * SLOT_MULT+SLOT_HEIGHT/2, text);
440}
441
442static void svg_legenda_box(int X, const char *text, const char *style)
443{
444 double boxsize;
445 boxsize = SLOT_HEIGHT / 2;
446
447 fprintf(svgfile, "<rect x=\"%i\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
448 X, boxsize, boxsize, style);
449 fprintf(svgfile, "<text transform=\"translate(%4.8f, %4.8f)\" font-size=\"%4.8fpt\">%s</text>\n",
450 X + boxsize + 5, boxsize, 0.8 * boxsize, text);
451}
452
453void svg_legenda(void)
454{
455 if (!svgfile)
456 return;
457
458 svg_legenda_box(0, "Running", "sample");
459 svg_legenda_box(100, "Idle","c1");
460 svg_legenda_box(200, "Deeper Idle", "c3");
461 svg_legenda_box(350, "Deepest Idle", "c6");
462 svg_legenda_box(550, "Sleeping", "process2");
463 svg_legenda_box(650, "Waiting for cpu", "waiting");
464 svg_legenda_box(800, "Blocked on IO", "blocked");
465}
466
467void svg_time_grid(void)
468{
469 u64 i;
470
471 if (!svgfile)
472 return;
473
474 i = first_time;
475 while (i < last_time) {
476 int color = 220;
477 double thickness = 0.075;
478 if ((i % 100000000) == 0) {
479 thickness = 0.5;
480 color = 192;
481 }
482 if ((i % 1000000000) == 0) {
483 thickness = 2.0;
484 color = 128;
485 }
486
487 fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%" PRIu64 "\" style=\"stroke:rgb(%i,%i,%i);stroke-width:%1.3f\"/>\n",
488 time2pixels(i), SLOT_MULT/2, time2pixels(i), total_height, color, color, color, thickness);
489
490 i += 10000000;
491 }
492}
493
494void svg_close(void)
495{
496 if (svgfile) {
497 fprintf(svgfile, "</svg>\n");
498 fclose(svgfile);
499 svgfile = NULL;
500 }
501}