-#!/usr/bin/python
-
-#
-# Copyright (c) 2014, ARM Limited. All rights reserved.
-#
-# SPDX-License-Identifier: BSD-2-Clause-Patent
-#
-
-import getopt
-import operator
-import os
-import pickle
-import sys
-from sys import argv
-from cStringIO import StringIO
-
-modules = {}
-functions = {}
-functions_addr = {}
-
-def usage():
- print "-t,--trace: Location of the Trace file"
- print "-s,--symbols: Location of the symbols and modules"
-
-def get_address_from_string(address):
- return int(address.strip("S:").strip("N:").strip("EL2:").strip("EL1:"), 16)
-
-def get_module_from_addr(modules, addr):
- for key,value in modules.items():
- if (value['start'] <= addr) and (addr <= value['end']):
- return key
- return None
-
-def add_cycles_to_function(functions, func_name, addr, cycles):
- if func_name != "<Unknown>":
- # Check if we are still in the previous function
- if add_cycles_to_function.prev_func_name == func_name:
- add_cycles_to_function.prev_entry['cycles'] += cycles
- return (add_cycles_to_function.prev_func_name, add_cycles_to_function.prev_module_name)
-
- if func_name in functions.keys():
- for module_name, module_value in functions[func_name].iteritems():
- if (module_value['start'] <= addr) and (addr < module_value['end']):
- module_value['cycles'] += cycles
-
- add_cycles_to_function.prev_func_name = func_name
- add_cycles_to_function.prev_module_name = module_name
- add_cycles_to_function.prev_entry = module_value
- return (func_name, module_name)
- elif (module_value['end'] == 0):
- module_value['cycles'] += cycles
-
- add_cycles_to_function.prev_func_name = func_name
- add_cycles_to_function.prev_module_name = module_name
- add_cycles_to_function.prev_entry = module_value
- return (func_name, module_name)
-
- # Workaround to fix the 'info func' limitation that does not expose the 'static' function
- module_name = get_module_from_addr(modules, addr)
- functions[func_name] = {}
- functions[func_name][module_name] = {}
- functions[func_name][module_name]['start'] = 0
- functions[func_name][module_name]['end'] = 0
- functions[func_name][module_name]['cycles'] = cycles
- functions[func_name][module_name]['count'] = 0
-
- add_cycles_to_function.prev_func_name = func_name
- add_cycles_to_function.prev_module_name = module_name
- add_cycles_to_function.prev_entry = functions[func_name][module_name]
- return (func_name, module_name)
- else:
- # Check if we are still in the previous function
- if (add_cycles_to_function.prev_entry is not None) and (add_cycles_to_function.prev_entry['start'] <= addr) and (addr < add_cycles_to_function.prev_entry['end']):
- add_cycles_to_function.prev_entry['cycles'] += cycles
- return (add_cycles_to_function.prev_func_name, add_cycles_to_function.prev_module_name)
-
- # Generate the key for the given address
- key = addr & ~0x0FFF
-
- if key not in functions_addr.keys():
- if 'Unknown' not in functions.keys():
- functions['Unknown'] = {}
- if 'Unknown' not in functions['Unknown'].keys():
- functions['Unknown']['Unknown'] = {}
- functions['Unknown']['Unknown']['cycles'] = 0
- functions['Unknown']['Unknown']['count'] = 0
- functions['Unknown']['Unknown']['cycles'] += cycles
-
- add_cycles_to_function.prev_func_name = None
- return None
-
- for func_key, module in functions_addr[key].iteritems():
- for module_key, module_value in module.iteritems():
- if (module_value['start'] <= addr) and (addr < module_value['end']):
- module_value['cycles'] += cycles
-
- # In case o <Unknown> we prefer to fallback on the direct search
- add_cycles_to_function.prev_func_name = func_key
- add_cycles_to_function.prev_module_name = module_key
- add_cycles_to_function.prev_entry = module_value
- return (func_key, module_key)
-
- print "Warning: Function %s @ 0x%x not found" % (func_name, addr)
-
- add_cycles_to_function.prev_func_name = None
- return None
-
-# Static variables for the previous function
-add_cycles_to_function.prev_func_name = None
-add_cycles_to_function.prev_entry = None
-
-def trace_read():
- global trace_process
- line = trace.readline()
- trace_process += len(line)
- return line
-
-#
-# Parse arguments
-#
-trace_name = None
-symbols_file = None
-
-opts,args = getopt.getopt(sys.argv[1:], "ht:vs:v", ["help","trace=","symbols="])
-if (opts is None) or (not opts):
- usage()
- sys.exit()
-
-for o,a in opts:
- if o in ("-h","--help"):
- usage()
- sys.exit()
- elif o in ("-t","--trace"):
- trace_name = a
- elif o in ("-s","--symbols"):
- symbols_file = a
- else:
- assert False, "Unhandled option (%s)" % o
-
-#
-# We try first to see if we run the script from DS-5
-#
-try:
- from arm_ds.debugger_v1 import Debugger
- from arm_ds.debugger_v1 import DebugException
-
- # Debugger object for accessing the debugger
- debugger = Debugger()
-
- # Initialisation commands
- ec = debugger.getExecutionContext(0)
- ec.getExecutionService().stop()
- ec.getExecutionService().waitForStop()
- # in case the execution context reference is out of date
- ec = debugger.getExecutionContext(0)
-
- #
- # Get the module name and their memory range
- #
- info_file = ec.executeDSCommand("info file")
- info_file_str = StringIO(info_file)
-
- line = info_file_str.readline().strip('\n')
- while line != '':
- if ("Symbols from" in line):
- # Get the module name from the line 'Symbols from "/home/...."'
- module_name = line.split("\"")[1].split("/")[-1]
- modules[module_name] = {}
-
- # Look for the text section
- line = info_file_str.readline().strip('\n')
- while (line != '') and ("Symbols from" not in line):
- if ("ER_RO" in line):
- modules[module_name]['start'] = get_address_from_string(line.split()[0])
- modules[module_name]['end'] = get_address_from_string(line.split()[2])
- line = info_file_str.readline().strip('\n')
- break;
- if (".text" in line):
- modules[module_name]['start'] = get_address_from_string(line.split()[0])
- modules[module_name]['end'] = get_address_from_string(line.split()[2])
- line = info_file_str.readline().strip('\n')
- break;
- line = info_file_str.readline().strip('\n')
- line = info_file_str.readline().strip('\n')
-
- #
- # Get the function name and their memory range
- #
- info_func = ec.executeDSCommand("info func")
- info_func_str = StringIO(info_func)
-
- # Skip the first line 'Low-level symbols ...'
- line = info_func_str.readline().strip('\n')
- func_prev = None
- while line != '':
- # We ignore all the functions after 'Functions in'
- if ("Functions in " in line):
- line = info_func_str.readline().strip('\n')
- while line != '':
- line = info_func_str.readline().strip('\n')
- line = info_func_str.readline().strip('\n')
- continue
-
- if ("Low-level symbols" in line):
- # We need to fixup the last function of the module
- if func_prev is not None:
- func_prev['end'] = modules[module_name]['end']
- func_prev = None
-
- line = info_func_str.readline().strip('\n')
- continue
-
- func_name = line.split()[1]
- func_start = get_address_from_string(line.split()[0])
- module_name = get_module_from_addr(modules, func_start)
-
- if func_name not in functions.keys():
- functions[func_name] = {}
- functions[func_name][module_name] = {}
- functions[func_name][module_name]['start'] = func_start
- functions[func_name][module_name]['cycles'] = 0
- functions[func_name][module_name]['count'] = 0
-
- # Set the end address of the previous function
- if func_prev is not None:
- func_prev['end'] = func_start
- func_prev = functions[func_name][module_name]
-
- line = info_func_str.readline().strip('\n')
-
- # Fixup the last function
- func_prev['end'] = modules[module_name]['end']
-
- if symbols_file is not None:
- pickle.dump((modules, functions), open(symbols_file, "w"))
-except:
- if symbols_file is None:
- print "Error: Symbols file is required when run out of ARM DS-5"
- sys.exit()
-
- (modules, functions) = pickle.load(open(symbols_file, "r"))
-
-#
-# Build optimized table for the <Unknown> functions
-#
-functions_addr = {}
-for func_key, module in functions.iteritems():
- for module_key, module_value in module.iteritems():
- key = module_value['start'] & ~0x0FFF
- if key not in functions_addr.keys():
- functions_addr[key] = {}
- if func_key not in functions_addr[key].keys():
- functions_addr[key][func_key] = {}
- functions_addr[key][func_key][module_key] = module_value
-
-#
-# Process the trace file
-#
-if trace_name is None:
- sys.exit()
-
-trace = open(trace_name, "r")
-trace_size = os.path.getsize(trace_name)
-trace_process = 0
-
-# Get the column names from the first line
-columns = trace_read().split()
-column_addr = columns.index('Address')
-column_cycles = columns.index('Cycles')
-column_function = columns.index('Function')
-
-line = trace_read()
-i = 0
-prev_callee = None
-while line:
- try:
- func_name = line.split('\t')[column_function].strip()
- address = get_address_from_string(line.split('\t')[column_addr])
- cycles = int(line.split('\t')[column_cycles])
- callee = add_cycles_to_function(functions, func_name, address, cycles)
- if (prev_callee != None) and (prev_callee != callee):
- functions[prev_callee[0]][prev_callee[1]]['count'] += 1
- prev_callee = callee
- except ValueError:
- pass
- line = trace_read()
- if ((i % 1000000) == 0) and (i != 0):
- percent = (trace_process * 100.00) / trace_size
- print "Processing file ... (%.2f %%)" % (percent)
- i = i + 1
-
-# Fixup the last callee
-functions[prev_callee[0]][prev_callee[1]]['count'] += 1
-
-#
-# Process results
-#
-functions_cycles = {}
-all_functions_cycles = {}
-total_cycles = 0
-
-for func_key, module in functions.iteritems():
- for module_key, module_value in module.iteritems():
- key = "%s/%s" % (module_key, func_key)
- functions_cycles[key] = (module_value['cycles'], module_value['count'])
- total_cycles += module_value['cycles']
-
- if func_key not in all_functions_cycles.keys():
- all_functions_cycles[func_key] = (module_value['cycles'], module_value['count'])
- else:
- all_functions_cycles[func_key] = tuple(map(sum, zip(all_functions_cycles[func_key], (module_value['cycles'], module_value['count']))))
-
-sorted_functions_cycles = sorted(functions_cycles.iteritems(), key=operator.itemgetter(1), reverse = True)
-sorted_all_functions_cycles = sorted(all_functions_cycles.items(), key=operator.itemgetter(1), reverse = True)
-
-print
-print "----"
-for (key,value) in sorted_functions_cycles[:20]:
- if value[0] != 0:
- print "%s (cycles: %d - %d%%, count: %d)" % (key, value[0], (value[0] * 100) / total_cycles, value[1])
- else:
- break;
-print "----"
-for (key,value) in sorted_all_functions_cycles[:20]:
- if value[0] != 0:
- print "%s (cycles: %d - %d%%, count: %d)" % (key, value[0], (value[0] * 100) / total_cycles, value[1])
- else:
- break;
+#!/usr/bin/python\r
+\r
+#\r
+# Copyright (c) 2014, ARM Limited. All rights reserved.\r
+#\r
+# SPDX-License-Identifier: BSD-2-Clause-Patent\r
+#\r
+\r
+import getopt\r
+import operator\r
+import os\r
+import pickle\r
+import sys\r
+from sys import argv\r
+from cStringIO import StringIO\r
+\r
+modules = {}\r
+functions = {}\r
+functions_addr = {}\r
+\r
+def usage():\r
+ print "-t,--trace: Location of the Trace file"\r
+ print "-s,--symbols: Location of the symbols and modules"\r
+\r
+def get_address_from_string(address):\r
+ return int(address.strip("S:").strip("N:").strip("EL2:").strip("EL1:"), 16)\r
+\r
+def get_module_from_addr(modules, addr):\r
+ for key,value in modules.items():\r
+ if (value['start'] <= addr) and (addr <= value['end']):\r
+ return key\r
+ return None\r
+\r
+def add_cycles_to_function(functions, func_name, addr, cycles):\r
+ if func_name != "<Unknown>":\r
+ # Check if we are still in the previous function\r
+ if add_cycles_to_function.prev_func_name == func_name:\r
+ add_cycles_to_function.prev_entry['cycles'] += cycles\r
+ return (add_cycles_to_function.prev_func_name, add_cycles_to_function.prev_module_name)\r
+\r
+ if func_name in functions.keys():\r
+ for module_name, module_value in functions[func_name].iteritems():\r
+ if (module_value['start'] <= addr) and (addr < module_value['end']):\r
+ module_value['cycles'] += cycles\r
+\r
+ add_cycles_to_function.prev_func_name = func_name\r
+ add_cycles_to_function.prev_module_name = module_name\r
+ add_cycles_to_function.prev_entry = module_value\r
+ return (func_name, module_name)\r
+ elif (module_value['end'] == 0):\r
+ module_value['cycles'] += cycles\r
+\r
+ add_cycles_to_function.prev_func_name = func_name\r
+ add_cycles_to_function.prev_module_name = module_name\r
+ add_cycles_to_function.prev_entry = module_value\r
+ return (func_name, module_name)\r
+\r
+ # Workaround to fix the 'info func' limitation that does not expose the 'static' function\r
+ module_name = get_module_from_addr(modules, addr)\r
+ functions[func_name] = {}\r
+ functions[func_name][module_name] = {}\r
+ functions[func_name][module_name]['start'] = 0\r
+ functions[func_name][module_name]['end'] = 0\r
+ functions[func_name][module_name]['cycles'] = cycles\r
+ functions[func_name][module_name]['count'] = 0\r
+\r
+ add_cycles_to_function.prev_func_name = func_name\r
+ add_cycles_to_function.prev_module_name = module_name\r
+ add_cycles_to_function.prev_entry = functions[func_name][module_name]\r
+ return (func_name, module_name)\r
+ else:\r
+ # Check if we are still in the previous function\r
+ if (add_cycles_to_function.prev_entry is not None) and (add_cycles_to_function.prev_entry['start'] <= addr) and (addr < add_cycles_to_function.prev_entry['end']):\r
+ add_cycles_to_function.prev_entry['cycles'] += cycles\r
+ return (add_cycles_to_function.prev_func_name, add_cycles_to_function.prev_module_name)\r
+\r
+ # Generate the key for the given address\r
+ key = addr & ~0x0FFF\r
+\r
+ if key not in functions_addr.keys():\r
+ if 'Unknown' not in functions.keys():\r
+ functions['Unknown'] = {}\r
+ if 'Unknown' not in functions['Unknown'].keys():\r
+ functions['Unknown']['Unknown'] = {}\r
+ functions['Unknown']['Unknown']['cycles'] = 0\r
+ functions['Unknown']['Unknown']['count'] = 0\r
+ functions['Unknown']['Unknown']['cycles'] += cycles\r
+\r
+ add_cycles_to_function.prev_func_name = None\r
+ return None\r
+\r
+ for func_key, module in functions_addr[key].iteritems():\r
+ for module_key, module_value in module.iteritems():\r
+ if (module_value['start'] <= addr) and (addr < module_value['end']):\r
+ module_value['cycles'] += cycles\r
+\r
+ # In case o <Unknown> we prefer to fallback on the direct search\r
+ add_cycles_to_function.prev_func_name = func_key\r
+ add_cycles_to_function.prev_module_name = module_key\r
+ add_cycles_to_function.prev_entry = module_value\r
+ return (func_key, module_key)\r
+\r
+ print "Warning: Function %s @ 0x%x not found" % (func_name, addr)\r
+\r
+ add_cycles_to_function.prev_func_name = None\r
+ return None\r
+\r
+# Static variables for the previous function\r
+add_cycles_to_function.prev_func_name = None\r
+add_cycles_to_function.prev_entry = None\r
+\r
+def trace_read():\r
+ global trace_process\r
+ line = trace.readline()\r
+ trace_process += len(line)\r
+ return line\r
+\r
+#\r
+# Parse arguments\r
+#\r
+trace_name = None\r
+symbols_file = None\r
+\r
+opts,args = getopt.getopt(sys.argv[1:], "ht:vs:v", ["help","trace=","symbols="])\r
+if (opts is None) or (not opts):\r
+ usage()\r
+ sys.exit()\r
+\r
+for o,a in opts:\r
+ if o in ("-h","--help"):\r
+ usage()\r
+ sys.exit()\r
+ elif o in ("-t","--trace"):\r
+ trace_name = a\r
+ elif o in ("-s","--symbols"):\r
+ symbols_file = a\r
+ else:\r
+ assert False, "Unhandled option (%s)" % o\r
+\r
+#\r
+# We try first to see if we run the script from DS-5\r
+#\r
+try:\r
+ from arm_ds.debugger_v1 import Debugger\r
+ from arm_ds.debugger_v1 import DebugException\r
+\r
+ # Debugger object for accessing the debugger\r
+ debugger = Debugger()\r
+\r
+ # Initialisation commands\r
+ ec = debugger.getExecutionContext(0)\r
+ ec.getExecutionService().stop()\r
+ ec.getExecutionService().waitForStop()\r
+ # in case the execution context reference is out of date\r
+ ec = debugger.getExecutionContext(0)\r
+\r
+ #\r
+ # Get the module name and their memory range\r
+ #\r
+ info_file = ec.executeDSCommand("info file")\r
+ info_file_str = StringIO(info_file)\r
+\r
+ line = info_file_str.readline().strip('\n')\r
+ while line != '':\r
+ if ("Symbols from" in line):\r
+ # Get the module name from the line 'Symbols from "/home/...."'\r
+ module_name = line.split("\"")[1].split("/")[-1]\r
+ modules[module_name] = {}\r
+\r
+ # Look for the text section\r
+ line = info_file_str.readline().strip('\n')\r
+ while (line != '') and ("Symbols from" not in line):\r
+ if ("ER_RO" in line):\r
+ modules[module_name]['start'] = get_address_from_string(line.split()[0])\r
+ modules[module_name]['end'] = get_address_from_string(line.split()[2])\r
+ line = info_file_str.readline().strip('\n')\r
+ break;\r
+ if (".text" in line):\r
+ modules[module_name]['start'] = get_address_from_string(line.split()[0])\r
+ modules[module_name]['end'] = get_address_from_string(line.split()[2])\r
+ line = info_file_str.readline().strip('\n')\r
+ break;\r
+ line = info_file_str.readline().strip('\n')\r
+ line = info_file_str.readline().strip('\n')\r
+\r
+ #\r
+ # Get the function name and their memory range\r
+ #\r
+ info_func = ec.executeDSCommand("info func")\r
+ info_func_str = StringIO(info_func)\r
+\r
+ # Skip the first line 'Low-level symbols ...'\r
+ line = info_func_str.readline().strip('\n')\r
+ func_prev = None\r
+ while line != '':\r
+ # We ignore all the functions after 'Functions in'\r
+ if ("Functions in " in line):\r
+ line = info_func_str.readline().strip('\n')\r
+ while line != '':\r
+ line = info_func_str.readline().strip('\n')\r
+ line = info_func_str.readline().strip('\n')\r
+ continue\r
+\r
+ if ("Low-level symbols" in line):\r
+ # We need to fixup the last function of the module\r
+ if func_prev is not None:\r
+ func_prev['end'] = modules[module_name]['end']\r
+ func_prev = None\r
+\r
+ line = info_func_str.readline().strip('\n')\r
+ continue\r
+\r
+ func_name = line.split()[1]\r
+ func_start = get_address_from_string(line.split()[0])\r
+ module_name = get_module_from_addr(modules, func_start)\r
+\r
+ if func_name not in functions.keys():\r
+ functions[func_name] = {}\r
+ functions[func_name][module_name] = {}\r
+ functions[func_name][module_name]['start'] = func_start\r
+ functions[func_name][module_name]['cycles'] = 0\r
+ functions[func_name][module_name]['count'] = 0\r
+\r
+ # Set the end address of the previous function\r
+ if func_prev is not None:\r
+ func_prev['end'] = func_start\r
+ func_prev = functions[func_name][module_name]\r
+\r
+ line = info_func_str.readline().strip('\n')\r
+\r
+ # Fixup the last function\r
+ func_prev['end'] = modules[module_name]['end']\r
+\r
+ if symbols_file is not None:\r
+ pickle.dump((modules, functions), open(symbols_file, "w"))\r
+except:\r
+ if symbols_file is None:\r
+ print "Error: Symbols file is required when run out of ARM DS-5"\r
+ sys.exit()\r
+\r
+ (modules, functions) = pickle.load(open(symbols_file, "r"))\r
+\r
+#\r
+# Build optimized table for the <Unknown> functions\r
+#\r
+functions_addr = {}\r
+for func_key, module in functions.iteritems():\r
+ for module_key, module_value in module.iteritems():\r
+ key = module_value['start'] & ~0x0FFF\r
+ if key not in functions_addr.keys():\r
+ functions_addr[key] = {}\r
+ if func_key not in functions_addr[key].keys():\r
+ functions_addr[key][func_key] = {}\r
+ functions_addr[key][func_key][module_key] = module_value\r
+\r
+#\r
+# Process the trace file\r
+#\r
+if trace_name is None:\r
+ sys.exit()\r
+\r
+trace = open(trace_name, "r")\r
+trace_size = os.path.getsize(trace_name)\r
+trace_process = 0\r
+\r
+# Get the column names from the first line\r
+columns = trace_read().split()\r
+column_addr = columns.index('Address')\r
+column_cycles = columns.index('Cycles')\r
+column_function = columns.index('Function')\r
+\r
+line = trace_read()\r
+i = 0\r
+prev_callee = None\r
+while line:\r
+ try:\r
+ func_name = line.split('\t')[column_function].strip()\r
+ address = get_address_from_string(line.split('\t')[column_addr])\r
+ cycles = int(line.split('\t')[column_cycles])\r
+ callee = add_cycles_to_function(functions, func_name, address, cycles)\r
+ if (prev_callee != None) and (prev_callee != callee):\r
+ functions[prev_callee[0]][prev_callee[1]]['count'] += 1\r
+ prev_callee = callee\r
+ except ValueError:\r
+ pass\r
+ line = trace_read()\r
+ if ((i % 1000000) == 0) and (i != 0):\r
+ percent = (trace_process * 100.00) / trace_size\r
+ print "Processing file ... (%.2f %%)" % (percent)\r
+ i = i + 1\r
+\r
+# Fixup the last callee\r
+functions[prev_callee[0]][prev_callee[1]]['count'] += 1\r
+\r
+#\r
+# Process results\r
+#\r
+functions_cycles = {}\r
+all_functions_cycles = {}\r
+total_cycles = 0\r
+\r
+for func_key, module in functions.iteritems():\r
+ for module_key, module_value in module.iteritems():\r
+ key = "%s/%s" % (module_key, func_key)\r
+ functions_cycles[key] = (module_value['cycles'], module_value['count'])\r
+ total_cycles += module_value['cycles']\r
+\r
+ if func_key not in all_functions_cycles.keys():\r
+ all_functions_cycles[func_key] = (module_value['cycles'], module_value['count'])\r
+ else:\r
+ all_functions_cycles[func_key] = tuple(map(sum, zip(all_functions_cycles[func_key], (module_value['cycles'], module_value['count']))))\r
+\r
+sorted_functions_cycles = sorted(functions_cycles.iteritems(), key=operator.itemgetter(1), reverse = True)\r
+sorted_all_functions_cycles = sorted(all_functions_cycles.items(), key=operator.itemgetter(1), reverse = True)\r
+\r
+print\r
+print "----"\r
+for (key,value) in sorted_functions_cycles[:20]:\r
+ if value[0] != 0:\r
+ print "%s (cycles: %d - %d%%, count: %d)" % (key, value[0], (value[0] * 100) / total_cycles, value[1])\r
+ else:\r
+ break;\r
+print "----"\r
+for (key,value) in sorted_all_functions_cycles[:20]:\r
+ if value[0] != 0:\r
+ print "%s (cycles: %d - %d%%, count: %d)" % (key, value[0], (value[0] * 100) / total_cycles, value[1])\r
+ else:\r
+ break;\r
projects / mirror_edk2.git / blobdiff