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

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