From 4650b7949ae3a41326e52ae454a9202493c41444 Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Thu, 9 Mar 2023 15:41:31 +1100 Subject: [PATCH] Rewrite `cg_annotate` in Python. Perl was a reasonable choice for `cg_annotate` in 2002, but not in 2023. Also, the existing structure of the code is not good. These two things make it hard to modify `cg_annotate` in any significant way. Benefits of the change: - Now written in a language that is (a) nice, and (b) not moribund. - Easier to maintain, due to (a) abovementioned better language, (b) better code structure, and (c) better language tooling, such as formatters, type checkers, and linters. - The new version is a little shorter. - It runs about 2x faster. - Argument handling is more standard. E.g. things like `--context 2`, `--auto`, `--no-auto` are supported. (The old forms that require `=` are still supported, though the `=yes`/`=no` forms are deprecated.) The behaviour and output of the new version is identical for typical uses, but there are some very minor changes for edge cases, which nobody is likely to notice. For example: - The file format is slightly changed: I removed support for '.' counts, which had the same meaning as '0'. This was a feature that Cachegrind never used, and the old script handled it inconsistently. - The new version will abort on a malformed data line. The old version would just print a warning and continue. The commit also adds a new test `ann3` that tests many parts of `cg_annotate` that weren't tested previously, and tweaks the existing `ann2` test. --- NEWS | 5 + cachegrind/Makefile.am | 30 + cachegrind/cg_annotate.in | 1759 ++++++++--------- cachegrind/docs/cg-manual.xml | 33 +- cachegrind/pylintrc | 53 + cachegrind/tests/ann2.post.exp | 14 +- cachegrind/tests/ann2.vgtest | 2 +- cachegrind/tests/ann3-aux/ann3-via-I.rs | 1 + cachegrind/tests/ann3-basic.rs | 20 + .../tests/ann3-more-recent-than-cgout.rs | 5 + cachegrind/tests/ann3-negatives.rs | 15 + cachegrind/tests/ann3-past-the-end.rs | 3 + cachegrind/tests/ann3-unmentioned.rs | 1 + cachegrind/tests/ann3.post.exp | 146 ++ cachegrind/tests/ann3.stderr.exp | 17 + cachegrind/tests/ann3.vgtest | 13 + cachegrind/tests/cgout-test3 | 93 + cachegrind/tests/diff.post.exp | 4 +- 18 files changed, 1258 insertions(+), 956 deletions(-) mode change 100644 => 100755 cachegrind/cg_annotate.in create mode 100644 cachegrind/pylintrc create mode 100644 cachegrind/tests/ann3-aux/ann3-via-I.rs create mode 100644 cachegrind/tests/ann3-basic.rs create mode 100644 cachegrind/tests/ann3-more-recent-than-cgout.rs create mode 100644 cachegrind/tests/ann3-negatives.rs create mode 100644 cachegrind/tests/ann3-past-the-end.rs create mode 100644 cachegrind/tests/ann3-unmentioned.rs create mode 100644 cachegrind/tests/ann3.post.exp create mode 100644 cachegrind/tests/ann3.stderr.exp create mode 100644 cachegrind/tests/ann3.vgtest create mode 100644 cachegrind/tests/cgout-test3 diff --git a/NEWS b/NEWS index 8ede199d67..990043fe63 100644 --- a/NEWS +++ b/NEWS @@ -86,6 +86,11 @@ AMD64/macOS 10.13 and nanoMIPS/Linux. - Valgrind now contains python code that defines GDB helgrind front end monitor commands. See CORE CHANGES. +* Cachegrind: + - `cg_annotate` has been rewritten from Perl into Python. The new + version is twice as fast, has more flexible argument parsing, and + will make future improvements easier. + * Callgrind: - Valgrind now contains python code that defines GDB callgrind front end monitor commands. See CORE CHANGES. diff --git a/cachegrind/Makefile.am b/cachegrind/Makefile.am index f8447a17ce..8ea99ca529 100644 --- a/cachegrind/Makefile.am +++ b/cachegrind/Makefile.am @@ -88,3 +88,33 @@ cachegrind_@VGCONF_ARCH_SEC@_@VGCONF_OS@_LINK = \ $(cachegrind_@VGCONF_ARCH_SEC@_@VGCONF_OS@_CFLAGS) \ $(cachegrind_@VGCONF_ARCH_SEC@_@VGCONF_OS@_LDFLAGS) endif + +#---------------------------------------------------------------------------- +# Miscellaneous +#---------------------------------------------------------------------------- + +# Run the formatters, type checkers, and linters on `cg_annotate.in`, then +# generate `cg_annotate`. +# +# Note: `pyright` refuses to check any file without a `.py` extension, hence +# the copying to `/tmp/tmp.py`. +ann: + @echo "== black ==" + @black cg_annotate.in + @echo + @echo "== isort ==" + @isort cg_annotate.in + @echo + @echo "== mypy ==" + @mypy --strict cg_annotate.in + @echo + @echo "== pyright ==" + @cp cg_annotate.in /tmp/tmp.py && pyright /tmp/tmp.py && rm /tmp/tmp.py + @echo + @echo "== ruff ==" + @ruff cg_annotate.in + @echo + @echo "== pylint ==" + @pylint cg_annotate.in + @echo "== config.status ==" + $(MAKE) cg_annotate diff --git a/cachegrind/cg_annotate.in b/cachegrind/cg_annotate.in old mode 100644 new mode 100755 index 9111fbe7ef..247026f1fa --- a/cachegrind/cg_annotate.in +++ b/cachegrind/cg_annotate.in @@ -1,942 +1,855 @@ -#! @PERL@ +#! /usr/bin/python3 +# pyright: strict -##--------------------------------------------------------------------## -##--- Cachegrind's annotator. cg_annotate.in ---## -##--------------------------------------------------------------------## +# -------------------------------------------------------------------- +# --- Cachegrind's annotator. cg_annotate.in --- +# -------------------------------------------------------------------- -# This file is part of Cachegrind, a Valgrind tool for cache -# profiling programs. +# This file is part of Cachegrind, a Valgrind tool for cache +# profiling programs. # -# Copyright (C) 2002-2017 Nicholas Nethercote -# njn@valgrind.org +# Copyright (C) 2002-2023 Nicholas Nethercote +# njn@valgrind.org # -# This program is free software; you can redistribute it and/or -# modify it under the terms of the GNU General Public License as -# published by the Free Software Foundation; either version 2 of the -# License, or (at your option) any later version. +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of the +# License, or (at your option) any later version. # -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# General Public License for more details. +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. # -# You should have received a copy of the GNU General Public License -# along with this program; if not, see . +# You should have received a copy of the GNU General Public License +# along with this program; if not, see . # -# The GNU General Public License is contained in the file COPYING. - -#---------------------------------------------------------------------------- -# The file format is simple, basically printing the cost centre for every -# source line, grouped by files and functions. The details are in -# Cachegrind's manual. - -#---------------------------------------------------------------------------- -# Performance improvements record, using cachegrind.out for cacheprof, doing no -# source annotation (irrelevant ones removed): -# user time -# 1. turned off warnings in add_hash_a_to_b() 3.81 --> 3.48s -# [now add_array_a_to_b()] -# 6. make line_to_CC() return a ref instead of a hash 3.01 --> 2.77s +# The GNU General Public License is contained in the file COPYING. + +""" +This script reads Cachegrind output files and produces human-readable reports. +""" + +# Use `make ann` to "build" this script every time it is changed. This runs the +# formatters, type-checkers, and linters on `cg_annotate.in` and then generates +# `cg_annotate`. # -#10. changed file format to avoid file/fn name repetition 2.40s -# (not sure why higher; maybe due to new '.' entries?) -#11. changed file format to drop unnecessary end-line "."s 2.36s -# (shrunk file by about 37%) -#12. switched from hash CCs to array CCs 1.61s -#13. only adding b[i] to a[i] if b[i] defined (was doing it if -# either a[i] or b[i] was defined, but if b[i] was undefined -# it just added 0) 1.48s -#14. Stopped converting "." entries to undef and then back 1.16s -#15. Using foreach $i (x..y) instead of for ($i = 0...) in -# add_array_a_to_b() 1.11s +# The following Python tools are used. All can be installed with `pip3 install +# $NAME`, except `cProfile` which is built into Python. # -# Auto-annotating primes: -#16. Finding count lengths by int((length-1)/3), not by -# commifying (halves the number of commify calls) 1.68s --> 1.47s - -use warnings; -use strict; - -#---------------------------------------------------------------------------- -# Overview: the running example in the comments is for: -# - events = A,B,C,D -# - --show=C,A,D -# - --sort=D,C -#---------------------------------------------------------------------------- - -#---------------------------------------------------------------------------- -# Global variables, main data structures -#---------------------------------------------------------------------------- -# CCs are arrays, the counts corresponding to @events, with 'undef' -# representing '.'. This makes things fast (faster than using hashes for CCs) -# but we have to use @sort_order and @show_order below to handle the --sort and -# --show options, which is a bit tricky. -#---------------------------------------------------------------------------- - -# Total counts for summary (an array reference). -my $summary_CC; - -# Totals for each function, for overall summary. -# hash(filename:fn_name => CC array) -my %fn_totals; - -# Individual CCs, organised by filename and line_num for easy annotation. -# hash(filename => hash(line_num => CC array)) -my %allCCs; - -# Files chosen for annotation on the command line. -# key = basename (trimmed of any directory), value = full filename -my %user_ann_files; - -# Generic description string. -my $desc = ""; - -# Command line of profiled program. -my $cmd; - -# Events in input file, eg. (A,B,C,D) -my @events; - -# Events to show, from command line, eg. (C,A,D) -my @show_events; - -# Map from @show_events indices to @events indices, eg. (2,0,3). Gives the -# order in which we must traverse @events in order to show the @show_events, -# eg. (@events[$show_order[1]], @events[$show_order[2]]...) = @show_events. -# (Might help to think of it like a hash (0 => 2, 1 => 0, 2 => 3).) -my @show_order; - -# Print out the function totals sorted by these events, eg. (D,C). -my @sort_events; - -# Map from @sort_events indices to @events indices, eg. (3,2). Same idea as -# for @show_order. -my @sort_order; - -# Thresholds, one for each sort event (or default to 1 if no sort events -# specified). We print out functions and do auto-annotations until we've -# handled this proportion of all the events thresholded. -my @thresholds; - -my $default_threshold = 0.1; - -my $single_threshold = $default_threshold; - -# If on, show a percentage for each non-zero count. -my $show_percs = 1; - -# If on, automatically annotates all files that are involved in getting over -# all the threshold counts. -my $auto_annotate = 1; - -# Number of lines to show around each annotated line. -my $context = 8; - -# Directories in which to look for annotation files. -my @include_dirs = (""); - -# Input file name -my $input_file = undef; - -# Version number -my $version = "@VERSION@"; - -# Usage message. -my $usage = < a function is shown if it accounts for more than x% of - the counts of the primary sort event [$default_threshold] - --show-percs=yes|no show a percentage for each non-zero count [yes] - --auto=yes|no annotate all source files containing functions - that helped reach the event count threshold [yes] - --context=N print N lines of context before and after - annotated lines [8] - -I --include= add to list of directories to search for - source files - - cg_annotate is Copyright (C) 2002-2017 Nicholas Nethercote. - and licensed under the GNU General Public License, version 2. - Bug reports, feedback, admiration, abuse, etc, to: njn\@valgrind.org. - -END -; - -# Used in various places of output. -my $fancy = '-' x 80 . "\n"; - -sub safe_div($$) -{ - my ($x, $y) = @_; - return ($y == 0 ? 0 : $x / $y); -} - -#----------------------------------------------------------------------------- -# Argument and option handling -#----------------------------------------------------------------------------- -sub process_cmd_line() -{ - for my $arg (@ARGV) { - - # Option handling - if ($arg =~ /^-/) { - - # --version - if ($arg =~ /^--version$/) { - die("cg_annotate-$version\n"); - - # --show=A,B,C - } elsif ($arg =~ /^--show=(.*)$/) { - @show_events = split(/,/, $1); - - # --sort=A,B,C - # Nb: You can specify thresholds individually, eg. - # --sort=A:99,B:95,C:90. These will override any --threshold - # argument. - } elsif ($arg =~ /^--sort=(.*)$/) { - @sort_events = split(/,/, $1); - my $th_specified = 0; - foreach my $i (0 .. scalar @sort_events - 1) { - if ($sort_events[$i] =~ /.*:([\d\.]+)%?$/) { - my $th = $1; - ($th >= 0 && $th <= 100) or die($usage); - $sort_events[$i] =~ s/:.*//; - $thresholds[$i] = $th; - $th_specified = 1; - } else { - $thresholds[$i] = 0; - } - } - if (not $th_specified) { - @thresholds = (); - } - - # --threshold=X (tolerates a trailing '%') - } elsif ($arg =~ /^--threshold=([\d\.]+)%?$/) { - $single_threshold = $1; - ($1 >= 0 && $1 <= 20) or die($usage); - - # --show-percs=yes|no - } elsif ($arg =~ /^--show-percs=yes$/) { - $show_percs = 1; - } elsif ($arg =~ /^--show-percs=no$/) { - $show_percs = 0; - - # --auto=yes|no - } elsif ($arg =~ /^--auto=yes$/) { - $auto_annotate = 1; - } elsif ($arg =~ /^--auto=no$/) { - $auto_annotate = 0; - - # --context=N - } elsif ($arg =~ /^--context=([\d\.]+)$/) { - $context = $1; - if ($context < 0) { - die($usage); - } - - # We don't handle "-I name" -- there can be no space. - } elsif ($arg =~ /^-I$/) { - die("Sorry, no space is allowed after a -I flag\n"); - - # --include=A,B,C. Allow -I=name for backwards compatibility. - } elsif ($arg =~ /^(-I=|-I|--include=)(.*)$/) { - my $inc = $2; - $inc =~ s|/$||; # trim trailing '/' - push(@include_dirs, "$inc/"); - - } else { # -h and --help fall under this case - die($usage); - } - - # Argument handling -- annotation file checking and selection. - # Stick filenames into a hash for quick 'n easy lookup throughout. - } else { - if (not defined $input_file) { - # First non-option argument is the output file. - $input_file = $arg; - } else { - # Subsequent non-option arguments are source files. - my $readable = 0; - foreach my $include_dir (@include_dirs) { - if (-r $include_dir . $arg) { - $readable = 1; - } - } - $readable or die("File $arg not found in any of: @include_dirs\n"); - $user_ann_files{$arg} = 1; - } - } - } - - # Must have chosen an input file - if (not defined $input_file) { - die($usage); - } -} - -#----------------------------------------------------------------------------- -# Reading of input file -#----------------------------------------------------------------------------- -sub max ($$) -{ - my ($x, $y) = @_; - return ($x > $y ? $x : $y); -} - -# Add the two arrays; any '.' entries are ignored. Two tricky things: -# 1. If $a2->[$i] is undefined, it defaults to 0 which is what we want; we turn -# off warnings to allow this. This makes things about 10% faster than -# checking for definedness ourselves. -# 2. We don't add an undefined count or a ".", even though it's value is 0, -# because we don't want to make an $a2->[$i] that is undef become 0 -# unnecessarily. -sub add_array_a_to_b ($$) -{ - my ($a1, $a2) = @_; - - my $n = max(scalar @$a1, scalar @$a2); - $^W = 0; - foreach my $i (0 .. $n-1) { - $a2->[$i] += $a1->[$i] if (defined $a1->[$i] && "." ne $a1->[$i]); - } - $^W = 1; -} - -# Add each event count to the CC array. '.' counts become undef, as do -# missing entries (implicitly). -sub line_to_CC ($) -{ - my @CC = (split /\s+/, $_[0]); - (@CC <= @events) or die("Line $.: too many event counts\n"); - return \@CC; -} - -sub read_input_file() -{ - open(INPUTFILE, "< $input_file") - || die "Cannot open $input_file for reading\n"; - - # Read "desc:" lines. - my $line; - while ($line = ) { - if ($line =~ s/desc:\s+//) { - $desc .= $line; - } else { - last; - } - } - - # Read "cmd:" line (Nb: will already be in $line from "desc:" loop above). - ($line =~ s/^cmd:\s+//) or die("Line $.: missing command line\n"); - $cmd = $line; - chomp($cmd); # Remove newline - - # Read "events:" line. We make a temporary hash in which the Nth event's - # value is N, which is useful for handling --show/--sort options below. - $line = ; - (defined $line && $line =~ s/^events:\s+//) - or die("Line $.: missing events line\n"); - @events = split(/\s+/, $line); - my %events; - my $n = 0; - foreach my $event (@events) { - $events{$event} = $n; - $n++ - } - - # If no --show arg give, default to showing all events in the file. - # If --show option is used, check all specified events appeared in the - # "events:" line. Then initialise @show_order. - if (@show_events) { - foreach my $show_event (@show_events) { - (defined $events{$show_event}) or - die("--show event `$show_event' did not appear in input\n"); - } - } else { - @show_events = @events; - } - foreach my $show_event (@show_events) { - push(@show_order, $events{$show_event}); - } - - # Do as for --show, but if no --sort arg given, default to sorting by - # column order (ie. first column event is primary sort key, 2nd column is - # 2ndary key, etc). - if (@sort_events) { - foreach my $sort_event (@sort_events) { - (defined $events{$sort_event}) or - die("--sort event `$sort_event' did not appear in input\n"); - } - } else { - @sort_events = @events; - } - foreach my $sort_event (@sort_events) { - push(@sort_order, $events{$sort_event}); - } - - # If multiple threshold args weren't given via --sort, stick in the single - # threshold (either from --threshold if used, or the default otherwise) for - # the primary sort event, and 0% for the rest. - if (not @thresholds) { - foreach my $e (@sort_order) { - push(@thresholds, 100); - } - $thresholds[0] = $single_threshold; - } - - my $currFileName; - my $currFileFuncName; - - my $currFuncCC; - my $currFileCCs = {}; # hash(line_num => CC) - - # Read body of input file. - while () { - # Skip comments and empty lines. - next if /^\s*$/ || /^\#/; - - if (s/^(-?\d+)\s+//) { - my $lineNum = $1; - my $CC = line_to_CC($_); - defined($currFuncCC) || die; - add_array_a_to_b($CC, $currFuncCC); - - # If currFileName is selected, add CC to currFileName list. We look for - # full filename matches; or, if auto-annotating, we have to - # remember everything -- we won't know until the end what's needed. - defined($currFileCCs) || die; - if ($auto_annotate || defined $user_ann_files{$currFileName}) { - my $currLineCC = $currFileCCs->{$lineNum}; - if (not defined $currLineCC) { - $currLineCC = []; - $currFileCCs->{$lineNum} = $currLineCC; - } - add_array_a_to_b($CC, $currLineCC); - } - - } elsif (s/^fn=(.*)$//) { - $currFileFuncName = "$currFileName:$1"; - $currFuncCC = $fn_totals{$currFileFuncName}; - if (not defined $currFuncCC) { - $currFuncCC = []; - $fn_totals{$currFileFuncName} = $currFuncCC; - } - - } elsif (s/^fl=(.*)$//) { - $currFileName = $1; - $currFileCCs = $allCCs{$currFileName}; - if (not defined $currFileCCs) { - $currFileCCs = {}; - $allCCs{$currFileName} = $currFileCCs; - } - # Assume that a "fn=" line is followed by a "fl=" line. - $currFileFuncName = undef; - - } elsif (s/^summary:\s+//) { - $summary_CC = line_to_CC($_); - (scalar(@$summary_CC) == @events) - or die("Line $.: summary event and total event mismatch\n"); - - } else { - warn("WARNING: line $. malformed, ignoring\n"); - } - } - - # Check if summary line was present - if (not defined $summary_CC) { - die("missing final summary line, aborting\n"); - } - - close(INPUTFILE); -} - -#----------------------------------------------------------------------------- -# Print options used -#----------------------------------------------------------------------------- -sub print_options () -{ - print($fancy); - print($desc); - print("Command: $cmd\n"); - print("Data file: $input_file\n"); - print("Events recorded: @events\n"); - print("Events shown: @show_events\n"); - print("Event sort order: @sort_events\n"); - print("Thresholds: @thresholds\n"); - - my @include_dirs2 = @include_dirs; # copy @include_dirs - shift(@include_dirs2); # remove "" entry, which is always the first - unshift(@include_dirs2, "") if (0 == @include_dirs2); - my $include_dir = shift(@include_dirs2); - print("Include dirs: $include_dir\n"); - foreach my $include_dir (@include_dirs2) { - print(" $include_dir\n"); - } - - my @user_ann_files = keys %user_ann_files; - unshift(@user_ann_files, "") if (0 == @user_ann_files); - my $user_ann_file = shift(@user_ann_files); - print("User annotated: $user_ann_file\n"); - foreach $user_ann_file (@user_ann_files) { - print(" $user_ann_file\n"); - } - - my $is_on = ($auto_annotate ? "on" : "off"); - print("Auto-annotation: $is_on\n"); - print("\n"); -} - -#----------------------------------------------------------------------------- -# Print summary and sorted function totals -#----------------------------------------------------------------------------- -sub mycmp ($$) -{ - my ($c, $d) = @_; - - # Iterate through sort events (eg. 3,2); return result if two are different - foreach my $i (@sort_order) { - my ($x, $y); - $x = $c->[$i]; - $y = $d->[$i]; - $x = -1 unless defined $x; - $y = -1 unless defined $y; - - my $cmp = abs($y) <=> abs($x); # reverse sort of absolute size - if (0 != $cmp) { - return $cmp; - } - } - # Exhausted events, equal - return 0; -} - -sub commify ($) { - my ($val) = @_; - 1 while ($val =~ s/^(-?\d+)(\d{3})/$1,$2/); - return $val; -} - -# Because the counts can get very big, and we don't want to waste screen space -# and make lines too long, we compute exactly how wide each column needs to be -# by finding the widest entry for each one. -sub compute_CC_col_widths (@) -{ - my @CCs = @_; - my $CC_col_widths = []; - - # Initialise with minimum widths (from event names) - foreach my $event (@events) { - push(@$CC_col_widths, length($event)); - } - - # Find maximum width count for each column. @CC_col_width positions - # correspond to @CC positions. - foreach my $CC (@CCs) { - foreach my $i (0 .. scalar(@$CC)-1) { - if (defined $CC->[$i]) { - # Find length, accounting for commas that will be added, and - # possibly a percentage. - my $length = length $CC->[$i]; - my $width = $length + int(($length - 1) / 3); - if ($show_percs) { - $width += 9; # e.g. " (12.34%)" is 9 chars - } - $CC_col_widths->[$i] = max($CC_col_widths->[$i], $width); - } - } - } - return $CC_col_widths; -} - -# Print the CC with each column's size dictated by $CC_col_widths. -sub print_CC ($$) -{ - my ($CC, $CC_col_widths) = @_; - - foreach my $i (@show_order) { - my $count = (defined $CC->[$i] ? commify($CC->[$i]) : "."); - - my $perc = ""; - if ($show_percs) { - if (defined $CC->[$i] && $CC->[$i] != 0) { - # Try our best to keep the number fitting into 5 chars. This - # requires dropping a digit after the decimal place if it's - # sufficiently negative (e.g. "-10.0") or positive (e.g. - # "100.0"). Thanks to diffs it's possible to have even more - # extreme values, like "-100.0" or "1000.0"; those rare case - # will end up with slightly wrong indenting, oh well. - $perc = safe_div($CC->[$i] * 100, $summary_CC->[$i]); - $perc = (-9.995 < $perc && $perc < 99.995) - ? sprintf(" (%5.2f%%)", $perc) - : sprintf(" (%5.1f%%)", $perc); - } else { - # Don't show percentages for "." and "0" entries. - $perc = " "; - } - } - - # $reps will be negative for the extreme values mentioned above. The - # use of max() avoids a possible warning about a negative repeat count. - my $text = $count . $perc; - my $len = length($text); - my $reps = $CC_col_widths->[$i] - length($text); - my $space = ' ' x max($reps, 0); - print("$space$text "); - } -} - -sub print_events ($) -{ - my ($CC_col_widths) = @_; - - foreach my $i (@show_order) { - my $event = $events[$i]; - my $event_width = length($event); - my $col_width = $CC_col_widths->[$i]; - my $space = ' ' x ($col_width - $event_width); - print("$event$space "); - } -} - -# Prints summary and function totals (with separate column widths, so that -# function names aren't pushed over unnecessarily by huge summary figures). -# Also returns a hash containing all the files that are involved in getting the -# events count above the thresholds (ie. all the interesting ones). -sub print_summary_and_fn_totals () -{ - my @fn_fullnames = keys %fn_totals; - - # Work out the size of each column for printing (summary and functions - # separately). - my $summary_CC_col_widths = compute_CC_col_widths($summary_CC); - my $fn_CC_col_widths = compute_CC_col_widths(values %fn_totals); - - # Header and counts for summary - print($fancy); - print_events($summary_CC_col_widths); - print("\n"); - print($fancy); - print_CC($summary_CC, $summary_CC_col_widths); - print(" PROGRAM TOTALS\n"); - print("\n"); - - # Header for functions - print($fancy); - print_events($fn_CC_col_widths); - print(" file:function\n"); - print($fancy); - - # Sort function names into order dictated by --sort option. - @fn_fullnames = sort { - mycmp($fn_totals{$a}, $fn_totals{$b}) - } @fn_fullnames; - - - # Assertion - (scalar @sort_order == scalar @thresholds) or - die("sort_order length != thresholds length:\n", - " @sort_order\n @thresholds\n"); - - my $threshold_files = {}; - # @curr_totals has the same shape as @sort_order and @thresholds - my @curr_totals = (); - foreach my $e (@thresholds) { - push(@curr_totals, 0); - } - - # Print functions, stopping when the threshold has been reached. - foreach my $fn_name (@fn_fullnames) { - - my $fn_CC = $fn_totals{$fn_name}; - - # Stop when we've reached all the thresholds - my $any_thresholds_exceeded = 0; - foreach my $i (0 .. scalar @thresholds - 1) { - my $prop = safe_div(abs($fn_CC->[$sort_order[$i]] * 100), - abs($summary_CC->[$sort_order[$i]])); - $any_thresholds_exceeded ||= ($prop >= $thresholds[$i]); - } - last if not $any_thresholds_exceeded; - - # Print function results - print_CC($fn_CC, $fn_CC_col_widths); - print(" $fn_name\n"); - - # Update the threshold counts - my $filename = $fn_name; - $filename =~ s/:.+$//; # remove function name - $threshold_files->{$filename} = 1; - foreach my $i (0 .. scalar @sort_order - 1) { - $curr_totals[$i] += $fn_CC->[$sort_order[$i]] - if (defined $fn_CC->[$sort_order[$i]]); - } - } - print("\n"); - - return $threshold_files; -} - -#----------------------------------------------------------------------------- -# Annotate selected files -#----------------------------------------------------------------------------- - -# Issue a warning that the source file is more recent than the input file. -sub warning_on_src_more_recent_than_inputfile ($) -{ - my $src_file = $_[0]; - - my $warning = < Args: + def comma_separated_list(values: str) -> list[str]: + return values.split(",") + + def threshold(n: str) -> float: + f = float(n) + if 0 <= f <= 20: + return f + raise ValueError + + def add_bool_argument(p: ArgumentParser, name: str, help: str) -> None: + """ + Add a bool argument that defaults to true. + + Supports these forms: `--foo`, `--no-foo`, `--foo=yes`, `--foo=no`. + The latter two were the forms supported by the old Perl version of + `cg_annotate`, and are now deprecated. + """ + flag = "--" + name + dest = name.replace("-", "_") + + # Note: the default value is always printed with `BooleanOptionalAction`, + # due to an argparse bug: https://github.com/python/cpython/issues/83137. + p.add_argument( + flag, + default=True, + action=BooleanOptionalAction, + help=help, + ) + p.add_argument( + f"{flag}=yes", + dest=dest, + action="store_true", + help=f"(deprecated) same as --{name}", + ) + p.add_argument( + f"{flag}=no", + dest=dest, + action="store_false", + help=f"(deprecated) same as --no-{name}", + ) + + p = ArgumentParser(description="Process Cachegrind output files.") + + p.add_argument("--version", action="version", version="%(prog)s-@VERSION@") + + p.add_argument( + "--show", + type=comma_separated_list, + metavar="A,B,C", + help="only show figures for events A,B,C (default: all events)", + ) + + p.add_argument( + "--sort", + type=comma_separated_list, + metavar="A,B,C", + help="sort functions by events A,B,C (default: event column order)", + ) + + p.add_argument( + "--threshold", + type=threshold, + default=0.1, + metavar="N:[0,20]", + help="only show functions with more than N%% of primary sort event " + "counts (default: %(default)s)", + ) + add_bool_argument( + p, + "show-percs", + "show a percentage for each non-zero count", + ) + add_bool_argument( + p, + "auto", + "annotate all source files containing functions that reached the " + "event count threshold", + ) + p.add_argument( + "--context", + type=int, + default=8, + metavar="N", + help="print N lines of context before and after annotated lines " + "(default: %(default)s)", + ) + p.add_argument( + "-I", + "--include", + action="append", + default=[], + metavar="D", + help="add D to the list of searched source file directories", + ) + p.add_argument( + "cgout_filename", + nargs=1, + metavar="cachegrind-out-file", + help="file produced by Cachegrind", + ) + p.add_argument( + "src_filenames", + nargs="*", + metavar="source-files", + help="source files to annotate (usually not needed due to --auto)", + ) + + return p.parse_args(namespace=Args()) + + +# Args are stored in a global for easy access. +args = Args.parse() + + +# A single instance of this class is constructed, from `args` and the `events:` +# line in the cgout file. +class Events: + # The event names. + events: list[str] + + # The order in which we must traverse events for --show. Can be shorter + # than `events`. + show_events: list[str] + + # Like `show_events`, but indices into `events`, rather than names. + show_indices: list[int] + + # The order in which we must traverse events for --sort. Can be shorter + # than `events`. + sort_events: list[str] + + # Like `sort_events`, but indices into `events`, rather than names. + sort_indices: list[int] + + # Threshold percentages, one per sort event. Dictates when we stop printing + # functions. Positions correspond to positions in `sort_events`. Only + # `thresholds[0]` is actually used for thresholding, for historical + # reasons. + threshold_percs: list[float] + + def __init__(self, text: str) -> None: + self.events = text.split() + self.num_events = len(self.events) + + # A temporary dict mapping events to indices, [0, n-1]. + event_indices = {event: n for n, event in enumerate(self.events)} + + # If --show is given, check it is valid. If --show is not given, + # default to all events in the standard order. + if args.show: + for event in args.show: + if event not in event_indices: + die(f"--show event `{event}` did not appear in `events:` line") + self.show_events = args.show + else: + self.show_events = self.events + + self.show_indices = [event_indices[event] for event in self.show_events] + + # Likewise for --sort. + if args.sort: + for event in args.sort: + if event not in event_indices: + die(f"--sort event `{event}` did not appear in `events:` line") + self.sort_events = args.sort + else: + self.sort_events = self.events + + self.sort_indices = [event_indices[event] for event in self.sort_events] + + # The primary sort event gets the --threshold value, and all other sort + # events get 100% (i.e. ignored). + self.threshold_percs = [100] * len(self.sort_events) + self.threshold_percs[0] = args.threshold + + def mk_cc(self, text: str) -> Cc: + # This is slightly faster than a list comprehension. + counts = list(map(int, text.split())) + + if len(counts) == self.num_events: + pass + elif len(counts) < self.num_events: + # Add zeroes at the end for any missing numbers. + counts.extend([0] * (self.num_events - len(counts))) + else: + raise ValueError + + return Cc(counts) + + def mk_empty_cc(self) -> Cc: + # This is much faster than a list comprehension. + return Cc([0] * self.num_events) + + +class Cc: + """ + This is a dumb container for counts. + + It doesn't know anything about events, i.e. what each count means. It can + do basic operations like `__iadd__` and `__eq__`, and anything more must be + done elsewhere. `Events.mk_cc` and `Events.mk_empty_cc` are used for + construction. + """ + + # Always the same length as `Events.events`. + counts: list[int] + + def __init__(self, counts: list[int]) -> None: + self.counts = counts + + def __repr__(self) -> str: + return str(self.counts) + + def __eq__(self, other: object) -> bool: + if not isinstance(other, Cc): + return NotImplemented + return self.counts == other.counts + + def __iadd__(self, other: Cc) -> Cc: + for i, other_count in enumerate(other.counts): + self.counts[i] += other_count + return self + + +# A paired filename and function name. +Flfn = NewType("Flfn", tuple[str, str]) + +# Per-function CCs. +DictFlfnCc: TypeAlias = DefaultDict[Flfn, Cc] + +# Per-line CCs, organised by filename and line number. +DictLineCc: TypeAlias = DefaultDict[int, Cc] +DictFlDictLineCc: TypeAlias = DefaultDict[str, DictLineCc] + + +def die(msg: str) -> NoReturn: + print("cg_annotate: error:", msg, file=sys.stderr) + sys.exit(1) + + +def read_cgout_file() -> tuple[str, str, Events, DictFlfnCc, DictFlDictLineCc, Cc]: + # The file format is described in Cachegrind's manual. + try: + cgout_file = open(args.cgout_filename[0], "r", encoding="utf-8") + except OSError as err: + die(f"{err}") + + with cgout_file: + cgout_line_num = 0 + + def parse_die(msg: str) -> NoReturn: + die(f"{cgout_file.name}:{cgout_line_num}: {msg}") + + def readline() -> str: + nonlocal cgout_line_num + cgout_line_num += 1 + return cgout_file.readline() + + # Read "desc:" lines. + desc = "" + while line := readline(): + if m := re.match(r"desc:\s+(.*)", line): + desc += m.group(1) + "\n" + else: + break + + # Read "cmd:" line. (`line` is already set from the "desc:" loop.) + if m := re.match(r"cmd:\s+(.*)", line): + cmd = m.group(1) + else: + parse_die("missing a `command:` line") + + # Read "events:" line. + line = readline() + if m := re.match(r"events:\s+(.*)", line): + events = Events(m.group(1)) + else: + parse_die("missing an `events:` line") + + def mk_empty_dict_line_cc() -> DictLineCc: + return defaultdict(events.mk_empty_cc) + + curr_fl = "" + curr_flfn = Flfn(("", "")) + + # Three different places where we accumulate CC data. + dict_flfn_cc: DictFlfnCc = defaultdict(events.mk_empty_cc) + dict_fl_dict_line_cc: DictFlDictLineCc = defaultdict(mk_empty_dict_line_cc) + summary_cc = None + + # Compile the one hot regex. + count_pat = re.compile(r"(\d+)\s+(.*)") + + # Line matching is done in order of pattern frequency, for speed. + while True: + line = readline() + + if m := count_pat.match(line): + line_num = int(m.group(1)) + try: + cc = events.mk_cc(m.group(2)) + except ValueError: + parse_die("malformed or too many event counts") + + # Record this CC at the function level. + flfn_cc = dict_flfn_cc[curr_flfn] + flfn_cc += cc + + # Record this CC at the file/line level. + line_cc = dict_fl_dict_line_cc[curr_fl][line_num] + line_cc += cc + + elif line.startswith("fn="): + curr_flfn = Flfn((curr_fl, line[3:-1])) + + elif line.startswith("fl="): + curr_fl = line[3:-1] + # A `fn=` line should follow, overwriting the "???". + curr_flfn = Flfn((curr_fl, "???")) + + elif m := re.match(r"summary:\s+(.*)", line): + try: + summary_cc = events.mk_cc(m.group(1)) + except ValueError: + parse_die("too many event counts") + + elif line == "": + break # EOF + + elif line == "\n" or line.startswith("#"): + # Skip empty lines and comment lines. + pass + + else: + parse_die(f"malformed line: {line[:-1]}") + + # Check if summary line was present. + if not summary_cc: + parse_die("missing `summary:` line, aborting") + + # Check summary is correct. + total_cc = events.mk_empty_cc() + for flfn_cc in dict_flfn_cc.values(): + total_cc += flfn_cc + if summary_cc != total_cc: + msg = ( + "`summary:` line doesn't match compute total\n" + f"- summary: {summary_cc}\n" + f"- total: {total_cc}" + ) + parse_die(msg) + + return (desc, cmd, events, dict_flfn_cc, dict_fl_dict_line_cc, summary_cc) + + +def safe_perc(m: int, n: int) -> float: + return 0 if n == 0 else m * 100 / n + + +class CcPrinter: + # Note: every `CcPrinter` gets the same `Events` object. + events: Events + + # Note: every `CcPrinter` gets the same summary CC. + summary_cc: Cc + + # The width of each event column. For simplicity, its length matches + # `events.events`, even though not all events are necessarily shown. + widths: list[int] + + def __init__(self, events: Events, ccs: list[Cc], summary_cc: Cc) -> None: + self.events = events + self.summary_cc = summary_cc + + # Find min and max value for each event. One of them will be the + # widest value. + min_cc = events.mk_empty_cc() + max_cc = events.mk_empty_cc() + for cc in ccs: + for i, _ in enumerate(events.events): + count = cc.counts[i] + if count > max_cc.counts[i]: + max_cc.counts[i] = count + elif count < min_cc.counts[i]: + min_cc.counts[i] = count + + # Find maximum width for each column. + self.widths = [0] * len(events.events) + for i, event in enumerate(events.events): + # Get widest of the min and max, accounting for commas that will be + # added, and a possible percentage. + width = max(len(str(min_cc.counts[i])), len(str(max_cc.counts[i]))) + width += (width - 1) // 3 + if args.show_percs: + width += 9 # e.g. " (12.34%)" is 9 chars. + + # Account for the event name, too. + self.widths[i] = max(width, len(event)) + + def print_events(self, suffix: str) -> None: + for i in self.events.show_indices: + # +1 is for the single space between columns. + print(f"{self.events.events[i]:{self.widths[i] + 1}}", end="") + + print(suffix) + + def print_count(self, i: int, text: str) -> None: + print(f"{text:>{self.widths[i]}}", end=" ") + + def print_cc(self, cc: Cc, suffix: str) -> None: + for i in self.events.show_indices: + nstr = f"{cc.counts[i]:,d}" # commify + if args.show_percs: + if cc.counts[i] != 0: + # Try our best to keep the number fitting into 5 chars. This + # requires dropping a digit after the decimal place if it's + # sufficiently negative (e.g. "-10.0") or positive (e.g. + # "100.0"). Thanks to diffs it's possible to have even more + # extreme values, like "-100.0" or "1000.0"; those rare case + # will end up with slightly wrong indenting, oh well. + p = safe_perc(cc.counts[i], self.summary_cc.counts[i]) + normal = -9.995 < p < 99.995 + perc = f" ({p:5.{2 if normal else 1}f}%)" + else: + # Don't show percentages for "0" entries, it's just clutter. + perc = " " + else: + perc = "" + + self.print_count(i, nstr + perc) + + print("", suffix) + + def print_missing_cc(self, suffix: str) -> None: + if args.show_percs: + # Don't show percentages for "." entries, it's just clutter. + text = ". " + else: + text = "." + + for i in self.events.show_indices: + self.print_count(i, text) + + print("", suffix) + + +# Used in various places in the output. +FANCY: str = "-" * 80 + + +def print_header(desc: str, cmd: str, events: Events) -> None: + print(FANCY) + print(desc, end="") + print("Command: ", cmd) + print("Data file: ", args.cgout_filename[0]) + print("Events recorded: ", *events.events) + print("Events shown: ", *events.show_events) + print("Event sort order:", *events.sort_events) + print("Thresholds: ", *events.threshold_percs) + + if len(args.include) == 0: + print("Include dirs: ") + else: + print(f"Include dirs: {args.include[0]}") + for include_dirname in args.include[1:]: + print(f" {include_dirname}") + + if len(args.src_filenames) == 0: + print("User annotated: ") + else: + print(f"User annotated: {args.src_filenames[0]}") + for src_filename in args.src_filenames[1:]: + print(f" {src_filename}") + + print("Auto-annotation: ", "on" if args.auto else "off") + print() + + +def print_summary_cc(events: Events, summary_cc: Cc) -> None: + printer = CcPrinter(events, [summary_cc], summary_cc) + + print(FANCY) + printer.print_events("") + print(FANCY) + printer.print_cc(summary_cc, "PROGRAM TOTALS") + print() + + +def print_flfn_ccs( + events: Events, dict_flfn_cc: DictFlfnCc, summary_cc: Cc +) -> set[str]: + # Only the first threshold percentage is actually used. + threshold_index = events.sort_indices[0] + + # Convert the threshold from a percentage to an event count. + threshold = ( + events.threshold_percs[0] * abs(summary_cc.counts[threshold_index]) / 100 + ) + + def meets_threshold(flfn_and_cc: tuple[Flfn, Cc]) -> bool: + cc = flfn_and_cc[1] + return abs(cc.counts[threshold_index]) >= threshold + + # Create a list with the counts in sort order, so that left-to-right list + # comparison does the right thing. Plus the `Flfn` at the end for + # deterministic output when all the event counts are identical in two CCs. + def key(flfn_and_cc: tuple[Flfn, Cc]) -> tuple[list[int], Flfn]: + cc = flfn_and_cc[1] + return ([abs(cc.counts[i]) for i in events.sort_indices], flfn_and_cc[0]) + + # Filter out functions for which the primary sort event count is below the + # threshold, and sort the remainder. + filtered_flfns_and_ccs = filter(meets_threshold, dict_flfn_cc.items()) + sorted_flfns_and_ccs = sorted(filtered_flfns_and_ccs, key=key, reverse=True) + sorted_ccs = list(map(lambda flfn_and_cc: flfn_and_cc[1], sorted_flfns_and_ccs)) + + printer = CcPrinter(events, sorted_ccs, summary_cc) + + print(FANCY) + printer.print_events(" file:function") + print(FANCY) -END -; - print($warning); -} - -# If there is information about lines not in the file, issue a warning -# explaining possible causes. -sub warning_on_nonexistent_lines ($$$) -{ - my ($src_more_recent_than_inputfile, $src_file, $excess_line_nums) = @_; - my $cause_and_solution; - - if ($src_more_recent_than_inputfile) { - $cause_and_solution = < str: + return f"""\ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ -@@ -@@ Information recorded about lines past the end of '$src_file'. -@@ -@@ Probable cause and solution: -$cause_and_solution@@ +{msg}\ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ -END -; - print($warning); -} - -sub annotate_ann_files($) -{ - my ($threshold_files) = @_; - - my %all_ann_files; - my @unfound_auto_annotate_files; - my $printed_totals_CC = []; - - # If auto-annotating, add interesting files (but not "???") - if ($auto_annotate) { - delete $threshold_files->{"???"}; - %all_ann_files = (%user_ann_files, %$threshold_files) - } else { - %all_ann_files = %user_ann_files; - } - - # Track if we did any annotations. - my $did_annotations = 0; - - LOOP: - foreach my $src_file (keys %all_ann_files) { - - my $opened_file = ""; - my $full_file_name = ""; - # Nb: include_dirs already includes "", so it works in the case - # where the filename has the full path. - foreach my $include_dir (@include_dirs) { - my $try_name = $include_dir . $src_file; - if (open(INPUTFILE, "< $try_name")) { - $opened_file = $try_name; - $full_file_name = ($include_dir eq "" - ? $src_file - : "$include_dir + $src_file"); - last; - } - } - - if (not $opened_file) { - # Failed to open the file. If chosen on the command line, die. - # If arose from auto-annotation, print a little message. - if (defined $user_ann_files{$src_file}) { - die("File $src_file not opened in any of: @include_dirs\n"); - - } else { - push(@unfound_auto_annotate_files, $src_file); - } - - } else { - # File header (distinguish between user- and auto-selected files). - print("$fancy"); - my $ann_type = - (defined $user_ann_files{$src_file} ? "User" : "Auto"); - print("-- $ann_type-annotated source: $full_file_name\n"); - print("$fancy"); - - # Get file's CCs - my $src_file_CCs = $allCCs{$src_file}; - if (!defined $src_file_CCs) { - print(" No information has been collected for $src_file\n\n"); - next LOOP; - } - - $did_annotations = 1; - - # Numeric, not lexicographic sort! - my @line_nums = sort {$a <=> $b} keys %$src_file_CCs; - - # If $src_file more recent than cachegrind.out, issue warning - my $src_more_recent_than_inputfile = 0; - if ((stat $opened_file)[9] > (stat $input_file)[9]) { - $src_more_recent_than_inputfile = 1; - warning_on_src_more_recent_than_inputfile($src_file); - } - - # Work out the size of each column for printing - my $CC_col_widths = compute_CC_col_widths(values %$src_file_CCs); - - # Events header - print_events($CC_col_widths); - print("\n\n"); - - # Shift out 0 if it's in the line numbers (from unknown entries, - # likely due to bugs in Valgrind's stabs debug info reader) - shift(@line_nums) if (0 == $line_nums[0]); - - # Finds interesting line ranges -- all lines with a CC, and all - # lines within $context lines of a line with a CC. - my $n = @line_nums; - my @pairs; - for (my $i = 0; $i < $n; $i++) { - push(@pairs, $line_nums[$i] - $context); # lower marker - while ($i < $n-1 && - $line_nums[$i] + 2*$context >= $line_nums[$i+1]) { - $i++; - } - push(@pairs, $line_nums[$i] + $context); # upper marker - } - - # Annotate chosen lines, tracking total counts of lines printed - if (@pairs) { - $pairs[0] = 1 if ($pairs[0] < 1); - while (@pairs) { - my $low = shift @pairs; - my $high = shift @pairs; - while ($. < $low-1) { - my $tmp = ; - last unless (defined $tmp); # hack to detect EOF - } - my $src_line; - # Print line number, unless start of file - print("-- line $low " . '-' x 40 . "\n") if ($low != 1); - while (($. < $high) && ($src_line = )) { - if (defined $line_nums[0] && $. == $line_nums[0]) { - print_CC($src_file_CCs->{$.}, $CC_col_widths); - add_array_a_to_b($src_file_CCs->{$.}, - $printed_totals_CC); - shift(@line_nums); - - } else { - print_CC([], $CC_col_widths); - } - - print(" $src_line"); - } - # Print line number, unless EOF - if ($src_line) { - print("-- line $high " . '-' x 40 . "\n"); - } else { - last; - } - } - } - - # If there was info on lines past the end of the file... - if (@line_nums) { - foreach my $line_num (@line_nums) { - print_CC($src_file_CCs->{$line_num}, $CC_col_widths); - print(" \n"); - } - print("\n"); - warning_on_nonexistent_lines($src_more_recent_than_inputfile, - $src_file, \@line_nums); - } - print("\n"); - - # Print summary of counts attributed to file but not to any - # particular line (due to incomplete debug info). - if ($src_file_CCs->{0}) { - print_CC($src_file_CCs->{0}, $CC_col_widths); - print(" \n\n"); - } - - close(INPUTFILE); - } - } - - # Print list of unfound auto-annotate selected files. - if (@unfound_auto_annotate_files) { - print("$fancy"); - print("The following files chosen for auto-annotation could not be found:\n"); - print($fancy); - foreach my $f (sort @unfound_auto_annotate_files) { - print(" $f\n"); - } - print("\n"); - } +""" + +def warn_src_file_is_newer(src_filename: str, cgout_filename: str) -> None: + msg = f"""\ +@ Source file '{src_filename}' is more recent than input file '{cgout_filename}'. +@ Annotations may not be correct. +""" + print(mk_warning(msg)) + + +def warn_bogus_lines(src_filename: str) -> None: + msg = f"""\ +@@ Information recorded about lines past the end of '{src_filename}'. +""" + print(mk_warning(msg), end="") + + +def print_annotated_src_file( + events: Events, + dict_line_cc: DictLineCc, + ann_type: str, + src_file: TextIO, + annotated_cc: Cc, + summary_cc: Cc, +) -> None: + print(FANCY) + print("-- ", ann_type, "-annotated source: ", src_file.name, sep="") + print(FANCY) + + # Get file's CCs. + if not dict_line_cc: + print(f" No information has been collected for {src_file.name}") + print() + return + + # If the source file is more recent than the cgout file, issue warning. + if os.stat(src_file.name).st_mtime_ns > os.stat(args.cgout_filename[0]).st_mtime_ns: + warn_src_file_is_newer(src_file.name, args.cgout_filename[0]) + + printer = CcPrinter(events, list(dict_line_cc.values()), summary_cc) + + printer.print_events("") + print() + + # Remove the CC for line 0 if it's present. It gets special treatment + # later. + line0_cc = dict_line_cc.pop(0, None) + + # Find interesting line ranges: all lines with a CC, and all lines within + # `args.context` lines of a line with a CC. + line_nums = list(sorted(dict_line_cc.keys())) + pairs: list[tuple[int, int]] = [] + n = len(line_nums) + i = 0 + context = args.context + while i < n: + lo = max(line_nums[i] - context, 1) # `max` to prevent negatives + while i < n - 1 and line_nums[i] + 2 * context >= line_nums[i + 1]: + i += 1 + hi = line_nums[i] + context + pairs.append((lo, hi)) + i += 1 + + # Annotate chosen lines, tracking total annotated counts. + line_num = 0 + if pairs: + while pairs: + (lo, hi) = pairs.pop(0) + while line_num < lo - 1: + tmp = src_file.readline() + line_num += 1 + if not tmp: + break # EOF + + src_line = "" + # Print line number, unless start of file. + if lo != 1: + print("-- line", lo, "-" * 40) + + while line_num < hi: + src_line = src_file.readline() + line_num += 1 + if not src_line: + break + if line_nums and line_num == line_nums[0]: + printer.print_cc(dict_line_cc[line_num], src_line[:-1]) + annotated_cc += dict_line_cc[line_num] + del line_nums[0] + else: + printer.print_missing_cc(src_line[:-1]) + + # Print line number, unless EOF. + if src_line: + print("-- line", hi, "-" * 40) + else: + break + + # If there was info on lines past the end of the file, warn. + if line_nums: + for line_num in line_nums: + printer.print_cc(dict_line_cc[line_num], f"") + + print() + warn_bogus_lines(src_file.name) + + print() + + # Print summary of counts attributed to the source file but not to any + # particular line (due to incomplete debug info). + if line0_cc: + suffix = f"" + printer.print_cc(line0_cc, suffix) + print() + + +def print_annotated_src_files( + events: Events, + threshold_src_filenames: set[str], + dict_fl_dict_line_cc: DictFlDictLineCc, + summary_cc: Cc, +) -> tuple[list[str], Cc]: + unfound_auto_filenames: list[str] = [] + annotated_cc = events.mk_empty_cc() + + def pair_with(label: str) -> Callable[[str], tuple[str, str]]: + return lambda s: (s, label) + + # If auto-annotating, add interesting files (excluding "???"). + all_src_filenames = set(map(pair_with("User"), args.src_filenames)) + if args.auto: + threshold_src_filenames.discard("???") + all_src_filenames.update(map(pair_with("Auto"), threshold_src_filenames)) + + # Prepend "" to the include dirnames so things work in the case where the + # filename has the full path. + include_dirnames = args.include.copy() + include_dirnames.insert(0, "") + + for src_filename, ann_type in sorted(all_src_filenames): + annotated = False + for include_dirname in include_dirnames: + if include_dirname == "": + full_src_filename = src_filename + else: + full_src_filename = os.path.join(include_dirname, src_filename) + + try: + with open(full_src_filename, "r", encoding="utf-8") as src_file: + print_annotated_src_file( + events, + dict_fl_dict_line_cc[src_filename], + ann_type, + src_file, + annotated_cc, + summary_cc, + ) + annotated = True + break + except OSError: + pass + + if not annotated: + unfound_auto_filenames.append(src_filename) + + return (unfound_auto_filenames, annotated_cc) + + +def print_unfound_auto_filenames(unfound_auto_filenames: list[str]) -> None: + if unfound_auto_filenames: + print(FANCY) + print("The following files chosen for auto-annotation could not be found:") + print(FANCY) + for filename in sorted(unfound_auto_filenames): + print(" ", filename) + print() + + +def print_annotated_cc(events: Events, annotated_cc: Cc, summary_cc: Cc) -> None: # If we did any annotating, show how many events were covered by annotated # lines above. - if ($did_annotations) { - my $CC_col_widths = compute_CC_col_widths($printed_totals_CC); - print($fancy); - print_events($CC_col_widths); - print("\n"); - print($fancy); - print_CC($printed_totals_CC, $CC_col_widths); - print(" events annotated\n\n"); - } -} - -#---------------------------------------------------------------------------- -# "main()" -#---------------------------------------------------------------------------- -process_cmd_line(); -read_input_file(); -print_options(); -my $threshold_files = print_summary_and_fn_totals(); -annotate_ann_files($threshold_files); - -##--------------------------------------------------------------------## -##--- end cg_annotate.in ---## -##--------------------------------------------------------------------## + if args.auto or args.src_filenames: + printer = CcPrinter(events, [annotated_cc], summary_cc) + print(FANCY) + printer.print_events("") + print(FANCY) + printer.print_cc(annotated_cc, "events annotated") + print() + + +def main() -> None: + ( + desc, + cmd, + events, + dict_flfn_cc, + dict_fl_dict_line_cc, + summary_cc, + ) = read_cgout_file() + + # Each of these calls prints a section of the output. + + print_header(desc, cmd, events) + + print_summary_cc(events, summary_cc) + + threshold_src_filenames = print_flfn_ccs(events, dict_flfn_cc, summary_cc) + + (unfound_auto_filenames, annotated_cc) = print_annotated_src_files( + events, threshold_src_filenames, dict_fl_dict_line_cc, summary_cc + ) + + print_unfound_auto_filenames(unfound_auto_filenames) + + print_annotated_cc(events, annotated_cc, summary_cc) +if __name__ == "__main__": + main() diff --git a/cachegrind/docs/cg-manual.xml b/cachegrind/docs/cg-manual.xml index 7fabfa7fee..92fe086824 100644 --- a/cachegrind/docs/cg-manual.xml +++ b/cachegrind/docs/cg-manual.xml @@ -466,10 +466,8 @@ source. Use the to look for source files if the filenames found from the debugging information aren't specific enough. -Beware that cg_annotate can take some time to digest large -cachegrind.out.<pid> files, -e.g. 30 seconds or more. Also beware that auto-annotation can -produce a lot of output if your program is large! + Beware that auto-annotation can produce a lot of output if your program +is large. @@ -633,8 +631,7 @@ cg_annotate issues warnings. -This list looks long, but these cases should be fairly -rare. +These cases should be rare. @@ -946,7 +943,7 @@ small differences like these; it works in the same way as - + When enabled, a percentage is printed next to all event counts. @@ -957,7 +954,7 @@ small differences like these; it works in the same way as - + When enabled, automatically annotates every file that @@ -1442,9 +1439,9 @@ events_line ::= "events:" ws? (event ws)+ data_line ::= file_line | fn_line | count_line file_line ::= "fl=" filename fn_line ::= "fn=" fn_name -count_line ::= line_num ws? (count ws)+ -summary_line ::= "summary:" ws? (count ws)+ -count ::= num | "."]]> +count_line ::= line_num (ws+ count)* ws* +summary_line ::= "summary:" ws? count (ws+ count)+ ws* +count ::= num]]> Where: @@ -1479,19 +1476,17 @@ of the summary. This is a generic way of providing simulation specific information, e.g. for giving the cache configuration for cache simulation. -More than one line of info can be presented for each file/fn/line number. +More than one line of info can be present for each file/fn/line number. In such cases, the counts for the named events will be accumulated. -Counts can be "." to represent zero. This makes the files easier for -humans to read. - The number of counts in each line and the summary_line should not exceed the number of events in the event_line. If the number in each line is less, cg_annotate -treats those missing as though they were a "." entry. This saves space. +treats those missing as though they were a "0" entry. This can reduce +file size. A file_line changes the @@ -1504,9 +1499,9 @@ pertain to the current filename/fn_name. A "fn=" count_lines to give the context of the first count_lines. -Each file_line will normally be -immediately followed by a fn_line. But it -doesn't have to be. +Similarly, each file_line must be +immediately followed by a fn_line. + The summary line is redundant, because it just holds the total counts for each event. But this serves as a useful sanity check of the data; if diff --git a/cachegrind/pylintrc b/cachegrind/pylintrc new file mode 100644 index 0000000000..4b2cfb34af --- /dev/null +++ b/cachegrind/pylintrc @@ -0,0 +1,53 @@ +# How to create this file. +# - Generate with `pylint --generate-rcfile > pylintrc`. +# - Then modify entries resulting in unreasonable warnings. Comment out the +# original value, and add another comment line explaining the modification. +# - Remove all non-modified entries. + +[BASIC] + +# Minimum line length for functions/classes that require docstrings, shorter +# ones are exempt. +#docstring-min-length=-1 +# We don't care about having docstrings for all functions/classes. +docstring-min-length=1000 + +# Good variable names regexes, separated by a comma. If names match any regex, +# they will always be accepted +#good-names-rgxs= +# We allow any lower-case variable name of length 1 or 2. +good-names-rgxs=\b[a-z]\b,\b[a-z][a-z0-9]\b + +[VARIABLES] + +# List of names allowed to shadow builtins +#allowed-redefined-builtins= +# We use `help` reasonably as an argument. +allowed-redefined-builtins=help + +[DESIGN] + +# Maximum number of arguments for function / method. +#max-args=5 +# We have some large functions. +max-args=7 + +# Maximum number of branch for function / method body. +#max-branches=12 +# We have some large functions. +max-branches=25 + +# Maximum number of locals for function / method body. +#max-locals=15 +# We have some large functions. +max-locals=25 + +# Maximum number of statements in function / method body. +#max-statements=50 +# We have some large functions. +max-statements=65 + +# Minimum number of public methods for a class (see R0903). +#min-public-methods=2 +# We have some useful classes with little more than `__init__`. +min-public-methods=0 diff --git a/cachegrind/tests/ann2.post.exp b/cachegrind/tests/ann2.post.exp index d12fca0552..ac12bf87a4 100644 --- a/cachegrind/tests/ann2.post.exp +++ b/cachegrind/tests/ann2.post.exp @@ -9,8 +9,8 @@ Events shown: Dw Dr Ir Event sort order: Dr Thresholds: 0.1 Include dirs: -User annotated: -Auto-annotation: on +User annotated: a.c +Auto-annotation: off -------------------------------------------------------------------------------- Dw Dr Ir @@ -28,7 +28,7 @@ Dw Dr Ir file:function 0 5,158 ( 0.13%) 25,408 ( 0.49%) /build/glibc-OTsEL5/glibc-2.27/string/../sysdeps/x86_64/strcmp.S:strcmp -------------------------------------------------------------------------------- --- Auto-annotated source: a.c +-- User-annotated source: a.c -------------------------------------------------------------------------------- Dw Dr Ir @@ -40,14 +40,6 @@ Dw Dr Ir 0 1 ( 0.00%) 6 ( 0.00%) return z % 256; 0 2 ( 0.00%) 2 ( 0.00%) } --------------------------------------------------------------------------------- -The following files chosen for auto-annotation could not be found: --------------------------------------------------------------------------------- - /build/glibc-OTsEL5/glibc-2.27/elf/../sysdeps/x86_64/dl-machine.h - /build/glibc-OTsEL5/glibc-2.27/elf/dl-lookup.c - /build/glibc-OTsEL5/glibc-2.27/elf/dl-tunables.c - /build/glibc-OTsEL5/glibc-2.27/string/../sysdeps/x86_64/strcmp.S - -------------------------------------------------------------------------------- Dw Dr Ir -------------------------------------------------------------------------------- diff --git a/cachegrind/tests/ann2.vgtest b/cachegrind/tests/ann2.vgtest index 14ccd24dbe..7cf1b7fcd3 100644 --- a/cachegrind/tests/ann2.vgtest +++ b/cachegrind/tests/ann2.vgtest @@ -2,5 +2,5 @@ # the post-processing of the cgout-test file. prog: ../../tests/true vgopts: --cachegrind-out-file=cachegrind.out -post: touch cgout-test && perl ../../cachegrind/cg_annotate --sort=Dr --show=Dw,Dr,Ir --auto=yes cgout-test +post: touch cgout-test && perl ../../cachegrind/cg_annotate --sort=Dr --show=Dw,Dr,Ir --auto=no cgout-test a.c cleanup: rm cachegrind.out diff --git a/cachegrind/tests/ann3-aux/ann3-via-I.rs b/cachegrind/tests/ann3-aux/ann3-via-I.rs new file mode 100644 index 0000000000..5626abf0f7 --- /dev/null +++ b/cachegrind/tests/ann3-aux/ann3-via-I.rs @@ -0,0 +1 @@ +one diff --git a/cachegrind/tests/ann3-basic.rs b/cachegrind/tests/ann3-basic.rs new file mode 100644 index 0000000000..6dfea0f667 --- /dev/null +++ b/cachegrind/tests/ann3-basic.rs @@ -0,0 +1,20 @@ +one +two +three +four +five +six +seven +eight +nine +ten +eleven +twelve +thirteen +fourteen +fifteen +sixteen +seventeen +eighteen +nineteen +twenty diff --git a/cachegrind/tests/ann3-more-recent-than-cgout.rs b/cachegrind/tests/ann3-more-recent-than-cgout.rs new file mode 100644 index 0000000000..b2f931a673 --- /dev/null +++ b/cachegrind/tests/ann3-more-recent-than-cgout.rs @@ -0,0 +1,5 @@ +one +two +three +four +five diff --git a/cachegrind/tests/ann3-negatives.rs b/cachegrind/tests/ann3-negatives.rs new file mode 100644 index 0000000000..bea63466db --- /dev/null +++ b/cachegrind/tests/ann3-negatives.rs @@ -0,0 +1,15 @@ +one +two +three +four +five +six +seven +eight +nine +ten +eleven +twelve +thirteen +fourteen +fifteen diff --git a/cachegrind/tests/ann3-past-the-end.rs b/cachegrind/tests/ann3-past-the-end.rs new file mode 100644 index 0000000000..4cb29ea38f --- /dev/null +++ b/cachegrind/tests/ann3-past-the-end.rs @@ -0,0 +1,3 @@ +one +two +three diff --git a/cachegrind/tests/ann3-unmentioned.rs b/cachegrind/tests/ann3-unmentioned.rs new file mode 100644 index 0000000000..5626abf0f7 --- /dev/null +++ b/cachegrind/tests/ann3-unmentioned.rs @@ -0,0 +1 @@ +one diff --git a/cachegrind/tests/ann3.post.exp b/cachegrind/tests/ann3.post.exp new file mode 100644 index 0000000000..a648bb2e78 --- /dev/null +++ b/cachegrind/tests/ann3.post.exp @@ -0,0 +1,146 @@ +-------------------------------------------------------------------------------- +Command: ann3 +Data file: cgout-test3 +Events recorded: A SomeCount ThisIsAVeryLongEventName +Events shown: A SomeCount ThisIsAVeryLongEventName +Event sort order: A SomeCount ThisIsAVeryLongEventName +Thresholds: 0.5 100 100 +Include dirs: ann3-no-such-dir + ann3-no-such-dir-2 + ann3-aux +User annotated: ann3-unmentioned.rs + ann3-no-such-file.rs +Auto-annotation: on + +-------------------------------------------------------------------------------- +A SomeCount ThisIsAVeryLongEventName +-------------------------------------------------------------------------------- +100,000 (100.0%) 100,000 (100.0%) 0 PROGRAM TOTALS + +-------------------------------------------------------------------------------- +A SomeCount ThisIsAVeryLongEventName file:function +-------------------------------------------------------------------------------- +70,491 (70.49%) 90,491 (90.49%) 0 ann3-basic.rs:f0 +15,000 (15.00%) 600 ( 0.60%) 0 ann3-basic.rs:f1 + 9,000 ( 9.00%) 6,000 ( 6.00%) 0 ann3-could-not-be-found.rs:f1 + 2,000 ( 2.00%) 100 ( 0.10%) 0 ann3-basic.rs:f2 + 1,000 ( 1.00%) 500 ( 0.50%) 0 ann3-via-I.rs:f1 + 1,000 ( 1.00%) 300 ( 0.30%) -1,000 ( 0.00%) ann3-past-the-end.rs:f1 +-1,000 (-1.00%) 0 0 ann3-negatives.rs:neg3 +-1,000 (-1.00%) 0 0 ann3-negatives.rs:neg2 + 1,000 ( 1.00%) 0 0 ann3-more-recent-than-cgout.rs:new + 1,000 ( 1.00%) 0 0 ???:unknown + 500 ( 0.50%) 0 0 ann3-basic.rs:f6 + 500 ( 0.50%) 0 0 ann3-basic.rs:f4 + +-------------------------------------------------------------------------------- +-- Auto-annotated source: ann3-basic.rs +-------------------------------------------------------------------------------- +A SomeCount ThisIsAVeryLongEventName + +-- line 2 ---------------------------------------- + . . . two + . . . three + 5,000 ( 5.00%) 500 ( 0.50%) 0 four + 5,000 ( 5.00%) 100 ( 0.10%) 0 five + . . . six +70,491 (70.49%) 90,491 (90.49%) 0 seven + . . . eight + 110 ( 0.11%) 9 ( 0.01%) 0 nine + . . . ten + . . . eleven + 200 ( 0.20%) 0 0 twelve + 200 ( 0.20%) 0 0 thirteen + 100 ( 0.10%) 0 0 fourteen + 0 0 0 fifteen + 0 0 0 sixteen + 0 0 0 seventeen + 0 0 0 eighteen + 499 ( 0.50%) 2,000 ( 2.00%) 0 nineteen + 300 ( 0.30%) 0 0 twenty + + 7,100 ( 7.10%) 100 ( 0.10%) 0 + +-------------------------------------------------------------------------------- +-- Auto-annotated source: ann3-more-recent-than-cgout.rs +-------------------------------------------------------------------------------- +@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ +@@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ +@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ +@ Source file 'ann3-more-recent-than-cgout.rs' is more recent than input file 'cgout-test3'. +@ Annotations may not be correct. +@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ + +A SomeCount ThisIsAVeryLongEventName + + . . . one +1,000 ( 1.00%) 0 0 two + . . . three + . . . four +-- line 4 ---------------------------------------- + +-------------------------------------------------------------------------------- +-- Auto-annotated source: ann3-negatives.rs +-------------------------------------------------------------------------------- +A SomeCount ThisIsAVeryLongEventName + + 2,000 ( 2.00%) 2,000 ( 2.00%) 2,000 ( 0.00%) one + -1,000 (-1.00%) -1,000 (-1.00%) 0 two + . . . three + . . . four + 999,000 (999.0%) 0 -150,000 ( 0.00%) five +-1,000,000 (-1000.0%) 0 150,000 ( 0.00%) six + . . . seven + . . . eight + . . . nine + -10,000 (-10.0%) 0 10 ( 0.00%) ten + 10,000 (10.00%) 0 -20 ( 0.00%) eleven + . . . twelve + . . . thirteen +-- line 13 ---------------------------------------- + + -2,000 (-2.00%) -1,000 (-1.00%) -990 ( 0.00%) + +-------------------------------------------------------------------------------- +-- Auto-annotated source: ann3-past-the-end.rs +-------------------------------------------------------------------------------- +A SomeCount ThisIsAVeryLongEventName + +200 ( 0.20%) 100 ( 0.10%) 0 one + . . . two + . . . three +-- line 3 ---------------------------------------- +-- line 18 ---------------------------------------- +300 ( 0.30%) 100 ( 0.10%) 0 +300 ( 0.30%) 100 ( 0.10%) 0 +200 ( 0.20%) 0 -1,000 ( 0.00%) + +@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ +@@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ +@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ +@@ Information recorded about lines past the end of 'ann3-past-the-end.rs'. +@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ + +-------------------------------------------------------------------------------- +-- User-annotated source: ann3-unmentioned.rs +-------------------------------------------------------------------------------- + No information has been collected for ann3-unmentioned.rs + +-------------------------------------------------------------------------------- +-- Auto-annotated source: ann3-aux/ann3-via-I.rs +-------------------------------------------------------------------------------- +A SomeCount ThisIsAVeryLongEventName + +1,000 ( 1.00%) 500 ( 0.50%) 0 one + +-------------------------------------------------------------------------------- +The following files chosen for auto-annotation could not be found: +-------------------------------------------------------------------------------- + ann3-could-not-be-found.rs + ann3-no-such-file.rs + +-------------------------------------------------------------------------------- +A SomeCount ThisIsAVeryLongEventName +-------------------------------------------------------------------------------- +84,100 (84.10%) 94,700 (94.70%) 1,990 ( 0.00%) events annotated + diff --git a/cachegrind/tests/ann3.stderr.exp b/cachegrind/tests/ann3.stderr.exp new file mode 100644 index 0000000000..e8084c12c3 --- /dev/null +++ b/cachegrind/tests/ann3.stderr.exp @@ -0,0 +1,17 @@ + + +I refs: +I1 misses: +LLi misses: +I1 miss rate: +LLi miss rate: + +D refs: +D1 misses: +LLd misses: +D1 miss rate: +LLd miss rate: + +LL refs: +LL misses: +LL miss rate: diff --git a/cachegrind/tests/ann3.vgtest b/cachegrind/tests/ann3.vgtest new file mode 100644 index 0000000000..c4fb4cb140 --- /dev/null +++ b/cachegrind/tests/ann3.vgtest @@ -0,0 +1,13 @@ +# This tests all sorts of edge cases. See the comments in `cgout-test3` for +# more details. +# +# The `prog` doesn't matter because we don't use its output. Instead we test +# the post-processing of the cgout-test file. +prog: ../../tests/true +vgopts: --cachegrind-out-file=cachegrind.out + +# The `sleep` is to ensure the mtime of the second touched file is greater than +# the mtime of the first touched file. +post: touch cgout-test3 && sleep 0.1 && touch ann3-more-recent-than-cgout.rs && python3 ../../cachegrind/cg_annotate --context 2 --auto --show-percs=yes --threshold=0.5 -Iann3-no-such-dir --include ann3-no-such-dir-2 -I=ann3-aux cgout-test3 ann3-unmentioned.rs ann3-no-such-file.rs + +cleanup: rm cachegrind.out diff --git a/cachegrind/tests/cgout-test3 b/cachegrind/tests/cgout-test3 new file mode 100644 index 0000000000..7a3e188a8f --- /dev/null +++ b/cachegrind/tests/cgout-test3 @@ -0,0 +1,93 @@ +cmd: ann3 +events: A SomeCount ThisIsAVeryLongEventName + +# A file testing various things. +fl=ann3-basic.rs +# This one has the counts to get the totals to 100,000/100,000/0. +fn=f0 +7 70491 90491 0 +fn=f1 +# Different whitespace. Mix of line 0 and other lines. +0 5000 0 0 +4 5000 500 0 +5 5000 100 0 +# Line 0. +fn=f2 +0 2000 100 0 +# Below the threshold +fn=f3 +9 10 9 0 +fn=f4 +# Use of implicit zero event counts. +# Also just at the threshold. +12 200 0 0 +13 200 0 +14 100 +15 0 0 0 +16 0 0 +17 0 +18 +# Just below the threshold. +fn=f5 +19 499 2000 0 +fn=f6 +# Repeated line numbers, including ones from other functions. +# Also the total is identical to f4's total. +0 100 0 0 +9 100 0 0 +20 100 0 0 +20 100 0 0 +20 50 0 0 +20 50 0 0 + +# File with source newer than the cgout file. +fl=ann3-more-recent-than-cgout.rs +fn=new +2 1000 0 0 + +# File with negative and positive values. +fl=ann3-negatives.rs +# Various, and the sum is zero. +fn=neg1 +0 -1000 -1000 -1000 +1 2000 2000 2000 +2 -1000 -1000 0 +fn=neg2 +# Enormous numbers, but the sum is zero or almost zero. +# Also, because the summary value for `ThisIsAVeryLongEventName` is zero, the +# percentages here show up as zero. +5 999000 0 -150000 +6 -1000000 0 150000 +fn=neg3 +# Ditto. +0 -1000 0 10 +10 -10000 0 10 +11 10000 0 -20 + +# File with source newer than the cgout file. +fl=ann3-past-the-end.rs +# This filename is repeated in ann3-could-not-be-found.rs above. +fn=f1 +1 200 100 0 +20 300 100 0 +21 300 100 0 +22 200 0 -1000 + +# File mentioned here, but not present on disk. +fl=ann3-could-not-be-found.rs +fn=f1 +100 3000 2000 0 +101 3000 2000 0 +102 3000 2000 0 + +# File found in ann3-aux/, via -I. +fl=ann3-via-I.rs +fn=f1 +1 1000 500 0 + +# Unknown file +fl=??? +fn=unknown +0 1000 0 0 + +summary: 100000 100000 0 diff --git a/cachegrind/tests/diff.post.exp b/cachegrind/tests/diff.post.exp index 2f57945025..aa88967e26 100644 --- a/cachegrind/tests/diff.post.exp +++ b/cachegrind/tests/diff.post.exp @@ -29,7 +29,7 @@ Ir I1mr ILmr Dr D1mr DLmr 5,000,000 (100.0%) 0 0 -2,000,000 (100.0%) 0 0 0 0 0 -------------------------------------------------------------------------------- -Ir I1mr ILmr Dr D1mr DLmr Dw D1mw DLmw +Ir I1mr ILmr Dr D1mr DLmr Dw D1mw DLmw -------------------------------------------------------------------------------- -. . . . . . . . . events annotated +0 0 0 0 0 0 0 0 0 events annotated -- 2.43.5