• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2012 Fusion-io
3  *
4  *  This program is free software; you can redistribute it and/or
5  *  modify it under the terms of the GNU General Public
6  *  License v2 as published by the Free Software Foundation.
7  *
8  *  This program is distributed in the hope that it will be useful,
9  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
10  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  *  GNU General Public License for more details.
12  *
13  *  You should have received a copy of the GNU General Public License
14  *  along with this program; if not, write to the Free Software
15  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16  *
17  *  Parts of this file were imported from Jens Axboe's blktrace sources (also GPL)
18  */
19 #include <sys/types.h>
20 #include <sys/stat.h>
21 #include <fcntl.h>
22 #include <unistd.h>
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <math.h>
26 #include <inttypes.h>
27 #include <string.h>
28 #include <asm/types.h>
29 #include <errno.h>
30 #include <sys/mman.h>
31 #include <time.h>
32 #include <math.h>
33 
34 #include "plot.h"
35 
36 static int io_graph_scale = 8;
37 static int graph_width = 700;
38 static int graph_height = 250;
39 static int graph_circle_extra = 30;
40 static int graph_inner_x_margin = 2;
41 static int graph_inner_y_margin = 2;
42 static int graph_tick_len = 5;
43 static int graph_left_pad = 120;
44 static int tick_label_pad = 16;
45 static int tick_font_size = 15;
46 static char *font_family = "sans-serif";
47 
48 /* this is the title for the whole page */
49 static int plot_title_height = 50;
50 static int plot_title_font_size = 25;
51 
52 /* this is the label at the top of each plot */
53 static int plot_label_height = 60;
54 static int plot_label_font_size = 20;
55 
56 /* label for each axis is slightly smaller */
57 static int axis_label_font_size = 16;
58 
59 int legend_x_off = 45;
60 int legend_y_off = -10;
61 int legend_font_size = 15;
62 int legend_width = 80;
63 
64 static int rolling_avg_secs = 0;
65 
66 static int line_len = 1024;
67 static char line[1024];
68 
69 static int final_height = 0;
70 static int final_width = 0;
71 
72 static char *colors[] = {
73 	"blue", "darkgreen",
74 	"red",
75 	"darkviolet",
76 	"orange",
77 	"aqua",
78 	"brown", "#00FF00",
79 	"yellow", "coral",
80 	"black", "darkred",
81 	"fuchsia", "crimson",
82 	NULL };
83 
84 extern unsigned int longest_proc_name;
85 
pick_color(void)86 char *pick_color(void)
87 {
88 	static int color_index;
89 	char *ret = colors[color_index];
90 
91 	if (!ret) {
92 		color_index = 0;
93 		ret = colors[color_index];
94 	}
95 	color_index++;
96 	return ret;
97 }
98 
pick_fio_color(void)99 char *pick_fio_color(void)
100 {
101 	static int fio_color_index;
102 	char *ret = colors[fio_color_index];
103 
104 	if (!ret) {
105 		fio_color_index = 0;
106 		ret = colors[fio_color_index];
107 	}
108 	fio_color_index += 2;
109 	return ret;
110 }
111 
112 static int cpu_color_index;
113 
pick_cpu_color(void)114 char *pick_cpu_color(void)
115 {
116 	char *ret = colors[cpu_color_index];
117 	if (!ret) {
118 		cpu_color_index = 0;
119 		ret = colors[cpu_color_index];
120 	}
121 	cpu_color_index++;
122 	return ret;
123 }
124 
reset_cpu_color(void)125 void reset_cpu_color(void)
126 {
127 	cpu_color_index = 0;
128 }
129 
alloc_line_data(unsigned int min_seconds,unsigned int max_seconds,unsigned int stop_seconds)130 struct graph_line_data *alloc_line_data(unsigned int min_seconds,
131 					unsigned int max_seconds,
132 					unsigned int stop_seconds)
133 {
134 	int size = sizeof(struct graph_line_data) + (stop_seconds + 1) * sizeof(struct graph_line_pair);
135 	struct graph_line_data *gld;
136 
137 	gld = calloc(1, size);
138 	if (!gld) {
139 		fprintf(stderr, "Unable to allocate memory for graph data\n");
140 		exit(1);
141 	}
142 	gld->min_seconds = min_seconds;
143 	gld->max_seconds = max_seconds;
144 	gld->stop_seconds = stop_seconds;
145 	return gld;
146 }
147 
alloc_dot_data(unsigned int min_seconds,unsigned int max_seconds,u64 min_offset,u64 max_offset,unsigned int stop_seconds,char * color,char * label)148 struct graph_dot_data *alloc_dot_data(unsigned int min_seconds,
149 				      unsigned int max_seconds,
150 				      u64 min_offset, u64 max_offset,
151 				      unsigned int stop_seconds,
152 				      char *color, char *label)
153 {
154 	int size;
155 	int arr_size;
156 	int rows = graph_height * io_graph_scale;
157 	int cols = graph_width;
158 	struct graph_dot_data *gdd;
159 
160 	size = sizeof(struct graph_dot_data);
161 
162 	/* the number of bits */
163 	arr_size = (rows + 1) * cols;
164 
165 	/* the number of bytes */
166 	arr_size = (arr_size + 7) / 8;
167 
168 	gdd = calloc(1, size + arr_size);
169 	if (!gdd) {
170 		fprintf(stderr, "Unable to allocate memory for graph data\n");
171 		exit(1);
172 	}
173 	gdd->min_seconds = min_seconds;
174 	gdd->max_seconds = max_seconds;
175 	gdd->stop_seconds = stop_seconds;
176 	gdd->rows = rows;
177 	gdd->cols = cols;
178 	gdd->min_offset = min_offset;
179 	gdd->max_offset = max_offset;
180 	gdd->color = color;
181 	gdd->label = label;
182 
183 	if (strlen(label) > longest_proc_name)
184 		longest_proc_name = strlen(label);
185 
186 	return gdd;
187 }
188 
set_gdd_bit(struct graph_dot_data * gdd,u64 offset,double bytes,double time)189 void set_gdd_bit(struct graph_dot_data *gdd, u64 offset, double bytes, double time)
190 {
191 	double bytes_per_row = (double)(gdd->max_offset - gdd->min_offset + 1) / gdd->rows;
192 	double secs_per_col = (double)(gdd->max_seconds - gdd->min_seconds) / gdd->cols;
193 	double col;
194 	double row;
195 	int col_int;
196 	int row_int;
197 	int bit_index;
198 	int arr_index;
199 	int bit_mod;
200 	double mod = bytes_per_row;
201 
202 	if (offset > gdd->max_offset || offset < gdd->min_offset)
203 		return;
204 	time = time / 1000000000.0;
205 	if (time < gdd->min_seconds || time > gdd->max_seconds)
206 		return;
207 	gdd->total_ios++;
208 	while (bytes > 0 && offset <= gdd->max_offset) {
209 		row = (double)(offset - gdd->min_offset) / bytes_per_row;
210 		col = (time - gdd->min_seconds) / secs_per_col;
211 
212 		col_int = floor(col);
213 		row_int = floor(row);
214 		bit_index = row_int * gdd->cols + col_int;
215 		arr_index = bit_index / 8;
216 		bit_mod = bit_index % 8;
217 
218 		gdd->data[arr_index] |= 1 << bit_mod;
219 		offset += mod;
220 		bytes -= mod;
221 	}
222 }
223 
rolling_avg(struct graph_line_pair * data,int index,int distance)224 static double rolling_avg(struct graph_line_pair *data, int index, int distance)
225 {
226 	double sum = 0;
227 	int start;
228 
229 	if (distance < 0)
230 		distance = 1;
231 	if (distance > index) {
232 		start = 0;
233 	} else {
234 		start = index - distance;
235 	}
236 	distance = 0;
237 	while (start <= index) {
238 		double avg;
239 
240 		if (data[start].count)
241 			avg = ((double)data[start].sum) / data[start].count;
242 		else
243 			avg= 0;
244 
245 		sum += avg;
246 		distance++;
247 		start++;
248 	}
249 	return sum / distance;
250 }
251 
write_check(int fd,char * buf,size_t size)252 static void write_check(int fd, char *buf, size_t size)
253 {
254 	ssize_t ret;
255 
256 	ret = write(fd, buf, size);
257 	if (ret != (ssize_t)size) {
258 		if (ret < 0)
259 			perror("write failed");
260 		else
261 			fprintf(stderr, "error: short write\n");
262 		exit(1);
263 	}
264 }
265 
write_svg_header(int fd)266 void write_svg_header(int fd)
267 {
268 	char *spaces = "                                                    \n";
269 	char *header = "<svg  xmlns=\"http://www.w3.org/2000/svg\">\n";
270 	char *filter1 ="<filter id=\"shadow\">\n "
271 		"<feOffset result=\"offOut\" in=\"SourceAlpha\" dx=\"4\" dy=\"4\" />\n "
272 		"<feGaussianBlur result=\"blurOut\" in=\"offOut\" stdDeviation=\"2\" />\n "
273 		"<feBlend in=\"SourceGraphic\" in2=\"blurOut\" mode=\"normal\" />\n "
274 		"</filter>\n";
275 	char *filter2 ="<filter id=\"textshadow\" x=\"0\" y=\"0\" width=\"200%\" height=\"200%\">\n "
276 		"<feOffset result=\"offOut\" in=\"SourceAlpha\" dx=\"1\" dy=\"1\" />\n "
277 		"<feGaussianBlur result=\"blurOut\" in=\"offOut\" stdDeviation=\"1.5\" />\n "
278 		"<feBlend in=\"SourceGraphic\" in2=\"blurOut\" mode=\"normal\" />\n "
279 		"</filter>\n";
280 	char *filter3 ="<filter id=\"labelshadow\" x=\"0\" y=\"0\" width=\"200%\" height=\"200%\">\n "
281 		"<feOffset result=\"offOut\" in=\"SourceGraphic\" dx=\"3\" dy=\"3\" />\n "
282 		"<feColorMatrix result=\"matrixOut\" in=\"offOut\" type=\"matrix\" "
283 		"values=\"0.2 0 0 0 0 0 0.2 0 0 0 0 0 0.2 0 0 0 0 0 1 0\" /> "
284 		"<feGaussianBlur result=\"blurOut\" in=\"offOut\" stdDeviation=\"2\" />\n "
285 		"<feBlend in=\"SourceGraphic\" in2=\"blurOut\" mode=\"normal\" />\n "
286 		"</filter>\n";
287 	char *defs_start = "<defs>\n";
288 	char *defs_close = "</defs>\n";
289 	final_width = 0;
290 	final_height = 0;
291 
292 	write_check(fd, header, strlen(header));
293 	/* write a bunch of spaces so we can stuff in the width and height later */
294 	write_check(fd, spaces, strlen(spaces));
295 	write_check(fd, spaces, strlen(spaces));
296 	write_check(fd, spaces, strlen(spaces));
297 
298 	write_check(fd, defs_start, strlen(defs_start));
299 	write_check(fd, filter1, strlen(filter1));
300 	write_check(fd, filter2, strlen(filter2));
301 	write_check(fd, filter3, strlen(filter3));
302 	write_check(fd, defs_close, strlen(defs_close));
303 }
304 
305 /* svg y offset for the traditional 0,0 (bottom left corner) of the plot */
axis_y(void)306 static int axis_y(void)
307 {
308 	return plot_label_height + graph_height + graph_inner_y_margin;
309 }
310 
311 /* this gives you the correct pixel for a given offset from the bottom left y axis */
axis_y_off_double(double y)312 static double axis_y_off_double(double y)
313 {
314 	return plot_label_height + graph_height - y;
315 }
316 
axis_y_off(int y)317 static int axis_y_off(int y)
318 {
319 	return axis_y_off_double(y);
320 }
321 
322 /* svg x axis offset from 0 */
axis_x(void)323 static int axis_x(void)
324 {
325 	return graph_left_pad;
326 }
327 
328 /* the correct pixel for a given X offset */
axis_x_off_double(double x)329 static double axis_x_off_double(double x)
330 {
331 	return graph_left_pad + graph_inner_x_margin + x;
332 }
333 
axis_x_off(int x)334 static int axis_x_off(int x)
335 {
336 	return (int)axis_x_off_double(x);
337 }
338 
339 /*
340  * this draws a backing rectangle for the plot and it
341  * also creates a new svg element so our offsets can
342  * be relative to this one plot.
343  */
setup_axis(struct plot * plot)344 void setup_axis(struct plot *plot)
345 {
346 	int len;
347 	int fd = plot->fd;
348 	int bump_height = tick_font_size * 3 + axis_label_font_size;
349 	int local_legend_width = legend_width;
350 
351 	if (plot->no_legend)
352 		local_legend_width = 0;
353 
354 	plot->total_width = axis_x_off(graph_width) + graph_left_pad / 2 + local_legend_width;
355 	plot->total_height = axis_y() + tick_label_pad + tick_font_size;
356 
357 	if (plot->add_xlabel)
358 		plot->total_height += bump_height;
359 
360 	/* backing rect */
361 	snprintf(line, line_len, "<rect x=\"%d\" y=\"%d\" width=\"%d\" "
362 		 "height=\"%d\" fill=\"white\" stroke=\"none\"/>",
363 		 plot->start_x_offset,
364 		plot->start_y_offset, plot->total_width + 40,
365 		plot->total_height + 20);
366 	len = strlen(line);
367 	write_check(fd, line, len);
368 
369 	snprintf(line, line_len, "<rect x=\"%d\" y=\"%d\" width=\"%d\" "
370 		 "filter=\"url(#shadow)\" "
371 		 "height=\"%d\" fill=\"white\" stroke=\"none\"/>",
372 		 plot->start_x_offset + 15,
373 		plot->start_y_offset, plot->total_width, plot->total_height);
374 	len = strlen(line);
375 	write_check(fd, line, len);
376 	plot->total_height += 20;
377 	plot->total_width += 20;
378 
379 	if (plot->total_height + plot->start_y_offset > final_height)
380 		final_height = plot->total_height + plot->start_y_offset;
381 	if (plot->start_x_offset + plot->total_width + 40 > final_width)
382 		final_width = plot->start_x_offset + plot->total_width + 40;
383 
384 	/* create an svg object for all our coords to be relative against */
385 	snprintf(line, line_len, "<svg x=\"%d\" y=\"%d\">\n", plot->start_x_offset, plot->start_y_offset);
386 	write_check(fd, line, strlen(line));
387 
388 	snprintf(line, 1024, "<path d=\"M%d %d h %d V %d H %d Z\" stroke=\"black\" stroke-width=\"2\" fill=\"none\"/>\n",
389 		 axis_x(), axis_y(),
390 		 graph_width + graph_inner_x_margin * 2, axis_y_off(graph_height) - graph_inner_y_margin,
391 		 axis_x());
392 	len = strlen(line);
393 	write_check(fd, line, len);
394 }
395 
396 /*
397  * this draws a backing rectangle for the plot and it
398  * also creates a new svg element so our offsets can
399  * be relative to this one plot.
400  */
setup_axis_spindle(struct plot * plot)401 void setup_axis_spindle(struct plot *plot)
402 {
403 	int len;
404 	int fd = plot->fd;
405 	int bump_height = tick_font_size * 3 + axis_label_font_size;
406 
407 	legend_x_off = -60;
408 
409 	plot->total_width = axis_x_off(graph_width) + legend_width;
410 	plot->total_height = axis_y() + tick_label_pad + tick_font_size;
411 
412 	if (plot->add_xlabel)
413 		plot->total_height += bump_height;
414 
415 	/* backing rect */
416 	snprintf(line, line_len, "<rect x=\"%d\" y=\"%d\" width=\"%d\" "
417 		 "height=\"%d\" fill=\"white\" stroke=\"none\"/>",
418 		 plot->start_x_offset,
419 		plot->start_y_offset, plot->total_width + 10,
420 		plot->total_height + 20);
421 	len = strlen(line);
422 	write_check(fd, line, len);
423 
424 	snprintf(line, line_len, "<rect x=\"%d\" y=\"%d\" width=\"%d\" "
425 		 "filter=\"url(#shadow)\" "
426 		 "height=\"%d\" fill=\"white\" stroke=\"none\"/>",
427 		 plot->start_x_offset + 15,
428 		plot->start_y_offset, plot->total_width - 30,
429 		plot->total_height);
430 	len = strlen(line);
431 	write_check(fd, line, len);
432 	plot->total_height += 20;
433 
434 	if (plot->total_height + plot->start_y_offset > final_height)
435 		final_height = plot->total_height + plot->start_y_offset;
436 	if (plot->start_x_offset + plot->total_width + 40 > final_width)
437 		final_width = plot->start_x_offset + plot->total_width + 40;
438 
439 	/* create an svg object for all our coords to be relative against */
440 	snprintf(line, line_len, "<svg x=\"%d\" y=\"%d\">\n", plot->start_x_offset, plot->start_y_offset);
441 	write_check(fd, line, strlen(line));
442 
443 }
444 
445 /* draw a plot title.  This should be done only once,
446  * and it bumps the plot width/height numbers by
447  * what it draws.
448  *
449  * Call this before setting up the first axis
450  */
set_plot_title(struct plot * plot,char * title)451 void set_plot_title(struct plot *plot, char *title)
452 {
453 	int len;
454 	int fd = plot->fd;
455 
456 	plot->total_height = plot_title_height;
457 	plot->total_width = axis_x_off(graph_width) + graph_left_pad / 2 + legend_width;
458 
459 	/* backing rect */
460 	snprintf(line, line_len, "<rect x=\"0\" y=\"%d\" width=\"%d\" height=\"%d\" fill=\"white\" stroke=\"none\"/>",
461 		plot->start_y_offset, plot->total_width + 40, plot_title_height + 20);
462 	len = strlen(line);
463 	write_check(fd, line, len);
464 
465 	snprintf(line, line_len, "<text x=\"%d\" y=\"%d\" font-family=\"%s\" font-size=\"%d\" "
466 		 "font-weight=\"bold\" fill=\"black\" style=\"text-anchor: %s\">%s</text>\n",
467 		 axis_x_off(graph_width / 2),
468 		plot->start_y_offset + plot_title_height / 2,
469 		font_family, plot_title_font_size, "middle", title);
470 	plot->start_y_offset += plot_title_height;
471 	len = strlen(line);
472 	write_check(fd, line, len);
473 }
474 
475 #define TICK_MINI_STEPS 3
476 
find_step(double first,double last,int num_ticks)477 static double find_step(double first, double last, int num_ticks)
478 {
479 	int mini_step[TICK_MINI_STEPS] = { 1, 2, 5 };
480 	int cur_mini_step = 0;
481 	double step = (last - first) / num_ticks;
482 	double log10 = log(10);
483 
484 	/* Round to power of 10 */
485 	step = exp(floor(log(step) / log10) * log10);
486 	/* Scale down step to provide enough ticks */
487 	while (cur_mini_step < TICK_MINI_STEPS
488 	       && (last - first) / (step * mini_step[cur_mini_step]) > num_ticks)
489 		cur_mini_step++;
490 
491 	if (cur_mini_step > 0)
492 		step *= mini_step[cur_mini_step - 1];
493 
494 	return step;
495 }
496 
497 /*
498  * create evenly spread out ticks along the xaxis.  if tick only is set
499  * this just makes the ticks, otherwise it labels each tick as it goes
500  */
set_xticks(struct plot * plot,int num_ticks,int first,int last)501 void set_xticks(struct plot *plot, int num_ticks, int first, int last)
502 {
503 	int pixels_per_tick;
504 	double step;
505 	int i;
506 	int tick_y = axis_y_off(graph_tick_len) + graph_inner_y_margin;
507 	int tick_x = axis_x();
508 	int tick_only = plot->add_xlabel == 0;
509 
510 	int text_y = axis_y() + tick_label_pad;
511 
512 	char *middle = "middle";
513 	char *start = "start";
514 
515 	step = find_step(first, last, num_ticks);
516 	/*
517 	 * We don't want last two ticks to be too close together so subtract
518 	 * 20% of the step from the interval
519 	 */
520 	num_ticks = (double)(last - first - step) / step + 1;
521 	pixels_per_tick = graph_width * step / (double)(last - first);
522 
523 	for (i = 0; i < num_ticks; i++) {
524 		char *anchor;
525 		if (i != 0) {
526 			snprintf(line, line_len, "<rect x=\"%d\" y=\"%d\" width=\"2\" height=\"%d\" style=\"stroke:none;fill:black;\"/>\n",
527 				tick_x, tick_y, graph_tick_len);
528 			write_check(plot->fd, line, strlen(line));
529 			anchor = middle;
530 		} else {
531 			anchor = start;
532 		}
533 
534 		if (!tick_only) {
535 			if (step >= 1)
536 				snprintf(line, line_len, "<text x=\"%d\" y=\"%d\" font-family=\"%s\" font-size=\"%d\" "
537 					"fill=\"black\" style=\"text-anchor: %s\">%d</text>\n",
538 					tick_x, text_y, font_family, tick_font_size, anchor,
539 					(int)(first + step * i));
540 			else
541 				snprintf(line, line_len, "<text x=\"%d\" y=\"%d\" font-family=\"%s\" font-size=\"%d\" "
542 					"fill=\"black\" style=\"text-anchor: %s\">%.2f</text>\n",
543 					tick_x, text_y, font_family, tick_font_size, anchor,
544 					first + step * i);
545 			write_check(plot->fd, line, strlen(line));
546 		}
547 		tick_x += pixels_per_tick;
548 	}
549 
550 	if (!tick_only) {
551 		if (step >= 1)
552 			snprintf(line, line_len, "<text x=\"%d\" y=\"%d\" font-family=\"%s\" font-size=\"%d\" "
553 				"fill=\"black\" style=\"text-anchor: middle\">%d</text>\n",
554 				axis_x_off(graph_width - 2),
555 				text_y, font_family, tick_font_size, last);
556 		else
557 			snprintf(line, line_len, "<text x=\"%d\" y=\"%d\" font-family=\"%s\" font-size=\"%d\" "
558 				"fill=\"black\" style=\"text-anchor: middle\">%.2f</text>\n",
559 				axis_x_off(graph_width - 2),
560 				text_y, font_family, tick_font_size, (double)last);
561 		write_check(plot->fd, line, strlen(line));
562 	}
563 }
564 
set_ylabel(struct plot * plot,char * label)565 void set_ylabel(struct plot *plot, char *label)
566 {
567 	int len;
568 	int fd = plot->fd;
569 
570 	snprintf(line, line_len, "<text x=\"%d\" y=\"%d\" font-family=\"%s\" "
571 		 "transform=\"rotate(-90 %d %d)\" font-weight=\"bold\" "
572 		 "font-size=\"%d\" fill=\"black\" style=\"text-anchor: %s\">%s</text>\n",
573 		 graph_left_pad / 2 - axis_label_font_size,
574 		 axis_y_off(graph_height / 2),
575 		 font_family,
576 		 graph_left_pad / 2 - axis_label_font_size,
577 		 (int)axis_y_off(graph_height / 2),
578 		 axis_label_font_size, "middle", label);
579 	len = strlen(line);
580 	write_check(fd, line, len);
581 }
582 
set_xlabel(struct plot * plot,char * label)583 void set_xlabel(struct plot *plot, char *label)
584 {
585 	int len;
586 	int fd = plot->fd;
587 	snprintf(line, line_len, "<text x=\"%d\" y=\"%d\" font-family=\"%s\" "
588 		 "font-weight=\"bold\" "
589 		 "font-size=\"%d\" fill=\"black\" style=\"text-anchor: %s\">%s</text>\n",
590 		 axis_x_off(graph_width / 2),
591 		 axis_y() + tick_font_size * 3 + axis_label_font_size / 2,
592 		 font_family,
593 		 axis_label_font_size, "middle", label);
594 	len = strlen(line);
595 	write_check(fd, line, len);
596 
597 }
598 
599 /*
600  * create evenly spread out ticks along the y axis.
601  * The ticks are labeled as it goes
602  */
set_yticks(struct plot * plot,int num_ticks,int first,int last,char * units)603 void set_yticks(struct plot *plot, int num_ticks, int first, int last, char *units)
604 {
605 	int pixels_per_tick = graph_height / num_ticks;
606 	int step = (last - first) / num_ticks;
607 	int i;
608 	int tick_y = 0;
609 	int text_x = axis_x() - 6;
610 	int tick_x = axis_x();
611 	char *anchor = "end";
612 
613 	for (i = 0; i < num_ticks; i++) {
614 		if (i != 0) {
615 			snprintf(line, line_len, "<line x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" "
616 				 "style=\"stroke:lightgray;stroke-width:2;stroke-dasharray:9,12;\"/>\n",
617 				tick_x, axis_y_off(tick_y),
618 				axis_x_off(graph_width), axis_y_off(tick_y));
619 			write_check(plot->fd, line, strlen(line));
620 		}
621 
622 		snprintf(line, line_len, "<text x=\"%d\" y=\"%d\" font-family=\"%s\" font-size=\"%d\" "
623 			 "fill=\"black\" style=\"text-anchor: %s\">%d%s</text>\n",
624 			text_x,
625 			axis_y_off(tick_y - tick_font_size / 2),
626 			font_family, tick_font_size, anchor, first + step * i, units);
627 		write_check(plot->fd, line, strlen(line));
628 		tick_y += pixels_per_tick;
629 	}
630 	snprintf(line, line_len, "<text x=\"%d\" y=\"%d\" font-family=\"%s\" font-size=\"%d\" "
631 		 "fill=\"black\" style=\"text-anchor: %s\">%d%s</text>\n",
632 		 text_x, axis_y_off(graph_height), font_family, tick_font_size, anchor, last, units);
633 	write_check(plot->fd, line, strlen(line));
634 }
635 
set_plot_label(struct plot * plot,char * label)636 void set_plot_label(struct plot *plot, char *label)
637 {
638 	int len;
639 	int fd = plot->fd;
640 
641 	snprintf(line, line_len, "<text x=\"%d\" y=\"%d\" font-family=\"%s\" "
642 		 "font-size=\"%d\" fill=\"black\" style=\"text-anchor: %s\">%s</text>\n",
643 		 axis_x() + graph_width / 2,
644 		 plot_label_height / 2,
645 		font_family, plot_label_font_size, "middle", label);
646 	len = strlen(line);
647 	write_check(fd, line, len);
648 }
649 
close_svg(int fd)650 static void close_svg(int fd)
651 {
652 	char *close_line = "</svg>\n";
653 
654 	write_check(fd, close_line, strlen(close_line));
655 }
656 
close_plot(struct plot * plot)657 int close_plot(struct plot *plot)
658 {
659 	close_svg(plot->fd);
660 	if (plot->direction == PLOT_DOWN)
661 		plot->start_y_offset += plot->total_height;
662 	else if (plot->direction == PLOT_ACROSS)
663 		plot->start_x_offset += plot->total_width;
664 	return 0;
665 }
666 
alloc_plot(void)667 struct plot *alloc_plot(void)
668 {
669 	struct plot *plot;
670 	plot = calloc(1, sizeof(*plot));
671 	if (!plot) {
672 		fprintf(stderr, "Unable to allocate memory %s\n", strerror(errno));
673 		exit(1);
674 	}
675 	plot->fd = 0;
676 	return plot;
677 }
678 
close_plot_file(struct plot * plot)679 int close_plot_file(struct plot *plot)
680 {
681 	int ret;
682 	ret = lseek(plot->fd, 0, SEEK_SET);
683 	if (ret == (off_t)-1) {
684 		perror("seek");
685 		exit(1);
686 	}
687 	final_width = ((final_width  + 1) / 2) * 2;
688 	final_height = ((final_height  + 1) / 2) * 2;
689 	snprintf(line, line_len, "<svg  xmlns=\"http://www.w3.org/2000/svg\" "
690 		 "width=\"%d\" height=\"%d\">\n",
691 		 final_width, final_height);
692 	write_check(plot->fd, line, strlen(line));
693 	snprintf(line, line_len, "<rect x=\"0\" y=\"0\" width=\"%d\" "
694 		 "height=\"%d\" fill=\"white\"/>\n", final_width, final_height);
695 	write_check(plot->fd, line, strlen(line));
696 	close(plot->fd);
697 	plot->fd = 0;
698 	return 0;
699 }
700 
set_plot_output(struct plot * plot,char * filename)701 void set_plot_output(struct plot *plot, char *filename)
702 {
703 	int fd;
704 
705 	if (plot->fd)
706 		close_plot_file(plot);
707 	fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY, 0600);
708 	if (fd < 0) {
709 		fprintf(stderr, "Unable to open output file %s err %s\n", filename, strerror(errno));
710 		exit(1);
711 	}
712 	plot->fd = fd;
713 	plot->start_y_offset = plot->start_x_offset = 0;
714 	write_svg_header(fd);
715 }
716 
717 char *byte_unit_names[] = { "", "K", "M", "G", "T", "P", "E", "Z", "Y", "unobtainium" };
718 int MAX_BYTE_UNIT_SCALE = 9;
719 
720 char *time_unit_names[] = { "n", "u", "m", "s" };
721 int MAX_TIME_UNIT_SCALE = 3;
722 
scale_line_graph_bytes(u64 * max,char ** units,u64 factor)723 void scale_line_graph_bytes(u64 *max, char **units, u64 factor)
724 {
725 	int scale = 0;
726 	u64 val = *max;
727 	u64 div = 1;
728 	while (val > factor * 64) {
729 		val /= factor;
730 		scale++;
731 		div *= factor;
732 	}
733 	*units = byte_unit_names[scale];
734 	if (scale == 0)
735 		return;
736 
737 	if (scale > MAX_BYTE_UNIT_SCALE)
738 		scale = MAX_BYTE_UNIT_SCALE;
739 
740 	*max /= div;
741 }
742 
scale_line_graph_time(u64 * max,char ** units)743 void scale_line_graph_time(u64 *max, char **units)
744 {
745 	int scale = 0;
746 	u64 val = *max;
747 	u64 div = 1;
748 	while (val > 1000 * 10) {
749 		val /= 1000;
750 		scale++;
751 		div *= 1000;
752 		if (scale == MAX_TIME_UNIT_SCALE)
753 			break;
754 	}
755 	*units = time_unit_names[scale];
756 	if (scale == 0)
757 		return;
758 
759 	*max /= div;
760 }
761 
rolling_span(struct graph_line_data * gld)762 static int rolling_span(struct graph_line_data *gld)
763 {
764 	if (rolling_avg_secs)
765 		return rolling_avg_secs;
766 	return (gld->stop_seconds - gld->min_seconds) / 25;
767 }
768 
769 
line_graph_roll_avg_max(struct graph_line_data * gld)770 double line_graph_roll_avg_max(struct graph_line_data *gld)
771 {
772 	unsigned int i;
773 	int rolling;
774 	double avg, max = 0;
775 
776 	rolling = rolling_span(gld);
777 	for (i = gld->min_seconds; i < gld->stop_seconds; i++) {
778 		avg = rolling_avg(gld->data, i, rolling);
779 		if (avg > max)
780 			max = avg;
781 	}
782 	return max;
783 }
784 
svg_line_graph(struct plot * plot,struct graph_line_data * gld,char * color,int thresh1,int thresh2)785 int svg_line_graph(struct plot *plot, struct graph_line_data *gld, char *color, int thresh1, int thresh2)
786 {
787 	unsigned int i;
788 	double val;
789 	double avg;
790 	int rolling;
791 	int fd = plot->fd;
792 	char *start = "<path d=\"";
793 	double yscale = ((double)gld->max) / graph_height;
794 	double xscale = (double)(gld->max_seconds - gld->min_seconds - 1) / graph_width;
795 	char c = 'M';
796 	double x;
797 	int printed_header = 0;
798 	int printed_lines = 0;
799 
800 	if (thresh1 && thresh2)
801 		rolling = 0;
802 	else
803 		rolling = rolling_span(gld);
804 
805 	for (i = gld->min_seconds; i < gld->stop_seconds; i++) {
806 		avg = rolling_avg(gld->data, i, rolling);
807 		if (yscale == 0)
808 			val = 0;
809 		else
810 			val = avg / yscale;
811 
812 		if (val > graph_height)
813 			val = graph_height;
814 		if (val < 0)
815 			val = 0;
816 
817 		x = (double)(i - gld->min_seconds) / xscale;
818 		if (!thresh1 && !thresh2) {
819 			if (!printed_header) {
820 				write_check(fd, start, strlen(start));
821 				printed_header = 1;
822 			}
823 
824 			/* in full line mode, everything in the graph is connected */
825 			snprintf(line, line_len, "%c %d %d ", c, axis_x_off(x), axis_y_off(val));
826 			c = 'L';
827 			write_check(fd, line, strlen(line));
828 			printed_lines = 1;
829 		} else if (avg > thresh1 || avg > thresh2) {
830 			int len = 10;
831 			if (!printed_header) {
832 				write_check(fd, start, strlen(start));
833 				printed_header = 1;
834 			}
835 
836 			/* otherwise, we just print a bar up there to show this one data point */
837 			if (i >= gld->stop_seconds - 2)
838 				len = -10;
839 
840 			/*
841 			 * we don't use the rolling averages here to show high
842 			 * points in the data
843 			 */
844 			snprintf(line, line_len, "M %d %d h %d ", axis_x_off(x),
845 				 axis_y_off(val), len);
846 			write_check(fd, line, strlen(line));
847 			printed_lines = 1;
848 		}
849 
850 	}
851 	if (printed_lines) {
852 		snprintf(line, line_len, "\" fill=\"none\" stroke=\"%s\" stroke-width=\"2\"/>\n", color);
853 		write_check(fd, line, strlen(line));
854 	}
855 	if (plot->timeline)
856 		svg_write_time_line(plot, plot->timeline);
857 
858 	return 0;
859 }
860 
svg_write_time_line(struct plot * plot,int col)861 void svg_write_time_line(struct plot *plot, int col)
862 {
863 	snprintf(line, line_len, "<line x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" "
864 				 "style=\"stroke:black;stroke-width:2;\"/>\n",
865 				 axis_x_off(col), axis_y_off(0),
866 				 axis_x_off(col), axis_y_off(graph_height));
867 	write_check(plot->fd, line, strlen(line));
868 }
869 
svg_add_io(int fd,double row,double col,double width,double height,char * color)870 static void svg_add_io(int fd, double row, double col, double width, double height, char *color)
871 {
872 	float rx = 0;
873 
874 	snprintf(line, line_len, "<rect x=\"%.2f\" y=\"%.2f\" width=\"%.1f\" height=\"%.1f\" "
875 		 "rx=\"%.2f\" style=\"stroke:none;fill:%s;stroke-width:0\"/>\n",
876 		 axis_x_off_double(col), axis_y_off_double(row), width, height, rx, color);
877 	write_check(fd, line, strlen(line));
878 }
879 
svg_io_graph_movie_array(struct plot * plot,struct pid_plot_history * pph)880 int svg_io_graph_movie_array(struct plot *plot, struct pid_plot_history *pph)
881 {
882 	double cell_index;
883 	double movie_row;
884 	double movie_col;
885 	int i;
886 
887 	for (i = 0; i < pph->num_used; i++) {
888 		cell_index = pph->history[i];
889 		movie_row = floor(cell_index / graph_width);
890 		movie_col = cell_index - movie_row * graph_width;
891 		svg_add_io(plot->fd, movie_row, movie_col, 4, 4, pph->color);
892 	}
893 	return 0;
894 }
895 
896 static float spindle_steps = 0;
897 
rewind_spindle_steps(int num)898 void rewind_spindle_steps(int num)
899 {
900 	spindle_steps -= num * 0.01;
901 }
902 
svg_io_graph_movie_array_spindle(struct plot * plot,struct pid_plot_history * pph)903 int svg_io_graph_movie_array_spindle(struct plot *plot, struct pid_plot_history *pph)
904 {
905 	double cell_index;
906 	int i;
907 	int num_circles = 0;
908 	double cells_per_circle;
909 	double circle_num;
910 	double degrees_per_cell;
911 	double rot;
912 	double center_x;
913 	double center_y;
914 	double graph_width_extra = graph_width + graph_circle_extra;
915 	double graph_height_extra = graph_height + graph_circle_extra;
916 	double radius;;
917 
918 	if (graph_width_extra > graph_height_extra)
919 		graph_width_extra = graph_height_extra;
920 
921 	if (graph_width_extra < graph_height_extra)
922 		graph_height_extra = graph_width_extra;
923 
924 	radius = graph_width_extra;
925 
926 	center_x = axis_x_off_double(graph_width_extra / 2);
927 	center_y = axis_y_off_double(graph_height_extra / 2);
928 
929 	snprintf(line, line_len, "<g transform=\"rotate(%.4f, %.2f, %.2f)\"> "
930 		 "<circle cx=\"%.2f\" cy=\"%.2f\" "
931 		 "stroke=\"black\" stroke-width=\"6\" "
932 		 "r=\"%.2f\" fill=\"none\"/>\n",
933 		 spindle_steps * 1.2, center_x, center_y, center_x, center_y, graph_width_extra / 2);
934 	write_check(plot->fd, line, strlen(line));
935 	snprintf(line, line_len, "<circle cx=\"%.2f\" cy=\"%.2f\" "
936 		"stroke=\"none\" fill=\"red\" r=\"%.2f\"/>\n</g>\n",
937 		axis_x_off_double(graph_width_extra), center_y, 4.5);
938 	write_check(plot->fd, line, strlen(line));
939 	spindle_steps += 0.01;
940 
941 	radius = floor(radius / 2);
942 	num_circles = radius / 4 - 3;
943 	cells_per_circle = pph->history_max / num_circles;
944 	degrees_per_cell = 360 / cells_per_circle;
945 
946 	for (i = 0; i < pph->num_used; i++) {
947 		cell_index = pph->history[i];
948 		circle_num = floor(cell_index / cells_per_circle);
949 		rot = cell_index - circle_num * cells_per_circle;
950 		circle_num = num_circles - circle_num;
951 		radius = circle_num * 4;
952 
953 		rot = rot * degrees_per_cell;
954 		rot -= spindle_steps;
955 		snprintf(line, line_len, "<path transform=\"rotate(%.4f, %.2f, %.2f)\" "
956 			 "d=\"M %.2f %.2f a %.2f %.2f 0 0 1 0 5\" "
957 			 "stroke=\"%s\" stroke-width=\"4\"/>\n",
958 			 -rot, center_x, center_y,
959 			 axis_x_off_double(graph_width_extra / 2 + radius) + 8, center_y,
960 			 radius, radius, pph->color);
961 
962 		write_check(plot->fd, line, strlen(line));
963 	}
964 	return 0;
965 }
966 
add_plot_history(struct pid_plot_history * pph,double val)967 static int add_plot_history(struct pid_plot_history *pph, double val)
968 {
969 	if (pph->num_used == pph->history_len) {
970 		pph->history_len += 4096;
971 		pph->history = realloc(pph->history,
972 				       pph->history_len * sizeof(double));
973 		if (!pph->history) {
974 			perror("Unable to allocate memory");
975 			exit(1);
976 		}
977 	}
978 	pph->history[pph->num_used++] = val;
979 	return 0;
980 }
981 
svg_io_graph_movie(struct graph_dot_data * gdd,struct pid_plot_history * pph,int col)982 int svg_io_graph_movie(struct graph_dot_data *gdd, struct pid_plot_history *pph, int col)
983 {
984 	int row = 0;
985 	int arr_index;
986 	unsigned char val;
987 	int bit_index;
988 	int bit_mod;
989 	double blocks_per_row = (gdd->max_offset - gdd->min_offset + 1) / gdd->rows;
990 	double movie_blocks_per_cell = (gdd->max_offset - gdd->min_offset + 1) / (graph_width * graph_height);
991 	double cell_index;
992 	int margin_orig = graph_inner_y_margin;
993 
994 	graph_inner_y_margin += 5;
995 	pph->history_max = (gdd->max_offset - gdd->min_offset + 1) / movie_blocks_per_cell;
996 
997 	for (row = gdd->rows - 1; row >= 0; row--) {
998 		bit_index = row * gdd->cols + col;
999 		arr_index = bit_index / 8;
1000 		bit_mod = bit_index % 8;
1001 
1002 		if (arr_index < 0)
1003 			continue;
1004 		val = gdd->data[arr_index];
1005 		if (val & (1 << bit_mod)) {
1006 			/* in bytes, linear offset from the start of the drive */
1007 			cell_index = (double)row * blocks_per_row;
1008 
1009 			/* a cell number in the graph */
1010 			cell_index /= movie_blocks_per_cell;
1011 
1012 			add_plot_history(pph, cell_index);
1013 		}
1014 	}
1015 	graph_inner_y_margin = margin_orig;
1016 	return 0;
1017 }
1018 
svg_io_graph(struct plot * plot,struct graph_dot_data * gdd)1019 int svg_io_graph(struct plot *plot, struct graph_dot_data *gdd)
1020 {
1021 	int fd = plot->fd;;
1022 	int col = 0;
1023 	int row = 0;
1024 	int arr_index;
1025 	unsigned char val;
1026 	int bit_index;
1027 	int bit_mod;
1028 
1029 	for (row = gdd->rows - 1; row >= 0; row--) {
1030 		for (col = 0; col < gdd->cols; col++) {
1031 			bit_index = row * gdd->cols + col;
1032 			arr_index = bit_index / 8;
1033 			bit_mod = bit_index % 8;
1034 
1035 			if (arr_index < 0)
1036 				continue;
1037 			val = gdd->data[arr_index];
1038 			if (val & (1 << bit_mod))
1039 				svg_add_io(fd, floor(row / io_graph_scale), col, 1.5, 1.5, gdd->color);
1040 		}
1041 	}
1042 	return 0;
1043 }
1044 
svg_alloc_legend(struct plot * plot,int num_lines)1045 void svg_alloc_legend(struct plot *plot, int num_lines)
1046 {
1047 	char **lines = calloc(num_lines, sizeof(char *));
1048 	plot->legend_index = 0;
1049 	plot->legend_lines = lines;
1050 	plot->num_legend_lines = num_lines;
1051 }
1052 
svg_free_legend(struct plot * plot)1053 void svg_free_legend(struct plot *plot)
1054 {
1055 	int i;
1056 	for (i = 0; i < plot->legend_index; i++)
1057 		free(plot->legend_lines[i]);
1058 	free(plot->legend_lines);
1059 	plot->legend_lines = NULL;
1060 	plot->legend_index = 0;
1061 }
1062 
svg_write_legend(struct plot * plot)1063 void svg_write_legend(struct plot *plot)
1064 {
1065 	int legend_line_x = axis_x_off(graph_width) + legend_x_off;
1066 	int legend_line_y = axis_y_off(graph_height) + legend_y_off;
1067 	int i;
1068 
1069 	if (plot->legend_index == 0)
1070 		return;
1071 
1072 	snprintf(line, line_len, "<rect x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" "
1073 		 "fill=\"white\" filter=\"url(#shadow)\"/>\n",
1074 		 legend_line_x - 15,
1075 		 legend_line_y - 12,
1076 		 legend_width,
1077 		 plot->legend_index * legend_font_size + legend_font_size / 2 + 12);
1078 
1079 	write_check(plot->fd, line, strlen(line));
1080 	for (i = 0; i < plot->legend_index; i++) {
1081 		write_check(plot->fd, plot->legend_lines[i],
1082 		      strlen(plot->legend_lines[i]));
1083 		free(plot->legend_lines[i]);
1084 	}
1085 	free(plot->legend_lines);
1086 	plot->legend_lines = NULL;
1087 	plot->legend_index = 0;
1088 }
1089 
svg_add_legend(struct plot * plot,char * text,char * extra,char * color)1090 void svg_add_legend(struct plot *plot, char *text, char *extra, char *color)
1091 {
1092 	int legend_line_x = axis_x_off(graph_width) + legend_x_off;
1093 	int legend_line_y = axis_y_off(graph_height) + legend_y_off;
1094 
1095 	if (!text && (!extra || strlen(extra) == 0))
1096 		return;
1097 
1098 	legend_line_y += plot->legend_index * legend_font_size + legend_font_size / 2;
1099 	snprintf(line, line_len, "<path d=\"M %d %d h 8\" stroke=\"%s\" stroke-width=\"8\" "
1100 		 "filter=\"url(#labelshadow)\"/> "
1101 		 "<text x=\"%d\" y=\"%d\" font-family=\"%s\" font-size=\"%d\" "
1102 		 "fill=\"black\" style=\"text-anchor: left\">%s%s</text>\n",
1103 		 legend_line_x, legend_line_y,
1104 		 color, legend_line_x + 13,
1105 		 legend_line_y + 4, font_family, legend_font_size,
1106 		 text, extra);
1107 
1108 	plot->legend_lines[plot->legend_index++] = strdup(line);
1109 }
1110 
set_legend_width(int longest_str)1111 void set_legend_width(int longest_str)
1112 {
1113 	if (longest_str)
1114 		legend_width = longest_str * (legend_font_size * 3 / 4) + 25;
1115 	else
1116 		legend_width = 0;
1117 }
1118 
set_rolling_avg(int rolling)1119 void set_rolling_avg(int rolling)
1120 {
1121 	rolling_avg_secs = rolling;
1122 }
1123 
set_io_graph_scale(int scale)1124 void set_io_graph_scale(int scale)
1125 {
1126 	io_graph_scale = scale;
1127 }
1128 
set_graph_size(int width,int height)1129 void set_graph_size(int width, int height)
1130 {
1131 	graph_width = width;
1132 	graph_height = height;
1133 }
1134 
get_graph_size(int * width,int * height)1135 void get_graph_size(int *width, int *height)
1136 {
1137 	*width = graph_width;
1138 	*height = graph_height;
1139 }
1140 
set_graph_height(int h)1141 void set_graph_height(int h)
1142 {
1143 	graph_height = h;
1144 }
set_graph_width(int w)1145 void set_graph_width(int w)
1146 {
1147 	graph_width = w;
1148 }
1149