Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
svghelper.c
Go to the documentation of this file.
1 /*
2  * svghelper.c - helper functions for outputting svg
3  *
4  * (C) Copyright 2009 Intel Corporation
5  *
6  * Authors:
7  * Arjan van de Ven <[email protected]>
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 
23 static u64 first_time, last_time;
24 static u64 turbo_frequency, max_freq;
25 
26 
27 #define SLOT_MULT 30.0
28 #define SLOT_HEIGHT 25.0
29 
30 int svg_page_width = 1000;
31 
32 #define MIN_TEXT_SIZE 0.01
33 
34 static u64 total_height;
35 static FILE *svgfile;
36 
37 static double cpu2slot(int cpu)
38 {
39  return 2 * cpu + 1;
40 }
41 
42 static double cpu2y(int cpu)
43 {
44  return cpu2slot(cpu) * SLOT_MULT;
45 }
46 
47 static 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  */
59 static 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 
74 void 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 
122 void 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 
131 void 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 
153 static 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 
171 void 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 
203 static 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 
236 void 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 
258 void 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 
282 void 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 
311 static 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 
335 void 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 
353 void 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 &gt;</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 &gt;</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 &lt;</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 &lt;</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 
400 void 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 
422 void 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 
433 void 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 
442 static 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 
453 void 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 
467 void 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 
494 void svg_close(void)
495 {
496  if (svgfile) {
497  fprintf(svgfile, "</svg>\n");
498  fclose(svgfile);
499  svgfile = NULL;
500  }
501 }
Generated on Thu Jan 10 2013 15:09:26 for Linux Kernel by   doxygen 1.8.2