Commit a483e64c authored by Adrian Hunter's avatar Adrian Hunter Committed by Arnaldo Carvalho de Melo
Browse files

perf scripting python: intel-pt-events.py: Add --insn-trace and --src-trace 



Add an instruction trace and a source trace to the intel-pt-events.py
script.

Signed-off-by: default avatarAdrian Hunter <adrian.hunter@intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Link: https://lore.kernel.org/r/20210530192308.7382-14-adrian.hunter@intel.com


Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent 2b87386c

tools/perf/Documentation/perf-intel-pt.txt

+5 −1
Original line number Diff line number Diff line
@@ -174,7 +174,11 @@ Refer to script export-to-sqlite.py or export-to-postgresql.py for more details, 
and to script exported-sql-viewer.py for an example of using the database.



There is also script intel-pt-events.py which provides an example of how to

unpack the raw data for power events and PTWRITE.

unpack the raw data for power events and PTWRITE. The script also displays

branches, and supports 2 additional modes selected by option:



 --insn-trace - instruction trace

 --src-trace - source trace



As mentioned above, it is easy to capture too much data.  One way to limit the

data captured is to use 'snapshot' mode which is explained further below.

tools/perf/scripts/python/intel-pt-events.py

+158 −18
Original line number Diff line number Diff line
@@ -16,13 +16,16 @@ from __future__ import print_function 
import os

import sys

import struct

import argparse



from libxed import LibXED

from ctypes import create_string_buffer, addressof



sys.path.append(os.environ['PERF_EXEC_PATH'] + \

	'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')



# These perf imports are not used at present

#from perf_trace_context import *

#from Core import *

from perf_trace_context import perf_set_itrace_options, \

	perf_sample_insn, perf_sample_srccode



try:

	broken_pipe_exception = BrokenPipeError
@@ -31,6 +34,12 @@ except: 


glb_switch_str		= None

glb_switch_printed	= True

glb_insn		= False

glb_disassembler	= None

glb_src			= False

glb_source_file_name	= None

glb_line_number		= None

glb_dso			= None



def get_optional_null(perf_dict, field):

	if field in perf_dict:
@@ -42,6 +51,11 @@ def get_optional_zero(perf_dict, field): 
		return perf_dict[field]

	return 0



def get_optional_bytes(perf_dict, field):

	if field in perf_dict:

		return perf_dict[field]

	return bytes()



def get_optional(perf_dict, field):

	if field in perf_dict:

		return perf_dict[field]
@@ -53,7 +67,31 @@ def get_offset(perf_dict, field): 
	return ""



def trace_begin():

	ap = argparse.ArgumentParser(usage = "", add_help = False)

	ap.add_argument("--insn-trace", action='store_true')

	ap.add_argument("--src-trace", action='store_true')

	global glb_args

	global glb_insn

	global glb_src

	glb_args = ap.parse_args()

	if glb_args.insn_trace:

		print("Intel PT Instruction Trace")

		itrace = "i0nsepwx"

		glb_insn = True

	elif glb_args.src_trace:

		print("Intel PT Source Trace")

		itrace = "i0nsepwx"

		glb_insn = True

		glb_src = True

	else:

		print("Intel PT Branch Trace, Power Events and PTWRITE")

		itrace = "bepwx"

	global glb_disassembler

	try:

		glb_disassembler = LibXED()

	except:

		glb_disassembler = None

	perf_set_itrace_options(perf_script_context, itrace)



def trace_end():

	print("End")
@@ -111,11 +149,14 @@ def print_psb(raw_buf): 
	offset = data[1]

	print("offset: %#x" % (offset), end=' ')



def print_common_start(comm, sample, name):

def common_start_str(comm, sample):

	ts = sample["time"]

	cpu = sample["cpu"]

	pid = sample["pid"]

	tid = sample["tid"]

	return "%16s %5u/%-5u [%03u] %9u.%09u  " % (comm, pid, tid, cpu, ts / 1000000000, ts %1000000000)



def print_common_start(comm, sample, name):

	flags_disp = get_optional_null(sample, "flags_disp")

	# Unused fields:

	# period      = sample["period"]
@@ -123,22 +164,96 @@ def print_common_start(comm, sample, name): 
	# weight      = sample["weight"]

	# transaction = sample["transaction"]

	# cpumode     = get_optional_zero(sample, "cpumode")

	print("%16s %5u/%-5u [%03u] %9u.%09u  %7s  %19s" %

		(comm, pid, tid, cpu, ts / 1000000000, ts %1000000000, name, flags_disp),

		end=' ')

	print(common_start_str(comm, sample) + "%7s  %19s" % (name, flags_disp), end=' ')



def print_instructions_start(comm, sample):

	if "x" in get_optional_null(sample, "flags"):

		print(common_start_str(comm, sample) + "x", end=' ')

	else:

		print(common_start_str(comm, sample), end='  ')



def disassem(insn, ip):

	inst = glb_disassembler.Instruction()

	glb_disassembler.SetMode(inst, 0) # Assume 64-bit

	buf = create_string_buffer(64)

	buf.value = insn

	return glb_disassembler.DisassembleOne(inst, addressof(buf), len(insn), ip)



def print_common_ip(param_dict, sample, symbol, dso):

	ip   = sample["ip"]

	offs = get_offset(param_dict, "symoff")

	if "cyc_cnt" in sample:

		cyc_cnt = sample["cyc_cnt"]

		insn_cnt = get_optional_zero(sample, "insn_cnt")

		ipc_str = "  IPC: %#.2f (%u/%u)" % (insn_cnt / cyc_cnt, insn_cnt, cyc_cnt)

	else:

		ipc_str = ""

	if glb_insn and glb_disassembler is not None:

		insn = perf_sample_insn(perf_script_context)

		if insn and len(insn):

			cnt, text = disassem(insn, ip)

			byte_str = ("%x" % ip).rjust(16)

			if sys.version_info.major >= 3:

				for k in range(cnt):

					byte_str += " %02x" % insn[k]

			else:

				for k in xrange(cnt):

					byte_str += " %02x" % ord(insn[k])

			print("%-40s  %-30s" % (byte_str, text), end=' ')

		print("%s%s (%s)" % (symbol, offs, dso), end=' ')

	else:

		print("%16x %s%s (%s)" % (ip, symbol, offs, dso), end=' ')

	if "addr_correlates_sym" in sample:

		addr   = sample["addr"]

		dso    = get_optional(sample, "addr_dso")

		symbol = get_optional(sample, "addr_symbol")

		offs   = get_offset(sample, "addr_symoff")

		print("=> %x %s%s (%s)" % (addr, symbol, offs, dso))

		print("=> %x %s%s (%s)%s" % (addr, symbol, offs, dso, ipc_str))

	else:

		print(ipc_str)



def print_srccode(comm, param_dict, sample, symbol, dso, with_insn):

	ip = sample["ip"]

	if symbol == "[unknown]":

		start_str = common_start_str(comm, sample) + ("%x" % ip).rjust(16).ljust(40)

	else:

		offs = get_offset(param_dict, "symoff")

		start_str = common_start_str(comm, sample) + (symbol + offs).ljust(40)



	if with_insn and glb_insn and glb_disassembler is not None:

		insn = perf_sample_insn(perf_script_context)

		if insn and len(insn):

			cnt, text = disassem(insn, ip)

		start_str += text.ljust(30)



	global glb_source_file_name

	global glb_line_number

	global glb_dso



	source_file_name, line_number, source_line = perf_sample_srccode(perf_script_context)

	if source_file_name:

		if glb_line_number == line_number and glb_source_file_name == source_file_name:

			src_str = ""

		else:

			if len(source_file_name) > 40:

				src_file = ("..." + source_file_name[-37:]) + " "

			else:

		print()

				src_file = source_file_name.ljust(41)

			if source_line is None:

				src_str = src_file + str(line_number).rjust(4) + " <source not found>"

			else:

				src_str = src_file + str(line_number).rjust(4) + " " + source_line

		glb_dso = None

	elif dso == glb_dso:

		src_str = ""

	else:

		src_str = dso

		glb_dso = dso



	glb_line_number = line_number

	glb_source_file_name = source_file_name



	print(start_str, src_str)



def do_process_event(param_dict):

	global glb_switch_printed
@@ -159,23 +274,48 @@ def do_process_event(param_dict): 
	dso    = get_optional(param_dict, "dso")

	symbol = get_optional(param_dict, "symbol")



	if name[0:12] == "instructions":

		if glb_src:

			print_srccode(comm, param_dict, sample, symbol, dso, True)

		else:

			print_instructions_start(comm, sample)

			print_common_ip(param_dict, sample, symbol, dso)

	elif name[0:8] == "branches":

		if glb_src:

			print_srccode(comm, param_dict, sample, symbol, dso, False)

		else:

			print_common_start(comm, sample, name)

			print_common_ip(param_dict, sample, symbol, dso)

	elif name == "ptwrite":

		print_common_start(comm, sample, name)



	if name == "ptwrite":

		print_ptwrite(raw_buf)

		print_common_ip(param_dict, sample, symbol, dso)

	elif name == "cbr":

		print_common_start(comm, sample, name)

		print_cbr(raw_buf)

		print_common_ip(param_dict, sample, symbol, dso)

	elif name == "mwait":

		print_common_start(comm, sample, name)

		print_mwait(raw_buf)

		print_common_ip(param_dict, sample, symbol, dso)

	elif name == "pwre":

		print_common_start(comm, sample, name)

		print_pwre(raw_buf)

		print_common_ip(param_dict, sample, symbol, dso)

	elif name == "exstop":

		print_common_start(comm, sample, name)

		print_exstop(raw_buf)

		print_common_ip(param_dict, sample, symbol, dso)

	elif name == "pwrx":

		print_common_start(comm, sample, name)

		print_pwrx(raw_buf)

		print_common_ip(param_dict, sample, symbol, dso)

	elif name == "psb":

		print_common_start(comm, sample, name)

		print_psb(raw_buf)



		print_common_ip(param_dict, sample, symbol, dso)

	else:

		print_common_start(comm, sample, name)

		print_common_ip(param_dict, sample, symbol, dso)



def process_event(param_dict):