1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
# 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"]
|
