1 files changed, 0 insertions, 127 deletions
diff --git a/tools/perf/scripts/python/mem-phys-addr.py b/tools/perf/scripts/python/mem-phys-addr.py
deleted file mode 100644
index 5e237a5a5f1b..000000000000
--- a/tools/perf/scripts/python/mem-phys-addr.py
+++ /dev/null
@@ -1,127 +0,0 @@
-# mem-phys-addr.py: Resolve physical address samples
-# SPDX-License-Identifier: GPL-2.0
-#
-# Copyright (c) 2018, Intel Corporation.
-
-import os
-import sys
-import re
-import bisect
-import collections
-from dataclasses import dataclass
-from typing import (Dict, Optional)
-
-sys.path.append(os.environ['PERF_EXEC_PATH'] + \
-    '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
-
-@dataclass(frozen=True)
-class IomemEntry:
-    """Read from a line in /proc/iomem"""
-    begin: int
-    end: int
-    indent: int
-    label: str
-
-# Physical memory layout from /proc/iomem. Key is the indent and then
-# a list of ranges.
-iomem: Dict[int, list[IomemEntry]] = collections.defaultdict(list)
-# Child nodes from the iomem parent.
-children: Dict[IomemEntry, set[IomemEntry]] = collections.defaultdict(set)
-# Maximum indent seen before an entry in the iomem file.
-max_indent: int = 0
-# Count for each range of memory.
-load_mem_type_cnt: Dict[IomemEntry, int] = collections.Counter()
-# Perf event name set from the first sample in the data.
-event_name: Optional[str] = None
-
-def parse_iomem():
-    """Populate iomem from /proc/iomem file"""
-    global iomem
-    global max_indent
-    global children
-    with open('/proc/iomem', 'r', encoding='ascii') as f:
-        for line in f:
-            indent = 0
-            while line[indent] == ' ':
-                indent += 1
-            if indent > max_indent:
-                max_indent = indent
-            m = re.split('-|:', line, 2)
-            begin = int(m[0], 16)
-            end = int(m[1], 16)
-            label = m[2].strip()
-            entry = IomemEntry(begin, end, indent, label)
-            # Before adding entry, search for a parent node using its begin.
-            if indent > 0:
-                parent = find_memory_type(begin)
-                assert parent, f"Given indent expected a parent for {label}"
-                children[parent].add(entry)
-            iomem[indent].append(entry)
-
-def find_memory_type(phys_addr) -> Optional[IomemEntry]:
-    """Search iomem for the range containing phys_addr with the maximum indent"""
-    for i in range(max_indent, -1, -1):
-        if i not in iomem:
-            continue
-        position = bisect.bisect_right(iomem[i], phys_addr,
-                                       key=lambda entry: entry.begin)
-        if position is None:
-            continue
-        iomem_entry = iomem[i][position-1]
-        if  iomem_entry.begin <= phys_addr <= iomem_entry.end:
-            return iomem_entry
-    print(f"Didn't find {phys_addr}")
-    return None
-
-def print_memory_type():
-    print(f"Event: {event_name}")
-    print(f"{'Memory type':<40}  {'count':>10}  {'percentage':>10}")
-    print(f"{'-' * 40:<40}  {'-' * 10:>10}  {'-' * 10:>10}")
-    total = sum(load_mem_type_cnt.values())
-    # Add count from children into the parent.
-    for i in range(max_indent, -1, -1):
-        if i not in iomem:
-            continue
-        for entry in iomem[i]:
-            global children
-            for child in children[entry]:
-                if load_mem_type_cnt[child] > 0:
-                    load_mem_type_cnt[entry] += load_mem_type_cnt[child]
-
-    def print_entries(entries):
-        """Print counts from parents down to their children"""
-        global children
-        for entry in sorted(entries,
-                            key = lambda entry: load_mem_type_cnt[entry],
-                            reverse = True):
-            count = load_mem_type_cnt[entry]
-            if count > 0:
-                mem_type = ' ' * entry.indent + f"{entry.begin:x}-{entry.end:x} : {entry.label}"
-                percent = 100 * count / total
-                print(f"{mem_type:<40}  {count:>10}  {percent:>10.1f}")
-                print_entries(children[entry])
-
-    print_entries(iomem[0])
-
-def trace_begin():
-    parse_iomem()
-
-def trace_end():
-    print_memory_type()
-
-def process_event(param_dict):
-    if "sample" not in param_dict:
-        return
-
-    sample = param_dict["sample"]
-    if "phys_addr" not in sample:
-        return
-
-    phys_addr  = sample["phys_addr"]
-    entry = find_memory_type(phys_addr)
-    if entry:
-        load_mem_type_cnt[entry] += 1
-
-    global event_name
-    if event_name is None:
-        event_name  = param_dict["ev_name"]