| #!/usr/bin/perl -w | |
| # | |
| # flamegraph.pl flame stack grapher. | |
| # | |
| # This takes stack samples and renders a call graph, allowing hot functions | |
| # and codepaths to be quickly identified. Stack samples can be generated using | |
| # tools such as DTrace, perf, SystemTap, and Instruments. | |
| # | |
| # USAGE: ./flamegraph.pl [options] input.txt > graph.svg | |
| # | |
| # grep funcA input.txt | ./flamegraph.pl [options] > graph.svg | |
| # | |
| # Then open the resulting .svg in a web browser, for interactivity: mouse-over | |
| # frames for info, click to zoom, and ctrl-F to search. | |
| # | |
| # Options are listed in the usage message (--help). | |
| # | |
| # The input is stack frames and sample counts formatted as single lines. Each | |
| # frame in the stack is semicolon separated, with a space and count at the end | |
| # of the line. These can be generated for Linux perf script output using | |
| # stackcollapse-perf.pl, for DTrace using stackcollapse.pl, and for other tools | |
| # using the other stackcollapse programs. Example input: | |
| # | |
| # swapper;start_kernel;rest_init;cpu_idle;default_idle;native_safe_halt 1 | |
| # | |
| # An optional extra column of counts can be provided to generate a differential | |
| # flame graph of the counts, colored red for more, and blue for less. This | |
| # can be useful when using flame graphs for non-regression testing. | |
| # See the header comment in the difffolded.pl program for instructions. | |
| # | |
| # The input functions can optionally have annotations at the end of each | |
| # function name, following a precedent by some tools (Linux perf's _[k]): | |
| # _[k] for kernel | |
| # _[i] for inlined | |
| # _[j] for jit | |
| # _[w] for waker | |
| # Some of the stackcollapse programs support adding these annotations, eg, | |
| # stackcollapse-perf.pl --kernel --jit. They are used merely for colors by | |
| # some palettes, eg, flamegraph.pl --color=java. | |
| # | |
| # The output flame graph shows relative presence of functions in stack samples. | |
| # The ordering on the x-axis has no meaning; since the data is samples, time | |
| # order of events is not known. The order used sorts function names | |
| # alphabetically. | |
| # | |
| # While intended to process stack samples, this can also process stack traces. | |
| # For example, tracing stacks for memory allocation, or resource usage. You | |
| # can use --title to set the title to reflect the content, and --countname | |
| # to change "samples" to "bytes" etc. | |
| # | |
| # There are a few different palettes, selectable using --color. By default, | |
| # the colors are selected at random (except for differentials). Functions | |
| # called "-" will be printed gray, which can be used for stack separators (eg, | |
| # between user and kernel stacks). | |
| # | |
| # HISTORY | |
| # | |
| # This was inspired by Neelakanth Nadgir's excellent function_call_graph.rb | |
| # program, which visualized function entry and return trace events. As Neel | |
| # wrote: "The output displayed is inspired by Roch's CallStackAnalyzer which | |
| # was in turn inspired by the work on vftrace by Jan Boerhout". See: | |
| # https://blogs.oracle.com/realneel/entry/visualizing_callstacks_via_dtrace_and | |
| # | |
| # Copyright 2016 Netflix, Inc. | |
| # Copyright 2011 Joyent, Inc. All rights reserved. | |
| # Copyright 2011 Brendan Gregg. All rights reserved. | |
| # | |
| # CDDL HEADER START | |
| # | |
| # The contents of this file are subject to the terms of the | |
| # Common Development and Distribution License (the "License"). | |
| # You may not use this file except in compliance with the License. | |
| # | |
| # You can obtain a copy of the license at docs/cddl1.txt or | |
| # http://opensource.org/licenses/CDDL-1.0. | |
| # See the License for the specific language governing permissions | |
| # and limitations under the License. | |
| # | |
| # When distributing Covered Code, include this CDDL HEADER in each | |
| # file and include the License file at docs/cddl1.txt. | |
| # If applicable, add the following below this CDDL HEADER, with the | |
| # fields enclosed by brackets "[]" replaced with your own identifying | |
| # information: Portions Copyright [yyyy] [name of copyright owner] | |
| # | |
| # CDDL HEADER END | |
| # | |
| # 11-Oct-2014 Adrien Mahieux Added zoom. | |
| # 21-Nov-2013 Shawn Sterling Added consistent palette file option | |
| # 17-Mar-2013 Tim Bunce Added options and more tunables. | |
| # 15-Dec-2011 Dave Pacheco Support for frames with whitespace. | |
| # 10-Sep-2011 Brendan Gregg Created this. | |
| use strict; | |
| use Getopt::Long; | |
| use open qw(:std :utf8); | |
| # tunables | |
| my $encoding; | |
| my $fonttype = "Verdana"; | |
| my $imagewidth = 1200; # max width, pixels | |
| my $frameheight = 16; # max height is dynamic | |
| my $fontsize = 12; # base text size | |
| my $fontwidth = 0.59; # avg width relative to fontsize | |
| my $minwidth = 0.1; # min function width, pixels or percentage of time | |
| my $nametype = "Function:"; # what are the names in the data? | |
| my $countname = "samples"; # what are the counts in the data? | |
| my $colors = "hot"; # color theme | |
| my $bgcolors = ""; # background color theme | |
| my $nameattrfile; # file holding function attributes | |
| my $timemax; # (override the) sum of the counts | |
| my $factor = 1; # factor to scale counts by | |
| my $hash = 0; # color by function name | |
| my $rand = 0; # color randomly | |
| my $palette = 0; # if we use consistent palettes (default off) | |
| my %palette_map; # palette map hash | |
| my $pal_file = "palette.map"; # palette map file name | |
| my $stackreverse = 0; # reverse stack order, switching merge end | |
| my $inverted = 0; # icicle graph | |
| my $flamechart = 0; # produce a flame chart (sort by time, do not merge stacks) | |
| my $negate = 0; # switch differential hues | |
| my $titletext = ""; # centered heading | |
| my $titledefault = "Flame Graph"; # overwritten by --title | |
| my $titleinverted = "Icicle Graph"; # " " | |
| my $searchcolor = "rgb(230,0,230)"; # color for search highlighting | |
| my $notestext = ""; # embedded notes in SVG | |
| my $subtitletext = ""; # second level title (optional) | |
| my $help = 0; | |
| sub usage { | |
| die <<USAGE_END; | |
| USAGE: $0 [options] infile > outfile.svg\n | |
| --title TEXT # change title text | |
| --subtitle TEXT # second level title (optional) | |
| --width NUM # width of image (default 1200) | |
| --height NUM # height of each frame (default 16) | |
| --minwidth NUM # omit smaller functions. In pixels or use "%" for | |
| # percentage of time (default 0.1 pixels) | |
| --fonttype FONT # font type (default "Verdana") | |
| --fontsize NUM # font size (default 12) | |
| --countname TEXT # count type label (default "samples") | |
| --nametype TEXT # name type label (default "Function:") | |
| --colors PALETTE # set color palette. choices are: hot (default), mem, | |
| # io, wakeup, chain, java, js, perl, red, green, blue, | |
| # aqua, yellow, purple, orange | |
| --bgcolors COLOR # set background colors. gradient choices are yellow | |
| # (default), blue, green, grey; flat colors use "#rrggbb" | |
| --hash # colors are keyed by function name hash | |
| --random # colors are randomly generated | |
| --cp # use consistent palette (palette.map) | |
| --reverse # generate stack-reversed flame graph | |
| --inverted # icicle graph | |
| --flamechart # produce a flame chart (sort by time, do not merge stacks) | |
| --negate # switch differential hues (blue<->red) | |
| --notes TEXT # add notes comment in SVG (for debugging) | |
| --help # this message | |
| eg, | |
| $0 --title="Flame Graph: malloc()" trace.txt > graph.svg | |
| USAGE_END | |
| } | |
| GetOptions( | |
| 'fonttype=s' => \$fonttype, | |
| 'width=i' => \$imagewidth, | |
| 'height=i' => \$frameheight, | |
| 'encoding=s' => \$encoding, | |
| 'fontsize=f' => \$fontsize, | |
| 'fontwidth=f' => \$fontwidth, | |
| 'minwidth=s' => \$minwidth, | |
| 'title=s' => \$titletext, | |
| 'subtitle=s' => \$subtitletext, | |
| 'nametype=s' => \$nametype, | |
| 'countname=s' => \$countname, | |
| 'nameattr=s' => \$nameattrfile, | |
| 'total=s' => \$timemax, | |
| 'factor=f' => \$factor, | |
| 'colors=s' => \$colors, | |
| 'bgcolors=s' => \$bgcolors, | |
| 'hash' => \$hash, | |
| 'random' => \$rand, | |
| 'cp' => \$palette, | |
| 'reverse' => \$stackreverse, | |
| 'inverted' => \$inverted, | |
| 'flamechart' => \$flamechart, | |
| 'negate' => \$negate, | |
| 'notes=s' => \$notestext, | |
| 'help' => \$help, | |
| ) or usage(); | |
| $help && usage(); | |
| # internals | |
| my $ypad1 = $fontsize * 3; # pad top, include title | |
| my $ypad2 = $fontsize * 2 + 10; # pad bottom, include labels | |
| my $ypad3 = $fontsize * 2; # pad top, include subtitle (optional) | |
| my $xpad = 10; # pad lefm and right | |
| my $framepad = 1; # vertical padding for frames | |
| my $depthmax = 0; | |
| my %Events; | |
| my %nameattr; | |
| if ($flamechart && $titletext eq "") { | |
| $titletext = "Flame Chart"; | |
| } | |
| if ($titletext eq "") { | |
| unless ($inverted) { | |
| $titletext = $titledefault; | |
| } else { | |
| $titletext = $titleinverted; | |
| } | |
| } | |
| if ($nameattrfile) { | |
| # The name-attribute file format is a function name followed by a tab then | |
| # a sequence of tab separated name=value pairs. | |
| open my $attrfh, $nameattrfile or die "Can't read $nameattrfile: $!\n"; | |
| while (<$attrfh>) { | |
| chomp; | |
| my ($funcname, $attrstr) = split /\t/, $_, 2; | |
| die "Invalid format in $nameattrfile" unless defined $attrstr; | |
| $nameattr{$funcname} = { map { split /=/, $_, 2 } split /\t/, $attrstr }; | |
| } | |
| } | |
| if ($notestext =~ /[<>]/) { | |
| die "Notes string can't contain < or >" | |
| } | |
| # Ensure minwidth is a valid floating-point number, | |
| # print usage string if not | |
| my $minwidth_f; | |
| if ($minwidth =~ /^([0-9.]+)%?$/) { | |
| $minwidth_f = $1; | |
| } else { | |
| warn "Value '$minwidth' is invalid for minwidth, expected a float.\n"; | |
| usage(); | |
| } | |
| # background colors: | |
| # - yellow gradient: default (hot, java, js, perl) | |
| # - green gradient: mem | |
| # - blue gradient: io, wakeup, chain | |
| # - gray gradient: flat colors (red, green, blue, ...) | |
| if ($bgcolors eq "") { | |
| # choose a default | |
| if ($colors eq "mem") { | |
| $bgcolors = "green"; | |
| } elsif ($colors =~ /^(io|wakeup|chain)$/) { | |
| $bgcolors = "blue"; | |
| } elsif ($colors =~ /^(red|green|blue|aqua|yellow|purple|orange)$/) { | |
| $bgcolors = "grey"; | |
| } else { | |
| $bgcolors = "yellow"; | |
| } | |
| } | |
| my ($bgcolor1, $bgcolor2); | |
| if ($bgcolors eq "yellow") { | |
| $bgcolor1 = "#eeeeee"; # background color gradient start | |
| $bgcolor2 = "#eeeeb0"; # background color gradient stop | |
| } elsif ($bgcolors eq "blue") { | |
| $bgcolor1 = "#eeeeee"; $bgcolor2 = "#e0e0ff"; | |
| } elsif ($bgcolors eq "green") { | |
| $bgcolor1 = "#eef2ee"; $bgcolor2 = "#e0ffe0"; | |
| } elsif ($bgcolors eq "grey") { | |
| $bgcolor1 = "#f8f8f8"; $bgcolor2 = "#e8e8e8"; | |
| } elsif ($bgcolors =~ /^#......$/) { | |
| $bgcolor1 = $bgcolor2 = $bgcolors; | |
| } else { | |
| die "Unrecognized bgcolor option \"$bgcolors\"" | |
| } | |
| # SVG functions | |
| { package SVG; | |
| sub new { | |
| my $class = shift; | |
| my $self = {}; | |
| bless ($self, $class); | |
| return $self; | |
| } | |
| sub header { | |
| my ($self, $w, $h) = @_; | |
| my $enc_attr = ''; | |
| if (defined $encoding) { | |
| $enc_attr = qq{ encoding="$encoding"}; | |
| } | |
| $self->{svg} .= <<SVG; | |
| <?xml version="1.0"$enc_attr standalone="no"?> | |
| <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"> | |
| <svg version="1.1" width="$w" height="$h" onload="init(evt)" viewBox="0 0 $w $h" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"> | |
| <!-- Flame graph stack visualization. See https://github.com/brendangregg/FlameGraph for latest version, and http://www.brendangregg.com/flamegraphs.html for examples. --> | |
| <!-- NOTES: $notestext --> | |
| SVG | |
| } | |
| sub include { | |
| my ($self, $content) = @_; | |
| $self->{svg} .= $content; | |
| } | |
| sub colorAllocate { | |
| my ($self, $r, $g, $b) = @_; | |
| return "rgb($r,$g,$b)"; | |
| } | |
| sub group_start { | |
| my ($self, $attr) = @_; | |
| my @g_attr = map { | |
| exists $attr->{$_} ? sprintf(qq/$_="%s"/, $attr->{$_}) : () | |
| } qw(id class); | |
| push @g_attr, $attr->{g_extra} if $attr->{g_extra}; | |
| if ($attr->{href}) { | |
| my @a_attr; | |
| push @a_attr, sprintf qq/xlink:href="%s"/, $attr->{href} if $attr->{href}; | |
| # default target=_top else links will open within SVG <object> | |
| push @a_attr, sprintf qq/target="%s"/, $attr->{target} || "_top"; | |
| push @a_attr, $attr->{a_extra} if $attr->{a_extra}; | |
| $self->{svg} .= sprintf qq/<a %s>\n/, join(' ', (@a_attr, @g_attr)); | |
| } else { | |
| $self->{svg} .= sprintf qq/<g %s>\n/, join(' ', @g_attr); | |
| } | |
| $self->{svg} .= sprintf qq/<title>%s<\/title>/, $attr->{title} | |
| if $attr->{title}; # should be first element within g container | |
| } | |
| sub group_end { | |
| my ($self, $attr) = @_; | |
| $self->{svg} .= $attr->{href} ? qq/<\/a>\n/ : qq/<\/g>\n/; | |
| } | |
| sub filledRectangle { | |
| my ($self, $x1, $y1, $x2, $y2, $fill, $extra) = @_; | |
| $x1 = sprintf "%0.1f", $x1; | |
| $x2 = sprintf "%0.1f", $x2; | |
| my $w = sprintf "%0.1f", $x2 - $x1; | |
| my $h = sprintf "%0.1f", $y2 - $y1; | |
| $extra = defined $extra ? $extra : ""; | |
| $self->{svg} .= qq/<rect x="$x1" y="$y1" width="$w" height="$h" fill="$fill" $extra \/>\n/; | |
| } | |
| sub stringTTF { | |
| my ($self, $id, $x, $y, $str, $extra) = @_; | |
| $x = sprintf "%0.2f", $x; | |
| $id = defined $id ? qq/id="$id"/ : ""; | |
| $extra ||= ""; | |
| $self->{svg} .= qq/<text $id x="$x" y="$y" $extra>$str<\/text>\n/; | |
| } | |
| sub svg { | |
| my $self = shift; | |
| return "$self->{svg}</svg>\n"; | |
| } | |
| 1; | |
| } | |
| sub namehash { | |
| # Generate a vector hash for the name string, weighting early over | |
| # later characters. We want to pick the same colors for function | |
| # names across different flame graphs. | |
| my $name = shift; | |
| my $vector = 0; | |
| my $weight = 1; | |
| my $max = 1; | |
| my $mod = 10; | |
| # if module name present, trunc to 1st char | |
| $name =~ s/.(.*?)`//; | |
| foreach my $c (split //, $name) { | |
| my $i = (ord $c) % $mod; | |
| $vector += ($i / ($mod++ - 1)) * $weight; | |
| $max += 1 * $weight; | |
| $weight *= 0.70; | |
| last if $mod > 12; | |
| } | |
| return (1 - $vector / $max) | |
| } | |
| sub sum_namehash { | |
| my $name = shift; | |
| return unpack("%32W*", $name); | |
| } | |
| sub random_namehash { | |
| # Generate a random hash for the name string. | |
| # This ensures that functions with the same name have the same color, | |
| # both within a flamegraph and across multiple flamegraphs without | |
| # needing to set a palette and while preserving the original flamegraph | |
| # optic, unlike what happens with --hash. | |
| my $name = shift; | |
| my $hash = sum_namehash($name); | |
| srand($hash); | |
| return rand(1) | |
| } | |
| sub color { | |
| my ($type, $hash, $name) = @_; | |
| my ($v1, $v2, $v3); | |
| if ($hash) { | |
| $v1 = namehash($name); | |
| $v2 = $v3 = namehash(scalar reverse $name); | |
| } elsif ($rand) { | |
| $v1 = rand(1); | |
| $v2 = rand(1); | |
| $v3 = rand(1); | |
| } else { | |
| $v1 = random_namehash($name); | |
| $v2 = random_namehash($name); | |
| $v3 = random_namehash($name); | |
| } | |
| # theme palettes | |
| if (defined $type and $type eq "hot") { | |
| my $r = 205 + int(50 * $v3); | |
| my $g = 0 + int(230 * $v1); | |
| my $b = 0 + int(55 * $v2); | |
| return "rgb($r,$g,$b)"; | |
| } | |
| if (defined $type and $type eq "mem") { | |
| my $r = 0; | |
| my $g = 190 + int(50 * $v2); | |
| my $b = 0 + int(210 * $v1); | |
| return "rgb($r,$g,$b)"; | |
| } | |
| if (defined $type and $type eq "io") { | |
| my $r = 80 + int(60 * $v1); | |
| my $g = $r; | |
| my $b = 190 + int(55 * $v2); | |
| return "rgb($r,$g,$b)"; | |
| } | |
| # multi palettes | |
| if (defined $type and $type eq "java") { | |
| # Handle both annotations (_[j], _[i], ...; which are | |
| # accurate), as well as input that lacks any annotations, as | |
| # best as possible. Without annotations, we get a little hacky | |
| # and match on java|org|com, etc. | |
| if ($name =~ m:_\[j\]$:) { # jit annotation | |
| $type = "green"; | |
| } elsif ($name =~ m:_\[i\]$:) { # inline annotation | |
| $type = "aqua"; | |
| } elsif ($name =~ m:^L?(java|javax|jdk|net|org|com|io|sun)/:) { # Java | |
| $type = "green"; | |
| } elsif ($name =~ /:::/) { # Java, typical perf-map-agent method separator | |
| $type = "green"; | |
| } elsif ($name =~ /::/) { # C++ | |
| $type = "yellow"; | |
| } elsif ($name =~ m:_\[k\]$:) { # kernel annotation | |
| $type = "orange"; | |
| } elsif ($name =~ /::/) { # C++ | |
| $type = "yellow"; | |
| } else { # system | |
| $type = "red"; | |
| } | |
| # fall-through to color palettes | |
| } | |
| if (defined $type and $type eq "perl") { | |
| if ($name =~ /::/) { # C++ | |
| $type = "yellow"; | |
| } elsif ($name =~ m:Perl: or $name =~ m:\.pl:) { # Perl | |
| $type = "green"; | |
| } elsif ($name =~ m:_\[k\]$:) { # kernel | |
| $type = "orange"; | |
| } else { # system | |
| $type = "red"; | |
| } | |
| # fall-through to color palettes | |
| } | |
| if (defined $type and $type eq "js") { | |
| # Handle both annotations (_[j], _[i], ...; which are | |
| # accurate), as well as input that lacks any annotations, as | |
| # best as possible. Without annotations, we get a little hacky, | |
| # and match on a "/" with a ".js", etc. | |
| if ($name =~ m:_\[j\]$:) { # jit annotation | |
| if ($name =~ m:/:) { | |
| $type = "green"; # source | |
| } else { | |
| $type = "aqua"; # builtin | |
| } | |
| } elsif ($name =~ /::/) { # C++ | |
| $type = "yellow"; | |
| } elsif ($name =~ m:/.*\.js:) { # JavaScript (match "/" in path) | |
| $type = "green"; | |
| } elsif ($name =~ m/:/) { # JavaScript (match ":" in builtin) | |
| $type = "aqua"; | |
| } elsif ($name =~ m/^ $/) { # Missing symbol | |
| $type = "green"; | |
| } elsif ($name =~ m:_\[k\]:) { # kernel | |
| $type = "orange"; | |
| } else { # system | |
| $type = "red"; | |
| } | |
| # fall-through to color palettes | |
| } | |
| if (defined $type and $type eq "wakeup") { | |
| $type = "aqua"; | |
| # fall-through to color palettes | |
| } | |
| if (defined $type and $type eq "chain") { | |
| if ($name =~ m:_\[w\]:) { # waker | |
| $type = "aqua" | |
| } else { # off-CPU | |
| $type = "blue"; | |
| } | |
| # fall-through to color palettes | |
| } | |
| # color palettes | |
| if (defined $type and $type eq "red") { | |
| my $r = 200 + int(55 * $v1); | |
| my $x = 50 + int(80 * $v1); | |
| return "rgb($r,$x,$x)"; | |
| } | |
| if (defined $type and $type eq "green") { | |
| my $g = 200 + int(55 * $v1); | |
| my $x = 50 + int(60 * $v1); | |
| return "rgb($x,$g,$x)"; | |
| } | |
| if (defined $type and $type eq "blue") { | |
| my $b = 205 + int(50 * $v1); | |
| my $x = 80 + int(60 * $v1); | |
| return "rgb($x,$x,$b)"; | |
| } | |
| if (defined $type and $type eq "yellow") { | |
| my $x = 175 + int(55 * $v1); | |
| my $b = 50 + int(20 * $v1); | |
| return "rgb($x,$x,$b)"; | |
| } | |
| if (defined $type and $type eq "purple") { | |
| my $x = 190 + int(65 * $v1); | |
| my $g = 80 + int(60 * $v1); | |
| return "rgb($x,$g,$x)"; | |
| } | |
| if (defined $type and $type eq "aqua") { | |
| my $r = 50 + int(60 * $v1); | |
| my $g = 165 + int(55 * $v1); | |
| my $b = 165 + int(55 * $v1); | |
| return "rgb($r,$g,$b)"; | |
| } | |
| if (defined $type and $type eq "orange") { | |
| my $r = 190 + int(65 * $v1); | |
| my $g = 90 + int(65 * $v1); | |
| return "rgb($r,$g,0)"; | |
| } | |
| return "rgb(0,0,0)"; | |
| } | |
| sub color_scale { | |
| my ($value, $max) = @_; | |
| my ($r, $g, $b) = (255, 255, 255); | |
| $value = -$value if $negate; | |
| if ($value > 0) { | |
| $g = $b = int(210 * ($max - $value) / $max); | |
| } elsif ($value < 0) { | |
| $r = $g = int(210 * ($max + $value) / $max); | |
| } | |
| return "rgb($r,$g,$b)"; | |
| } | |
| sub color_map { | |
| my ($colors, $func) = @_; | |
| if (exists $palette_map{$func}) { | |
| return $palette_map{$func}; | |
| } else { | |
| $palette_map{$func} = color($colors, $hash, $func); | |
| return $palette_map{$func}; | |
| } | |
| } | |
| sub write_palette { | |
| open(FILE, ">$pal_file"); | |
| foreach my $key (sort keys %palette_map) { | |
| print FILE $key."->".$palette_map{$key}."\n"; | |
| } | |
| close(FILE); | |
| } | |
| sub read_palette { | |
| if (-e $pal_file) { | |
| open(FILE, $pal_file) or die "can't open file $pal_file: $!"; | |
| while ( my $line = <FILE>) { | |
| chomp($line); | |
| (my $key, my $value) = split("->",$line); | |
| $palette_map{$key}=$value; | |
| } | |
| close(FILE) | |
| } | |
| } | |
| my %Node; # Hash of merged frame data | |
| my %Tmp; | |
| # flow() merges two stacks, storing the merged frames and value data in %Node. | |
| sub flow { | |
| my ($last, $this, $v, $d) = @_; | |
| my $len_a = @$last - 1; | |
| my $len_b = @$this - 1; | |
| my $i = 0; | |
| my $len_same; | |
| for (; $i <= $len_a; $i++) { | |
| last if $i > $len_b; | |
| last if $last->[$i] ne $this->[$i]; | |
| } | |
| $len_same = $i; | |
| for ($i = $len_a; $i >= $len_same; $i--) { | |
| my $k = "$last->[$i];$i"; | |
| # a unique ID is constructed from "func;depth;etime"; | |
| # func-depth isn't unique, it may be repeated later. | |
| $Node{"$k;$v"}->{stime} = delete $Tmp{$k}->{stime}; | |
| if (defined $Tmp{$k}->{delta}) { | |
| $Node{"$k;$v"}->{delta} = delete $Tmp{$k}->{delta}; | |
| } | |
| delete $Tmp{$k}; | |
| } | |
| for ($i = $len_same; $i <= $len_b; $i++) { | |
| my $k = "$this->[$i];$i"; | |
| $Tmp{$k}->{stime} = $v; | |
| if (defined $d) { | |
| $Tmp{$k}->{delta} += $i == $len_b ? $d : 0; | |
| } | |
| } | |
| return $this; | |
| } | |
| # parse input | |
| my @Data; | |
| my @SortedData; | |
| my $last = []; | |
| my $time = 0; | |
| my $delta = undef; | |
| my $ignored = 0; | |
| my $line; | |
| my $maxdelta = 1; | |
| # reverse if needed | |
| foreach (<>) { | |
| chomp; | |
| $line = $_; | |
| if ($stackreverse) { | |
| # there may be an extra samples column for differentials | |
| # XXX todo: redo these REs as one. It's repeated below. | |
| my($stack, $samples) = (/^(.*)\s+?(\d+(?:\.\d*)?)$/); | |
| my $samples2 = undef; | |
| if ($stack =~ /^(.*)\s+?(\d+(?:\.\d*)?)$/) { | |
| $samples2 = $samples; | |
| ($stack, $samples) = $stack =~ (/^(.*)\s+?(\d+(?:\.\d*)?)$/); | |
| unshift @Data, join(";", reverse split(";", $stack)) . " $samples $samples2"; | |
| } else { | |
| unshift @Data, join(";", reverse split(";", $stack)) . " $samples"; | |
| } | |
| } else { | |
| unshift @Data, $line; | |
| } | |
| } | |
| if ($flamechart) { | |
| # In flame chart mode, just reverse the data so time moves from left to right. | |
| @SortedData = reverse @Data; | |
| } else { | |
| @SortedData = sort @Data; | |
| } | |
| # process and merge frames | |
| foreach (@SortedData) { | |
| chomp; | |
| # process: folded_stack count | |
| # eg: func_a;func_b;func_c 31 | |
| my ($stack, $samples) = (/^(.*)\s+?(\d+(?:\.\d*)?)$/); | |
| unless (defined $samples and defined $stack) { | |
| ++$ignored; | |
| next; | |
| } | |
| # there may be an extra samples column for differentials: | |
| my $samples2 = undef; | |
| if ($stack =~ /^(.*)\s+?(\d+(?:\.\d*)?)$/) { | |
| $samples2 = $samples; | |
| ($stack, $samples) = $stack =~ (/^(.*)\s+?(\d+(?:\.\d*)?)$/); | |
| } | |
| $delta = undef; | |
| if (defined $samples2) { | |
| $delta = $samples2 - $samples; | |
| $maxdelta = abs($delta) if abs($delta) > $maxdelta; | |
| } | |
| # for chain graphs, annotate waker frames with "_[w]", for later | |
| # coloring. This is a hack, but has a precedent ("_[k]" from perf). | |
| if ($colors eq "chain") { | |
| my @parts = split ";--;", $stack; | |
| my @newparts = (); | |
| $stack = shift @parts; | |
| $stack .= ";--;"; | |
| foreach my $part (@parts) { | |
| $part =~ s/;/_[w];/g; | |
| $part .= "_[w]"; | |
| push @newparts, $part; | |
| } | |
| $stack .= join ";--;", @parts; | |
| } | |
| # merge frames and populate %Node: | |
| $last = flow($last, [ '', split ";", $stack ], $time, $delta); | |
| if (defined $samples2) { | |
| $time += $samples2; | |
| } else { | |
| $time += $samples; | |
| } | |
| } | |
| flow($last, [], $time, $delta); | |
| if ($countname eq "samples") { | |
| # If $countname is used, it's likely that we're not measuring in stack samples | |
| # (e.g. time could be the unit), so don't warn. | |
| warn "Stack count is low ($time). Did something go wrong?\n" if $time < 100; | |
| } | |
| warn "Ignored $ignored lines with invalid format\n" if $ignored; | |
| unless ($time) { | |
| warn "ERROR: No stack counts found\n"; | |
| my $im = SVG->new(); | |
| # emit an error message SVG, for tools automating flamegraph use | |
| my $imageheight = $fontsize * 5; | |
| $im->header($imagewidth, $imageheight); | |
| $im->stringTTF(undef, int($imagewidth / 2), $fontsize * 2, | |
| "ERROR: No valid input provided to flamegraph.pl."); | |
| print $im->svg; | |
| exit 2; | |
| } | |
| if ($timemax and $timemax < $time) { | |
| warn "Specified --total $timemax is less than actual total $time, so ignored\n" | |
| if $timemax/$time > 0.02; # only warn is significant (e.g., not rounding etc) | |
| undef $timemax; | |
| } | |
| $timemax ||= $time; | |
| my $widthpertime = ($imagewidth - 2 * $xpad) / $timemax; | |
| # Treat as a percentage of time if the string ends in a "%". | |
| my $minwidth_time; | |
| if ($minwidth =~ /%$/) { | |
| $minwidth_time = $timemax * $minwidth_f / 100; | |
| } else { | |
| $minwidth_time = $minwidth_f / $widthpertime; | |
| } | |
| # prune blocks that are too narrow and determine max depth | |
| while (my ($id, $node) = each %Node) { | |
| my ($func, $depth, $etime) = split ";", $id; | |
| my $stime = $node->{stime}; | |
| die "missing start for $id" if not defined $stime; | |
| if (($etime-$stime) < $minwidth_time) { | |
| delete $Node{$id}; | |
| next; | |
| } | |
| $depthmax = $depth if $depth > $depthmax; | |
| } | |
| # draw canvas, and embed interactive JavaScript program | |
| my $imageheight = (($depthmax + 1) * $frameheight) + $ypad1 + $ypad2; | |
| $imageheight += $ypad3 if $subtitletext ne ""; | |
| my $titlesize = $fontsize + 5; | |
| my $im = SVG->new(); | |
| my ($black, $vdgrey, $dgrey) = ( | |
| $im->colorAllocate(0, 0, 0), | |
| $im->colorAllocate(160, 160, 160), | |
| $im->colorAllocate(200, 200, 200), | |
| ); | |
| $im->header($imagewidth, $imageheight); | |
| my $inc = <<INC; | |
| <defs> | |
| <linearGradient id="background" y1="0" y2="1" x1="0" x2="0" > | |
| <stop stop-color="$bgcolor1" offset="5%" /> | |
| <stop stop-color="$bgcolor2" offset="95%" /> | |
| </linearGradient> | |
| </defs> | |
| <style type="text/css"> | |
| text { font-family:$fonttype; font-size:${fontsize}px; fill:$black; } | |
| #search, #ignorecase { opacity:0.1; cursor:pointer; } | |
| #search:hover, #search.show, #ignorecase:hover, #ignorecase.show { opacity:1; } | |
| #subtitle { text-anchor:middle; font-color:$vdgrey; } | |
| #title { text-anchor:middle; font-size:${titlesize}px} | |
| #unzoom { cursor:pointer; } | |
| #frames > *:hover { stroke:black; stroke-width:0.5; cursor:pointer; } | |
| .hide { display:none; } | |
| .parent { opacity:0.5; } | |
| </style> | |
| <script type="text/ecmascript"> | |
| <![CDATA[ | |
| "use strict"; | |
| var details, searchbtn, unzoombtn, matchedtxt, svg, searching, currentSearchTerm, ignorecase, ignorecaseBtn; | |
| function init(evt) { | |
| details = document.getElementById("details").firstChild; | |
| searchbtn = document.getElementById("search"); | |
| ignorecaseBtn = document.getElementById("ignorecase"); | |
| unzoombtn = document.getElementById("unzoom"); | |
| matchedtxt = document.getElementById("matched"); | |
| svg = document.getElementsByTagName("svg")[0]; | |
| searching = 0; | |
| currentSearchTerm = null; | |
| // use GET parameters to restore a flamegraphs state. | |
| var params = get_params(); | |
| if (params.x && params.y) | |
| zoom(find_group(document.querySelector('[x="' + params.x + '"][y="' + params.y + '"]'))); | |
| if (params.s) search(params.s); | |
| } | |
| // event listeners | |
| window.addEventListener("click", function(e) { | |
| var target = find_group(e.target); | |
| if (target) { | |
| if (target.nodeName == "a") { | |
| if (e.ctrlKey === false) return; | |
| e.preventDefault(); | |
| } | |
| if (target.classList.contains("parent")) unzoom(true); | |
| zoom(target); | |
| if (!document.querySelector('.parent')) { | |
| // we have basically done a clearzoom so clear the url | |
| var params = get_params(); | |
| if (params.x) delete params.x; | |
| if (params.y) delete params.y; | |
| history.replaceState(null, null, parse_params(params)); | |
| unzoombtn.classList.add("hide"); | |
| return; | |
| } | |
| // set parameters for zoom state | |
| var el = target.querySelector("rect"); | |
| if (el && el.attributes && el.attributes.y && el.attributes._orig_x) { | |
| var params = get_params() | |
| params.x = el.attributes._orig_x.value; | |
| params.y = el.attributes.y.value; | |
| history.replaceState(null, null, parse_params(params)); | |
| } | |
| } | |
| else if (e.target.id == "unzoom") clearzoom(); | |
| else if (e.target.id == "search") search_prompt(); | |
| else if (e.target.id == "ignorecase") toggle_ignorecase(); | |
| }, false) | |
| // mouse-over for info | |
| // show | |
| window.addEventListener("mouseover", function(e) { | |
| var target = find_group(e.target); | |
| if (target) details.nodeValue = "$nametype " + g_to_text(target); | |
| }, false) | |
| // clear | |
| window.addEventListener("mouseout", function(e) { | |
| var target = find_group(e.target); | |
| if (target) details.nodeValue = ' '; | |
| }, false) | |
| // ctrl-F for search | |
| // ctrl-I to toggle case-sensitive search | |
| window.addEventListener("keydown",function (e) { | |
| if (e.keyCode === 114 || (e.ctrlKey && e.keyCode === 70)) { | |
| e.preventDefault(); | |
| search_prompt(); | |
| } | |
| else if (e.ctrlKey && e.keyCode === 73) { | |
| e.preventDefault(); | |
| toggle_ignorecase(); | |
| } | |
| }, false) | |
| // functions | |
| function get_params() { | |
| var params = {}; | |
| var paramsarr = window.location.search.substr(1).split('&'); | |
| for (var i = 0; i < paramsarr.length; ++i) { | |
| var tmp = paramsarr[i].split("="); | |
| if (!tmp[0] || !tmp[1]) continue; | |
| params[tmp[0]] = decodeURIComponent(tmp[1]); | |
| } | |
| return params; | |
| } | |
| function parse_params(params) { | |
| var uri = "?"; | |
| for (var key in params) { | |
| uri += key + '=' + encodeURIComponent(params[key]) + '&'; | |
| } | |
| if (uri.slice(-1) == "&") | |
| uri = uri.substring(0, uri.length - 1); | |
| if (uri == '?') | |
| uri = window.location.href.split('?')[0]; | |
| return uri; | |
| } | |
| function find_child(node, selector) { | |
| var children = node.querySelectorAll(selector); | |
| if (children.length) return children[0]; | |
| } | |
| function find_group(node) { | |
| var parent = node.parentElement; | |
| if (!parent) return; | |
| if (parent.id == "frames") return node; | |
| return find_group(parent); | |
| } | |
| function orig_save(e, attr, val) { | |
| if (e.attributes["_orig_" + attr] != undefined) return; | |
| if (e.attributes[attr] == undefined) return; | |
| if (val == undefined) val = e.attributes[attr].value; | |
| e.setAttribute("_orig_" + attr, val); | |
| } | |
| function orig_load(e, attr) { | |
| if (e.attributes["_orig_"+attr] == undefined) return; | |
| e.attributes[attr].value = e.attributes["_orig_" + attr].value; | |
| e.removeAttribute("_orig_"+attr); | |
| } | |
| function g_to_text(e) { | |
| var text = find_child(e, "title").firstChild.nodeValue; | |
| return (text) | |
| } | |
| function g_to_func(e) { | |
| var func = g_to_text(e); | |
| // if there's any manipulation we want to do to the function | |
| // name before it's searched, do it here before returning. | |
| return (func); | |
| } | |
| function update_text(e) { | |
| var r = find_child(e, "rect"); | |
| var t = find_child(e, "text"); | |
| var w = parseFloat(r.attributes.width.value) -3; | |
| var txt = find_child(e, "title").textContent.replace(/\\([^(]*\\)\$/,""); | |
| t.attributes.x.value = parseFloat(r.attributes.x.value) + 3; | |
| // Smaller than this size won't fit anything | |
| if (w < 2 * $fontsize * $fontwidth) { | |
| t.textContent = ""; | |
| return; | |
| } | |
| t.textContent = txt; | |
| var sl = t.getSubStringLength(0, txt.length); | |
| // check if only whitespace or if we can fit the entire string into width w | |
| if (/^ *\$/.test(txt) || sl < w) | |
| return; | |
| // this isn't perfect, but gives a good starting point | |
| // and avoids calling getSubStringLength too often | |
| var start = Math.floor((w/sl) * txt.length); | |
| for (var x = start; x > 0; x = x-2) { | |
| if (t.getSubStringLength(0, x + 2) <= w) { | |
| t.textContent = txt.substring(0, x) + ".."; | |
| return; | |
| } | |
| } | |
| t.textContent = ""; | |
| } | |
| // zoom | |
| function zoom_reset(e) { | |
| if (e.attributes != undefined) { | |
| orig_load(e, "x"); | |
| orig_load(e, "width"); | |
| } | |
| if (e.childNodes == undefined) return; | |
| for (var i = 0, c = e.childNodes; i < c.length; i++) { | |
| zoom_reset(c[i]); | |
| } | |
| } | |
| function zoom_child(e, x, ratio) { | |
| if (e.attributes != undefined) { | |
| if (e.attributes.x != undefined) { | |
| orig_save(e, "x"); | |
| e.attributes.x.value = (parseFloat(e.attributes.x.value) - x - $xpad) * ratio + $xpad; | |
| if (e.tagName == "text") | |
| e.attributes.x.value = find_child(e.parentNode, "rect[x]").attributes.x.value + 3; | |
| } | |
| if (e.attributes.width != undefined) { | |
| orig_save(e, "width"); | |
| e.attributes.width.value = parseFloat(e.attributes.width.value) * ratio; | |
| } | |
| } | |
| if (e.childNodes == undefined) return; | |
| for (var i = 0, c = e.childNodes; i < c.length; i++) { | |
| zoom_child(c[i], x - $xpad, ratio); | |
| } | |
| } | |
| function zoom_parent(e) { | |
| if (e.attributes) { | |
| if (e.attributes.x != undefined) { | |
| orig_save(e, "x"); | |
| e.attributes.x.value = $xpad; | |
| } | |
| if (e.attributes.width != undefined) { | |
| orig_save(e, "width"); | |
| e.attributes.width.value = parseInt(svg.width.baseVal.value) - ($xpad * 2); | |
| } | |
| } | |
| if (e.childNodes == undefined) return; | |
| for (var i = 0, c = e.childNodes; i < c.length; i++) { | |
| zoom_parent(c[i]); | |
| } | |
| } | |
| function zoom(node) { | |
| var attr = find_child(node, "rect").attributes; | |
| var width = parseFloat(attr.width.value); | |
| var xmin = parseFloat(attr.x.value); | |
| var xmax = parseFloat(xmin + width); | |
| var ymin = parseFloat(attr.y.value); | |
| var ratio = (svg.width.baseVal.value - 2 * $xpad) / width; | |
| // XXX: Workaround for JavaScript float issues (fix me) | |
| var fudge = 0.0001; | |
| unzoombtn.classList.remove("hide"); | |
| var el = document.getElementById("frames").children; | |
| for (var i = 0; i < el.length; i++) { | |
| var e = el[i]; | |
| var a = find_child(e, "rect").attributes; | |
| var ex = parseFloat(a.x.value); | |
| var ew = parseFloat(a.width.value); | |
| var upstack; | |
| // Is it an ancestor | |
| if ($inverted == 0) { | |
| upstack = parseFloat(a.y.value) > ymin; | |
| } else { | |
| upstack = parseFloat(a.y.value) < ymin; | |
| } | |
| if (upstack) { | |
| // Direct ancestor | |
| if (ex <= xmin && (ex+ew+fudge) >= xmax) { | |
| e.classList.add("parent"); | |
| zoom_parent(e); | |
| update_text(e); | |
| } | |
| // not in current path | |
| else | |
| e.classList.add("hide"); | |
| } | |
| // Children maybe | |
| else { | |
| // no common path | |
| if (ex < xmin || ex + fudge >= xmax) { | |
| e.classList.add("hide"); | |
| } | |
| else { | |
| zoom_child(e, xmin, ratio); | |
| update_text(e); | |
| } | |
| } | |
| } | |
| search(); | |
| } | |
| function unzoom(dont_update_text) { | |
| unzoombtn.classList.add("hide"); | |
| var el = document.getElementById("frames").children; | |
| for(var i = 0; i < el.length; i++) { | |
| el[i].classList.remove("parent"); | |
| el[i].classList.remove("hide"); | |
| zoom_reset(el[i]); | |
| if(!dont_update_text) update_text(el[i]); | |
| } | |
| search(); | |
| } | |
| function clearzoom() { | |
| unzoom(); | |
| // remove zoom state | |
| var params = get_params(); | |
| if (params.x) delete params.x; | |
| if (params.y) delete params.y; | |
| history.replaceState(null, null, parse_params(params)); | |
| } | |
| // search | |
| function toggle_ignorecase() { | |
| ignorecase = !ignorecase; | |
| if (ignorecase) { | |
| ignorecaseBtn.classList.add("show"); | |
| } else { | |
| ignorecaseBtn.classList.remove("show"); | |
| } | |
| reset_search(); | |
| search(); | |
| } | |
| function reset_search() { | |
| var el = document.querySelectorAll("#frames rect"); | |
| for (var i = 0; i < el.length; i++) { | |
| orig_load(el[i], "fill") | |
| } | |
| var params = get_params(); | |
| delete params.s; | |
| history.replaceState(null, null, parse_params(params)); | |
| } | |
| function search_prompt() { | |
| if (!searching) { | |
| var term = prompt("Enter a search term (regexp " + | |
| "allowed, eg: ^ext4_)" | |
| + (ignorecase ? ", ignoring case" : "") | |
| + "\\nPress Ctrl-i to toggle case sensitivity", ""); | |
| if (term != null) search(term); | |
| } else { | |
| reset_search(); | |
| searching = 0; | |
| currentSearchTerm = null; | |
| searchbtn.classList.remove("show"); | |
| searchbtn.firstChild.nodeValue = "Search" | |
| matchedtxt.classList.add("hide"); | |
| matchedtxt.firstChild.nodeValue = "" | |
| } | |
| } | |
| function search(term) { | |
| if (term) currentSearchTerm = term; | |
| var re = new RegExp(currentSearchTerm, ignorecase ? 'i' : ''); | |
| var el = document.getElementById("frames").children; | |
| var matches = new Object(); | |
| var maxwidth = 0; | |
| for (var i = 0; i < el.length; i++) { | |
| var e = el[i]; | |
| var func = g_to_func(e); | |
| var rect = find_child(e, "rect"); | |
| if (func == null || rect == null) | |
| continue; | |
| // Save max width. Only works as we have a root frame | |
| var w = parseFloat(rect.attributes.width.value); | |
| if (w > maxwidth) | |
| maxwidth = w; | |
| if (func.match(re)) { | |
| // highlight | |
| var x = parseFloat(rect.attributes.x.value); | |
| orig_save(rect, "fill"); | |
| rect.attributes.fill.value = "$searchcolor"; | |
| // remember matches | |
| if (matches[x] == undefined) { | |
| matches[x] = w; | |
| } else { | |
| if (w > matches[x]) { | |
| // overwrite with parent | |
| matches[x] = w; | |
| } | |
| } | |
| searching = 1; | |
| } | |
| } | |
| if (!searching) | |
| return; | |
| var params = get_params(); | |
| params.s = currentSearchTerm; | |
| history.replaceState(null, null, parse_params(params)); | |
| searchbtn.classList.add("show"); | |
| searchbtn.firstChild.nodeValue = "Reset Search"; | |
| // calculate percent matched, excluding vertical overlap | |
| var count = 0; | |
| var lastx = -1; | |
| var lastw = 0; | |
| var keys = Array(); | |
| for (k in matches) { | |
| if (matches.hasOwnProperty(k)) | |
| keys.push(k); | |
| } | |
| // sort the matched frames by their x location | |
| // ascending, then width descending | |
| keys.sort(function(a, b){ | |
| return a - b; | |
| }); | |
| // Step through frames saving only the biggest bottom-up frames | |
| // thanks to the sort order. This relies on the tree property | |
| // where children are always smaller than their parents. | |
| var fudge = 0.0001; // JavaScript floating point | |
| for (var k in keys) { | |
| var x = parseFloat(keys[k]); | |
| var w = matches[keys[k]]; | |
| if (x >= lastx + lastw - fudge) { | |
| count += w; | |
| lastx = x; | |
| lastw = w; | |
| } | |
| } | |
| // display matched percent | |
| matchedtxt.classList.remove("hide"); | |
| var pct = 100 * count / maxwidth; | |
| if (pct != 100) pct = pct.toFixed(1) | |
| matchedtxt.firstChild.nodeValue = "Matched: " + pct + "%"; | |
| } | |
| ]]> | |
| </script> | |
| INC | |
| $im->include($inc); | |
| $im->filledRectangle(0, 0, $imagewidth, $imageheight, 'url(#background)'); | |
| $im->stringTTF("title", int($imagewidth / 2), $fontsize * 2, $titletext); | |
| $im->stringTTF("subtitle", int($imagewidth / 2), $fontsize * 4, $subtitletext) if $subtitletext ne ""; | |
| $im->stringTTF("details", $xpad, $imageheight - ($ypad2 / 2), " "); | |
| $im->stringTTF("unzoom", $xpad, $fontsize * 2, "Reset Zoom", 'class="hide"'); | |
| $im->stringTTF("search", $imagewidth - $xpad - 100, $fontsize * 2, "Search"); | |
| $im->stringTTF("ignorecase", $imagewidth - $xpad - 16, $fontsize * 2, "ic"); | |
| $im->stringTTF("matched", $imagewidth - $xpad - 100, $imageheight - ($ypad2 / 2), " "); | |
| if ($palette) { | |
| read_palette(); | |
| } | |
| # draw frames | |
| $im->group_start({id => "frames"}); | |
| while (my ($id, $node) = each %Node) { | |
| my ($func, $depth, $etime) = split ";", $id; | |
| my $stime = $node->{stime}; | |
| my $delta = $node->{delta}; | |
| $etime = $timemax if $func eq "" and $depth == 0; | |
| my $x1 = $xpad + $stime * $widthpertime; | |
| my $x2 = $xpad + $etime * $widthpertime; | |
| my ($y1, $y2); | |
| unless ($inverted) { | |
| $y1 = $imageheight - $ypad2 - ($depth + 1) * $frameheight + $framepad; | |
| $y2 = $imageheight - $ypad2 - $depth * $frameheight; | |
| } else { | |
| $y1 = $ypad1 + $depth * $frameheight; | |
| $y2 = $ypad1 + ($depth + 1) * $frameheight - $framepad; | |
| } | |
| # Add commas per perlfaq5: | |
| # https://perldoc.perl.org/perlfaq5#How-can-I-output-my-numbers-with-commas-added? | |
| my $samples = sprintf "%.0f", ($etime - $stime) * $factor; | |
| (my $samples_txt = $samples) | |
| =~ s/(^[-+]?\d+?(?=(?>(?:\d{3})+)(?!\d))|\G\d{3}(?=\d))/$1,/g; | |
| my $info; | |
| if ($func eq "" and $depth == 0) { | |
| $info = "all ($samples_txt $countname, 100%)"; | |
| } else { | |
| my $pct = sprintf "%.2f", ((100 * $samples) / ($timemax * $factor)); | |
| my $escaped_func = $func; | |
| # clean up SVG breaking characters: | |
| $escaped_func =~ s/&/&/g; | |
| $escaped_func =~ s/</</g; | |
| $escaped_func =~ s/>/>/g; | |
| $escaped_func =~ s/"/"/g; | |
| $escaped_func =~ s/_\[[kwij]\]$//; # strip any annotation | |
| unless (defined $delta) { | |
| $info = "$escaped_func ($samples_txt $countname, $pct%)"; | |
| } else { | |
| my $d = $negate ? -$delta : $delta; | |
| my $deltapct = sprintf "%.2f", ((100 * $d) / ($timemax * $factor)); | |
| $deltapct = $d > 0 ? "+$deltapct" : $deltapct; | |
| $info = "$escaped_func ($samples_txt $countname, $pct%; $deltapct%)"; | |
| } | |
| } | |
| my $nameattr = { %{ $nameattr{$func}||{} } }; # shallow clone | |
| $nameattr->{title} ||= $info; | |
| $im->group_start($nameattr); | |
| my $color; | |
| if ($func eq "--") { | |
| $color = $vdgrey; | |
| } elsif ($func eq "-") { | |
| $color = $dgrey; | |
| } elsif (defined $delta) { | |
| $color = color_scale($delta, $maxdelta); | |
| } elsif ($palette) { | |
| $color = color_map($colors, $func); | |
| } else { | |
| $color = color($colors, $hash, $func); | |
| } | |
| $im->filledRectangle($x1, $y1, $x2, $y2, $color, 'rx="2" ry="2"'); | |
| my $chars = int( ($x2 - $x1) / ($fontsize * $fontwidth)); | |
| my $text = ""; | |
| if ($chars >= 3) { # room for one char plus two dots | |
| $func =~ s/_\[[kwij]\]$//; # strip any annotation | |
| $text = substr $func, 0, $chars; | |
| substr($text, -2, 2) = ".." if $chars < length $func; | |
| $text =~ s/&/&/g; | |
| $text =~ s/</</g; | |
| $text =~ s/>/>/g; | |
| } | |
| $im->stringTTF(undef, $x1 + 3, 3 + ($y1 + $y2) / 2, $text); | |
| $im->group_end($nameattr); | |
| } | |
| $im->group_end(); | |
| print $im->svg; | |
| if ($palette) { | |
| write_palette(); | |
| } | |
| # vim: ts=8 sts=8 sw=8 noexpandtab |