ArmPlatformPkg: convert LFs to CRLF, expand hard TABs

[mirror_edk2.git] / ArmPlatformPkg / Scripts / Ds5 / profile.py

#!/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