| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 125 | void reset_cpu_color(void) |
| | 126 | { |
| | 127 | cpu_color_index = 0; |
| | 128 | } |
| | 129 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 */ |
| | 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 */ |
| | 312 | static double axis_y_off_double(double y) |
| | 313 | { |
| | 314 | return plot_label_height + graph_height - y; |
| | 315 | } |
| | 316 | |
| | 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 */ |
| | 323 | static int axis_x(void) |
| | 324 | { |
| | 325 | return graph_left_pad; |
| | 326 | } |
| | 327 | |
| | 328 | /* the correct pixel for a given X offset */ |
| | 329 | static double axis_x_off_double(double x) |
| | 330 | { |
| | 331 | return graph_left_pad + graph_inner_x_margin + x; |
| | 332 | } |
| | 333 | |
| | 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 | */ |
| | 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 | */ |
| | 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 | */ |
| | 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 | |
| | 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 | */ |
| | 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 | |
| | 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 | |
| | 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 | */ |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 898 | void rewind_spindle_steps(int num) |
| | 899 | { |
| | 900 | spindle_steps -= num * 0.01; |
| | 901 | } |
| | 902 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 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 | |
| | 1119 | void set_rolling_avg(int rolling) |
| | 1120 | { |
| | 1121 | rolling_avg_secs = rolling; |
| | 1122 | } |
| | 1123 | |
| | 1124 | void set_io_graph_scale(int scale) |
| | 1125 | { |
| | 1126 | io_graph_scale = scale; |
| | 1127 | } |
| | 1128 | |
| | 1129 | void set_graph_size(int width, int height) |
| | 1130 | { |
| | 1131 | graph_width = width; |
| | 1132 | graph_height = height; |
| | 1133 | } |
| | 1134 | |
| | 1135 | void get_graph_size(int *width, int *height) |
| | 1136 | { |
| | 1137 | *width = graph_width; |
| | 1138 | *height = graph_height; |
| | 1139 | } |
| | 1140 | |
| | 1141 | void set_graph_height(int h) |
| | 1142 | { |
| | 1143 | graph_height = h; |
| | 1144 | } |
| | 1145 | void set_graph_width(int w) |
| | 1146 | { |
| | 1147 | graph_width = w; |
| | 1148 | } |
projects / blktrace.git / blame_incremental