iowatcher/plot.c

   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 }