| #!/usr/bin/python3 |
| # |
| # Copyright 2019, The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| """ |
| Usage: mkflame.py <jvmti_trace_file> |
| """ |
| |
| import argparse |
| import sys |
| |
| class TraceCollection: |
| def __init__(self, args): |
| self.args = args |
| # A table indexed by number and containing the definition for that number. |
| self.definitions = {} |
| # The "weight" of a stack trace, either 1 for counting or the size of the allocation. |
| self.weights = {} |
| # The count for each individual allocation. |
| self.allocation_count = {} |
| |
| def definition(self, index): |
| """ |
| Returns the definition for "index". |
| """ |
| return self.definitions[index] |
| |
| def set_definition(self, index, definition): |
| """ |
| Sets the definition for "index". |
| """ |
| self.definitions[index] = definition |
| |
| def weight(self, index): |
| """ |
| Returns the weight for "index". |
| """ |
| return self.weights[index] |
| |
| def set_weight(self, index, weight): |
| """ |
| Sets the weight for "index". |
| """ |
| self.weights[index] = weight |
| |
| def read_file(self, filename): |
| """ |
| Reads a file into a DefinitionTable. |
| """ |
| def process_definition(line): |
| """ |
| Adds line to the list of definitions in table. |
| """ |
| def expand_stack_trace(definition): |
| """ |
| Converts a semicolon-separated list of numbers into the text stack trace. |
| """ |
| def get_allocation_thread(thread_type_size): |
| """ |
| Returns the thread of an allocation from the thread/type/size record. |
| """ |
| THREAD_STRING = "thread[" |
| THREAD_STRING_LEN = len(THREAD_STRING) |
| thread_string = thread_type_size[thread_type_size.find(THREAD_STRING) + |
| THREAD_STRING_LEN:] |
| return thread_string[:thread_string.find("]")] |
| |
| def get_allocation_type(thread_type_size): |
| """ |
| Returns the type of an allocation from the thread/type/size record. |
| """ |
| TYPE_STRING = "jclass[" |
| TYPE_STRING_LEN = len(TYPE_STRING) |
| type_string = thread_type_size[thread_type_size.find(TYPE_STRING) + TYPE_STRING_LEN:] |
| return type_string[:type_string.find(" ")] |
| |
| def get_allocation_size(thread_type_size): |
| """ |
| Returns the size of an allocation from the thread/type/size record. |
| """ |
| SIZE_STRING = "size[" |
| SIZE_STRING_LEN = len(SIZE_STRING) |
| size_string = thread_type_size[thread_type_size.find(SIZE_STRING) + SIZE_STRING_LEN:] |
| size_string = size_string[:size_string.find(",")] |
| return int(size_string) |
| |
| def get_top_and_weight(index): |
| thread_type_size = self.definition(int(tokens[0])) |
| size = get_allocation_size(thread_type_size) |
| if self.args.type_only: |
| thread_type_size = get_allocation_type(thread_type_size) |
| elif self.args.thread_only: |
| thread_type_size = get_allocation_thread(thread_type_size) |
| return (thread_type_size, size) |
| |
| tokens = definition.split(";") |
| # The first element (base) of the stack trace is the thread/type/size. |
| # Get the weight (either 1 or the number of bytes allocated). |
| (thread_type_size, weight) = get_top_and_weight(int(tokens[0])) |
| self.set_weight(index, weight) |
| # Remove the thread/type/size from the base of the stack trace. |
| del tokens[0] |
| # Build the stack trace list. |
| expanded_definition = "" |
| for i in range(len(tokens)): |
| if self.args.depth_limit > 0 and i >= self.args.depth_limit: |
| break |
| token = tokens[i] |
| # Replace semicolons by colons in the method entry signatures. |
| method = self.definition(int(token)).replace(";", ":") |
| if len(expanded_definition) > 0: |
| expanded_definition += ";" |
| expanded_definition += method |
| if not self.args.ignore_type: |
| # Add the thread/type/size as the top-most stack frame. |
| if len(expanded_definition) > 0: |
| expanded_definition += ";" |
| expanded_definition += thread_type_size.replace(";", ":") |
| if self.args.reverse_stack: |
| def_list = expanded_definition.split(";") |
| expanded_definition = ";".join(def_list[::-1]) |
| return expanded_definition |
| |
| # If the line contains a comma, it is of the form [+=]index,definition, |
| # where index is a string containing an integer, and definition is the |
| # value represented by the integer whenever it is used later. |
| # * Lines starting with + are either a thread/type/size record or a single |
| # stack frame. These are simply interned in the table. |
| # * Those starting with = are stack traces, and contain a sequence of |
| # numbers separated by semicolon. These are "expanded" and then interned. |
| comma_pos = line.find(",") |
| index = int(line[1:comma_pos]) |
| definition = line[comma_pos+1:] |
| if line[0:1] == "=": |
| definition = expand_stack_trace(definition) |
| # Intern the definition in the table. |
| #if len(definition) == 0: |
| # Zero length samples are errors and are discarded. |
| #print("ERROR: definition for " + str(index) + " is empty") |
| #return |
| self.set_definition(index, definition) |
| |
| def process_trace(index): |
| """ |
| Remembers one stack trace in the list of stack traces we have seen. |
| Remembering a stack trace increments a count associated with the trace. |
| """ |
| trace = self.definition(index) |
| if self.args.use_size: |
| weight = self.weight(index) |
| else: |
| weight = 1 |
| if trace in self.allocation_count: |
| self.allocation_count[trace] = self.allocation_count[trace] + weight |
| else: |
| self.allocation_count[trace] = weight |
| |
| # Read the file, processing each line as a definition or stack trace. |
| tracefile = open(filename, "r") |
| current_allocation_trace = "" |
| for line in tracefile: |
| line = line.rstrip("\n") |
| if line[0:1] == "=" or line[0:1] == "+": |
| # definition. |
| process_definition(line) |
| else: |
| # stack trace. |
| process_trace(int(line)) |
| |
| def dump_flame_graph(self): |
| """ |
| Prints out a stack trace format compatible with flame graph creation utilities. |
| """ |
| for definition, weight in self.allocation_count.items(): |
| print(definition + " " + str(weight)) |
| |
| def parse_options(): |
| parser = argparse.ArgumentParser(description="Convert a trace to a form usable for flame graphs.") |
| parser.add_argument("filename", help="The trace file as input", type=str) |
| parser.add_argument("--use_size", help="Count by allocation size", action="store_true", |
| default=False) |
| parser.add_argument("--ignore_type", help="Ignore type of allocation", action="store_true", |
| default=False) |
| parser.add_argument("--reverse_stack", help="Reverse root and top of stacks", action="store_true", |
| default=False) |
| parser.add_argument("--type_only", help="Only consider allocation type", action="store_true", |
| default=False) |
| parser.add_argument("--thread_only", help="Only consider allocation thread", action="store_true", |
| default=False) |
| parser.add_argument("--depth_limit", help="Limit the length of a trace", type=int, default=0) |
| args = parser.parse_args() |
| return args |
| |
| def main(argv): |
| args = parse_options() |
| trace_collection = TraceCollection(args) |
| trace_collection.read_file(args.filename) |
| trace_collection.dump_flame_graph() |
| |
| if __name__ == '__main__': |
| sys.exit(main(sys.argv)) |
