1 # mem-phys-addr.py: Resolve physical address s 1 # mem-phys-addr.py: Resolve physical address samples
2 # SPDX-License-Identifier: GPL-2.0 2 # SPDX-License-Identifier: GPL-2.0
3 # 3 #
4 # Copyright (c) 2018, Intel Corporation. 4 # Copyright (c) 2018, Intel Corporation.
5 5
6 from __future__ import division 6 from __future__ import division
7 from __future__ import print_function <<
8 <<
9 import os 7 import os
10 import sys 8 import sys
11 import struct 9 import struct
12 import re 10 import re
13 import bisect 11 import bisect
14 import collections 12 import collections
15 13
16 sys.path.append(os.environ['PERF_EXEC_PATH'] + 14 sys.path.append(os.environ['PERF_EXEC_PATH'] + \
17 '/scripts/python/Perf-Trace-Util/lib/P 15 '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
18 16
19 #physical address ranges for System RAM 17 #physical address ranges for System RAM
20 system_ram = [] 18 system_ram = []
21 #physical address ranges for Persistent Memory 19 #physical address ranges for Persistent Memory
22 pmem = [] 20 pmem = []
23 #file object for proc iomem 21 #file object for proc iomem
24 f = None 22 f = None
25 #Count for each type of memory 23 #Count for each type of memory
26 load_mem_type_cnt = collections.Counter() 24 load_mem_type_cnt = collections.Counter()
27 #perf event name 25 #perf event name
28 event_name = None 26 event_name = None
29 27
30 def parse_iomem(): 28 def parse_iomem():
31 global f 29 global f
32 f = open('/proc/iomem', 'r') 30 f = open('/proc/iomem', 'r')
33 for i, j in enumerate(f): 31 for i, j in enumerate(f):
34 m = re.split('-|:',j,2) 32 m = re.split('-|:',j,2)
35 if m[2].strip() == 'System RAM 33 if m[2].strip() == 'System RAM':
36 system_ram.append(int( !! 34 system_ram.append(long(m[0], 16))
37 system_ram.append(int( !! 35 system_ram.append(long(m[1], 16))
38 if m[2].strip() == 'Persistent 36 if m[2].strip() == 'Persistent Memory':
39 pmem.append(int(m[0], !! 37 pmem.append(long(m[0], 16))
40 pmem.append(int(m[1], !! 38 pmem.append(long(m[1], 16))
41 39
42 def print_memory_type(): 40 def print_memory_type():
43 print("Event: %s" % (event_name)) !! 41 print "Event: %s" % (event_name)
44 print("%-40s %10s %10s\n" % ("Memory !! 42 print "%-40s %10s %10s\n" % ("Memory type", "count", "percentage"),
45 print("%-40s %10s %10s\n" % ("------ !! 43 print "%-40s %10s %10s\n" % ("----------------------------------------", \
46 "----- 44 "-----------", "-----------"),
47 end='' <<
48 total = sum(load_mem_type_cnt.values() 45 total = sum(load_mem_type_cnt.values())
49 for mem_type, count in sorted(load_mem 46 for mem_type, count in sorted(load_mem_type_cnt.most_common(), \
50 key = !! 47 key = lambda(k, v): (v, k), reverse = True):
51 print("%-40s %10d %10.1f%%\n !! 48 print "%-40s %10d %10.1f%%\n" % (mem_type, count, 100 * count / total),
52 (mem_type, count, 100 <<
53 end='') <<
54 49
55 def trace_begin(): 50 def trace_begin():
56 parse_iomem() 51 parse_iomem()
57 52
58 def trace_end(): 53 def trace_end():
59 print_memory_type() 54 print_memory_type()
60 f.close() 55 f.close()
61 56
62 def is_system_ram(phys_addr): 57 def is_system_ram(phys_addr):
63 #/proc/iomem is sorted 58 #/proc/iomem is sorted
64 position = bisect.bisect(system_ram, p 59 position = bisect.bisect(system_ram, phys_addr)
65 if position % 2 == 0: 60 if position % 2 == 0:
66 return False 61 return False
67 return True 62 return True
68 63
69 def is_persistent_mem(phys_addr): 64 def is_persistent_mem(phys_addr):
70 position = bisect.bisect(pmem, phys_ad 65 position = bisect.bisect(pmem, phys_addr)
71 if position % 2 == 0: 66 if position % 2 == 0:
72 return False 67 return False
73 return True 68 return True
74 69
75 def find_memory_type(phys_addr): 70 def find_memory_type(phys_addr):
76 if phys_addr == 0: 71 if phys_addr == 0:
77 return "N/A" 72 return "N/A"
78 if is_system_ram(phys_addr): 73 if is_system_ram(phys_addr):
79 return "System RAM" 74 return "System RAM"
80 75
81 if is_persistent_mem(phys_addr): 76 if is_persistent_mem(phys_addr):
82 return "Persistent Memory" 77 return "Persistent Memory"
83 78
84 #slow path, search all 79 #slow path, search all
85 f.seek(0, 0) 80 f.seek(0, 0)
86 for j in f: 81 for j in f:
87 m = re.split('-|:',j,2) 82 m = re.split('-|:',j,2)
88 if int(m[0], 16) <= phys_addr !! 83 if long(m[0], 16) <= phys_addr <= long(m[1], 16):
89 return m[2] 84 return m[2]
90 return "N/A" 85 return "N/A"
91 86
92 def process_event(param_dict): 87 def process_event(param_dict):
93 name = param_dict["ev_name"] 88 name = param_dict["ev_name"]
94 sample = param_dict["sample"] 89 sample = param_dict["sample"]
95 phys_addr = sample["phys_addr"] 90 phys_addr = sample["phys_addr"]
96 91
97 global event_name 92 global event_name
98 if event_name == None: 93 if event_name == None:
99 event_name = name 94 event_name = name
100 load_mem_type_cnt[find_memory_type(phy 95 load_mem_type_cnt[find_memory_type(phys_addr)] += 1
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.