1 #!/usr/bin/python 2 3 # 4 # Copyright (c) 2014, ARM Limited. All rights reserved. 5 # 6 # This program and the accompanying materials 7 # are licensed and made available under the terms and conditions of the BSD License 8 # which accompanies this distribution. The full text of the license may be found at 9 # http://opensource.org/licenses/bsd-license.php 10 # 11 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 12 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 13 # 14 15 import getopt 16 import operator 17 import os 18 import pickle 19 import sys 20 from sys import argv 21 from cStringIO import StringIO 22 23 modules = {} 24 functions = {} 25 functions_addr = {} 26 27 def usage(): 28 print "-t,--trace: Location of the Trace file" 29 print "-s,--symbols: Location of the symbols and modules" 30 31 def get_address_from_string(address): 32 return int(address.strip("S:").strip("N:").strip("EL2:").strip("EL1:"), 16) 33 34 def get_module_from_addr(modules, addr): 35 for key,value in modules.items(): 36 if (value['start'] <= addr) and (addr <= value['end']): 37 return key 38 return None 39 40 def add_cycles_to_function(functions, func_name, addr, cycles): 41 if func_name != "<Unknown>": 42 # Check if we are still in the previous function 43 if add_cycles_to_function.prev_func_name == func_name: 44 add_cycles_to_function.prev_entry['cycles'] += cycles 45 return (add_cycles_to_function.prev_func_name, add_cycles_to_function.prev_module_name) 46 47 if func_name in functions.keys(): 48 for module_name, module_value in functions[func_name].iteritems(): 49 if (module_value['start'] <= addr) and (addr < module_value['end']): 50 module_value['cycles'] += cycles 51 52 add_cycles_to_function.prev_func_name = func_name 53 add_cycles_to_function.prev_module_name = module_name 54 add_cycles_to_function.prev_entry = module_value 55 return (func_name, module_name) 56 elif (module_value['end'] == 0): 57 module_value['cycles'] += cycles 58 59 add_cycles_to_function.prev_func_name = func_name 60 add_cycles_to_function.prev_module_name = module_name 61 add_cycles_to_function.prev_entry = module_value 62 return (func_name, module_name) 63 64 # Workaround to fix the 'info func' limitation that does not expose the 'static' function 65 module_name = get_module_from_addr(modules, addr) 66 functions[func_name] = {} 67 functions[func_name][module_name] = {} 68 functions[func_name][module_name]['start'] = 0 69 functions[func_name][module_name]['end'] = 0 70 functions[func_name][module_name]['cycles'] = cycles 71 functions[func_name][module_name]['count'] = 0 72 73 add_cycles_to_function.prev_func_name = func_name 74 add_cycles_to_function.prev_module_name = module_name 75 add_cycles_to_function.prev_entry = functions[func_name][module_name] 76 return (func_name, module_name) 77 else: 78 # Check if we are still in the previous function 79 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']): 80 add_cycles_to_function.prev_entry['cycles'] += cycles 81 return (add_cycles_to_function.prev_func_name, add_cycles_to_function.prev_module_name) 82 83 # Generate the key for the given address 84 key = addr & ~0x0FFF 85 86 if key not in functions_addr.keys(): 87 if 'Unknown' not in functions.keys(): 88 functions['Unknown'] = {} 89 if 'Unknown' not in functions['Unknown'].keys(): 90 functions['Unknown']['Unknown'] = {} 91 functions['Unknown']['Unknown']['cycles'] = 0 92 functions['Unknown']['Unknown']['count'] = 0 93 functions['Unknown']['Unknown']['cycles'] += cycles 94 95 add_cycles_to_function.prev_func_name = None 96 return None 97 98 for func_key, module in functions_addr[key].iteritems(): 99 for module_key, module_value in module.iteritems(): 100 if (module_value['start'] <= addr) and (addr < module_value['end']): 101 module_value['cycles'] += cycles 102 103 # In case o <Unknown> we prefer to fallback on the direct search 104 add_cycles_to_function.prev_func_name = func_key 105 add_cycles_to_function.prev_module_name = module_key 106 add_cycles_to_function.prev_entry = module_value 107 return (func_key, module_key) 108 109 print "Warning: Function %s @ 0x%x not found" % (func_name, addr) 110 111 add_cycles_to_function.prev_func_name = None 112 return None 113 114 # Static variables for the previous function 115 add_cycles_to_function.prev_func_name = None 116 add_cycles_to_function.prev_entry = None 117 118 def trace_read(): 119 global trace_process 120 line = trace.readline() 121 trace_process += len(line) 122 return line 123 124 # 125 # Parse arguments 126 # 127 trace_name = None 128 symbols_file = None 129 130 opts,args = getopt.getopt(sys.argv[1:], "ht:vs:v", ["help","trace=","symbols="]) 131 if (opts is None) or (not opts): 132 usage() 133 sys.exit() 134 135 for o,a in opts: 136 if o in ("-h","--help"): 137 usage() 138 sys.exit() 139 elif o in ("-t","--trace"): 140 trace_name = a 141 elif o in ("-s","--symbols"): 142 symbols_file = a 143 else: 144 assert False, "Unhandled option (%s)" % o 145 146 # 147 # We try first to see if we run the script from DS-5 148 # 149 try: 150 from arm_ds.debugger_v1 import Debugger 151 from arm_ds.debugger_v1 import DebugException 152 153 # Debugger object for accessing the debugger 154 debugger = Debugger() 155 156 # Initialisation commands 157 ec = debugger.getExecutionContext(0) 158 ec.getExecutionService().stop() 159 ec.getExecutionService().waitForStop() 160 # in case the execution context reference is out of date 161 ec = debugger.getExecutionContext(0) 162 163 # 164 # Get the module name and their memory range 165 # 166 info_file = ec.executeDSCommand("info file") 167 info_file_str = StringIO(info_file) 168 169 line = info_file_str.readline().strip('\n') 170 while line != '': 171 if ("Symbols from" in line): 172 # Get the module name from the line 'Symbols from "/home/...."' 173 module_name = line.split("\"")[1].split("/")[-1] 174 modules[module_name] = {} 175 176 # Look for the text section 177 line = info_file_str.readline().strip('\n') 178 while (line != '') and ("Symbols from" not in line): 179 if ("ER_RO" in line): 180 modules[module_name]['start'] = get_address_from_string(line.split()[0]) 181 modules[module_name]['end'] = get_address_from_string(line.split()[2]) 182 line = info_file_str.readline().strip('\n') 183 break; 184 if (".text" in line): 185 modules[module_name]['start'] = get_address_from_string(line.split()[0]) 186 modules[module_name]['end'] = get_address_from_string(line.split()[2]) 187 line = info_file_str.readline().strip('\n') 188 break; 189 line = info_file_str.readline().strip('\n') 190 line = info_file_str.readline().strip('\n') 191 192 # 193 # Get the function name and their memory range 194 # 195 info_func = ec.executeDSCommand("info func") 196 info_func_str = StringIO(info_func) 197 198 # Skip the first line 'Low-level symbols ...' 199 line = info_func_str.readline().strip('\n') 200 func_prev = None 201 while line != '': 202 # We ignore all the functions after 'Functions in' 203 if ("Functions in " in line): 204 line = info_func_str.readline().strip('\n') 205 while line != '': 206 line = info_func_str.readline().strip('\n') 207 line = info_func_str.readline().strip('\n') 208 continue 209 210 if ("Low-level symbols" in line): 211 # We need to fixup the last function of the module 212 if func_prev is not None: 213 func_prev['end'] = modules[module_name]['end'] 214 func_prev = None 215 216 line = info_func_str.readline().strip('\n') 217 continue 218 219 func_name = line.split()[1] 220 func_start = get_address_from_string(line.split()[0]) 221 module_name = get_module_from_addr(modules, func_start) 222 223 if func_name not in functions.keys(): 224 functions[func_name] = {} 225 functions[func_name][module_name] = {} 226 functions[func_name][module_name]['start'] = func_start 227 functions[func_name][module_name]['cycles'] = 0 228 functions[func_name][module_name]['count'] = 0 229 230 # Set the end address of the previous function 231 if func_prev is not None: 232 func_prev['end'] = func_start 233 func_prev = functions[func_name][module_name] 234 235 line = info_func_str.readline().strip('\n') 236 237 # Fixup the last function 238 func_prev['end'] = modules[module_name]['end'] 239 240 if symbols_file is not None: 241 pickle.dump((modules, functions), open(symbols_file, "w")) 242 except: 243 if symbols_file is None: 244 print "Error: Symbols file is required when run out of ARM DS-5" 245 sys.exit() 246 247 (modules, functions) = pickle.load(open(symbols_file, "r")) 248 249 # 250 # Build optimized table for the <Unknown> functions 251 # 252 functions_addr = {} 253 for func_key, module in functions.iteritems(): 254 for module_key, module_value in module.iteritems(): 255 key = module_value['start'] & ~0x0FFF 256 if key not in functions_addr.keys(): 257 functions_addr[key] = {} 258 if func_key not in functions_addr[key].keys(): 259 functions_addr[key][func_key] = {} 260 functions_addr[key][func_key][module_key] = module_value 261 262 # 263 # Process the trace file 264 # 265 if trace_name is None: 266 sys.exit() 267 268 trace = open(trace_name, "r") 269 trace_size = os.path.getsize(trace_name) 270 trace_process = 0 271 272 # Get the column names from the first line 273 columns = trace_read().split() 274 column_addr = columns.index('Address') 275 column_cycles = columns.index('Cycles') 276 column_function = columns.index('Function') 277 278 line = trace_read() 279 i = 0 280 prev_callee = None 281 while line: 282 try: 283 func_name = line.split('\t')[column_function].strip() 284 address = get_address_from_string(line.split('\t')[column_addr]) 285 cycles = int(line.split('\t')[column_cycles]) 286 callee = add_cycles_to_function(functions, func_name, address, cycles) 287 if (prev_callee != None) and (prev_callee != callee): 288 functions[prev_callee[0]][prev_callee[1]]['count'] += 1 289 prev_callee = callee 290 except ValueError: 291 pass 292 line = trace_read() 293 if ((i % 1000000) == 0) and (i != 0): 294 percent = (trace_process * 100.00) / trace_size 295 print "Processing file ... (%.2f %%)" % (percent) 296 i = i + 1 297 298 # Fixup the last callee 299 functions[prev_callee[0]][prev_callee[1]]['count'] += 1 300 301 # 302 # Process results 303 # 304 functions_cycles = {} 305 all_functions_cycles = {} 306 total_cycles = 0 307 308 for func_key, module in functions.iteritems(): 309 for module_key, module_value in module.iteritems(): 310 key = "%s/%s" % (module_key, func_key) 311 functions_cycles[key] = (module_value['cycles'], module_value['count']) 312 total_cycles += module_value['cycles'] 313 314 if func_key not in all_functions_cycles.keys(): 315 all_functions_cycles[func_key] = (module_value['cycles'], module_value['count']) 316 else: 317 all_functions_cycles[func_key] = tuple(map(sum, zip(all_functions_cycles[func_key], (module_value['cycles'], module_value['count'])))) 318 319 sorted_functions_cycles = sorted(functions_cycles.iteritems(), key=operator.itemgetter(1), reverse = True) 320 sorted_all_functions_cycles = sorted(all_functions_cycles.items(), key=operator.itemgetter(1), reverse = True) 321 322 print 323 print "----" 324 for (key,value) in sorted_functions_cycles[:20]: 325 if value[0] != 0: 326 print "%s (cycles: %d - %d%%, count: %d)" % (key, value[0], (value[0] * 100) / total_cycles, value[1]) 327 else: 328 break; 329 print "----" 330 for (key,value) in sorted_all_functions_cycles[:20]: 331 if value[0] != 0: 332 print "%s (cycles: %d - %d%%, count: %d)" % (key, value[0], (value[0] * 100) / total_cycles, value[1]) 333 else: 334 break; 335
