SSL flamegraph.pl Interaktion und
PortierbarkeitShell

#!/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">


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}\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

quality82%

¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.49Angebot Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können ¤

*Eine klare Vorstellung vom Zielzustand

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.

SSL flamegraph.pl Interaktion und PortierbarkeitShell

¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.49Angebot Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können ¤

Haftungshinweis

Bemerkung:

SSL flamegraph.pl Interaktion und
PortierbarkeitShell