| #!/usr/bin/env ruby |
| |
| # Copyright (C) 2012-2014, 2016 Apple Inc. All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # 1. Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # 2. Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # |
| # THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' |
| # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS |
| # BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
| # THE POSSIBILITY OF SUCH DAMAGE. |
| |
| require 'rubygems' |
| |
| require 'readline' |
| |
| begin |
| require 'json' |
| require 'highline' |
| rescue LoadError |
| $stderr.puts "Error: some required gems are not installed!" |
| $stderr.puts |
| $stderr.puts "Try running:" |
| $stderr.puts |
| $stderr.puts "sudo gem install json" |
| $stderr.puts "sudo gem install highline" |
| exit 1 |
| end |
| |
| class Bytecode |
| attr_accessor :bytecodes, :bytecodeIndex, :opcode, :description, :topCounts, :bottomCounts, :machineInlinees, :osrExits |
| |
| def initialize(bytecodes, bytecodeIndex, opcode, description) |
| @bytecodes = bytecodes |
| @bytecodeIndex = bytecodeIndex |
| @opcode = opcode |
| @description = description |
| @topCounts = [] # "source" counts |
| @bottomCounts = {} # "machine" counts, maps compilations to counts |
| @machineInlinees = {} # maps my compilation to a set of inlinees |
| @osrExits = [] |
| end |
| |
| def shouldHaveCounts? |
| @opcode != "op_call_put_result" |
| end |
| |
| def addTopCount(count) |
| @topCounts << count |
| end |
| |
| def addBottomCountForCompilation(count, compilation) |
| @bottomCounts[compilation] = [] unless @bottomCounts[compilation] |
| @bottomCounts[compilation] << count |
| end |
| |
| def addMachineInlinee(compilation, inlinee) |
| @machineInlinees[compilation] = {} unless @machineInlinees[compilation] |
| @machineInlinees[compilation][inlinee] = true |
| end |
| |
| def totalTopExecutionCount |
| sum = 0 |
| @topCounts.each { |
| | value | |
| sum += value.count |
| } |
| sum |
| end |
| |
| def topExecutionCount(engine) |
| sum = 0 |
| @topCounts.each { |
| | value | |
| if value.engine == engine |
| sum += value.count |
| end |
| } |
| sum |
| end |
| |
| def totalBottomExecutionCount |
| sum = 0 |
| @bottomCounts.each_value { |
| | counts | |
| max = 0 |
| counts.each { |
| | value | |
| max = [max, value.count].max |
| } |
| sum += max |
| } |
| sum |
| end |
| |
| def bottomExecutionCount(engine) |
| sum = 0 |
| @bottomCounts.each_pair { |
| | compilation, counts | |
| if compilation.engine == engine |
| max = 0 |
| counts.each { |
| | value | |
| max = [max, value.count].max |
| } |
| sum += max |
| end |
| } |
| sum |
| end |
| |
| def totalExitCount |
| sum = 0 |
| @osrExits.each { |
| | exit | |
| sum += exit.count |
| } |
| sum |
| end |
| end |
| |
| class Bytecodes |
| attr_accessor :codeHash, :inferredName, :source, :instructionCount, :machineInlineSites, :compilations |
| |
| def initialize(json) |
| @codeHash = json["hash"].to_s |
| @inferredName = json["inferredName"].to_s |
| @source = json["sourceCode"].to_s |
| @instructionCount = json["instructionCount"].to_i |
| @bytecode = {} |
| json["bytecode"].each { |
| | subJson | |
| index = subJson["bytecodeIndex"].to_i |
| @bytecode[index] = Bytecode.new(self, index, subJson["opcode"].to_s, subJson["description"].to_s) |
| } |
| @machineInlineSites = {} # maps compilation to a set of origins |
| @compilations = [] |
| end |
| |
| def name(limit) |
| if to_s.size > limit |
| "\##{@codeHash}" |
| else |
| to_s |
| end |
| end |
| |
| def to_s |
| "#{@inferredName}\##{@codeHash}" |
| end |
| |
| def matches(pattern) |
| if pattern =~ /^#/ |
| $~.post_match == @codeHash |
| elsif pattern =~ /#/ |
| pattern == to_s |
| else |
| pattern == @inferredName or pattern == @codeHash |
| end |
| end |
| |
| def each |
| @bytecode.values.sort{|a, b| a.bytecodeIndex <=> b.bytecodeIndex}.each { |
| | value | |
| yield value |
| } |
| end |
| |
| def bytecode(bytecodeIndex) |
| @bytecode[bytecodeIndex] |
| end |
| |
| def addMachineInlineSite(compilation, origin) |
| @machineInlineSites[compilation] = {} unless @machineInlineSites[compilation] |
| @machineInlineSites[compilation][origin] = true |
| end |
| |
| def totalMachineInlineSites |
| sum = 0 |
| @machineInlineSites.each_value { |
| | set | |
| sum += set.size |
| } |
| sum |
| end |
| |
| def sourceMachineInlineSites |
| set = {} |
| @machineInlineSites.each_value { |
| | mySet | |
| set.merge!(mySet) |
| } |
| set.size |
| end |
| |
| def totalMaxTopExecutionCount |
| max = 0 |
| @bytecode.each_value { |
| | bytecode | |
| max = [max, bytecode.totalTopExecutionCount].max |
| } |
| max |
| end |
| |
| def maxTopExecutionCount(engine) |
| max = 0 |
| @bytecode.each_value { |
| | bytecode | |
| max = [max, bytecode.topExecutionCount(engine)].max |
| } |
| max |
| end |
| |
| def totalMaxBottomExecutionCount |
| max = 0 |
| @bytecode.each_value { |
| | bytecode | |
| max = [max, bytecode.totalBottomExecutionCount].max |
| } |
| max |
| end |
| |
| def maxBottomExecutionCount(engine) |
| max = 0 |
| @bytecode.each_value { |
| | bytecode | |
| max = [max, bytecode.bottomExecutionCount(engine)].max |
| } |
| max |
| end |
| |
| def totalExitCount |
| sum = 0 |
| each { |
| | bytecode | |
| sum += bytecode.totalExitCount |
| } |
| sum |
| end |
| |
| def codeHashSortKey |
| codeHash |
| end |
| end |
| |
| class ProfiledBytecode |
| attr_reader :bytecodeIndex, :description |
| |
| def initialize(json) |
| @bytecodeIndex = json["bytecodeIndex"].to_i |
| @description = json["description"].to_s |
| end |
| end |
| |
| class ProfiledBytecodes |
| attr_reader :header, :bytecodes |
| |
| def initialize(json) |
| @header = json["header"] |
| @bytecodes = $bytecodes[json["bytecodesID"].to_i] |
| @sequence = json["bytecode"].map { |
| | subJson | |
| ProfiledBytecode.new(subJson) |
| } |
| end |
| |
| def each |
| @sequence.each { |
| | description | |
| yield description |
| } |
| end |
| end |
| |
| def originStackFromJSON(json) |
| json.map { |
| | subJson | |
| $bytecodes[subJson["bytecodesID"].to_i].bytecode(subJson["bytecodeIndex"].to_i) |
| } |
| end |
| |
| class CompiledBytecode |
| attr_accessor :origin, :description |
| |
| def initialize(json) |
| @origin = originStackFromJSON(json["origin"]) |
| @description = json["description"].to_s |
| end |
| end |
| |
| class ExecutionCounter |
| attr_accessor :origin, :engine, :count |
| |
| def initialize(origin, engine, count) |
| @origin = origin |
| @engine = engine |
| @count = count |
| end |
| end |
| |
| class OSRExit |
| attr_reader :compilation, :origin, :codeAddresses, :exitKind, :isWatchpoint, :count |
| |
| def initialize(compilation, origin, codeAddresses, exitKind, isWatchpoint, count) |
| @compilation = compilation |
| @origin = origin |
| @codeAddresses = codeAddresses |
| @exitKind = exitKind |
| @isWatchpoint = isWatchpoint |
| @count = count |
| end |
| |
| def dumpForDisplay(prefix) |
| puts(prefix + "EXIT: due to #{@exitKind}, #{@count} times") |
| end |
| end |
| |
| class Compilation |
| attr_accessor :bytecode, :engine, :descriptions, :counters, :compilationIndex |
| attr_accessor :osrExits, :profiledBytecodes, :numInlinedGetByIds, :numInlinedPutByIds |
| attr_accessor :numInlinedCalls, :jettisonReason, :additionalJettisonReason, :uid |
| |
| def initialize(json) |
| @bytecode = $bytecodes[json["bytecodesID"].to_i] |
| @bytecode.compilations << self |
| @compilationIndex = @bytecode.compilations.size |
| @engine = json["compilationKind"] |
| @descriptions = json["descriptions"].map { |
| | subJson | |
| CompiledBytecode.new(subJson) |
| } |
| @descriptions.each { |
| | description | |
| next if description.origin.empty? |
| description.origin[1..-1].each_with_index { |
| | inlinee, index | |
| description.origin[0].addMachineInlinee(self, inlinee.bytecodes) |
| inlinee.bytecodes.addMachineInlineSite(self, description.origin[0...index]) |
| } |
| } |
| @counters = {} |
| json["counters"].each { |
| | subJson | |
| origin = originStackFromJSON(subJson["origin"]) |
| counter = ExecutionCounter.new(origin, @engine, subJson["executionCount"].to_i) |
| @counters[origin] = counter |
| origin[-1].addTopCount(counter) |
| origin[0].addBottomCountForCompilation(counter, self) |
| } |
| @osrExits = {} |
| json["osrExits"].each { |
| | subJson | |
| osrExit = OSRExit.new(self, originStackFromJSON(subJson["origin"]), |
| json["osrExitSites"][subJson["id"]].map { |
| | value | |
| value.hex |
| }, subJson["exitKind"], subJson["isWatchpoint"], |
| subJson["count"]) |
| osrExit.codeAddresses.each { |
| | codeAddress | |
| osrExits[codeAddress] = [] unless osrExits[codeAddress] |
| osrExits[codeAddress] << osrExit |
| } |
| osrExit.origin[-1].osrExits << osrExit |
| } |
| @profiledBytecodes = [] |
| json["profiledBytecodes"].each { |
| | subJson | |
| @profiledBytecodes << ProfiledBytecodes.new(subJson) |
| } |
| @numInlinedGetByIds = json["numInlinedGetByIds"] |
| @numInlinedPutByIds = json["numInlinedPutByIds"] |
| @numInlinedCalls = json["numInlinedCalls"] |
| @jettisonReason = json["jettisonReason"] |
| @additionalJettisonReason = json["additionalJettisonReason"] |
| @uid = json["uid"] |
| end |
| |
| def codeHashSortKey |
| bytecode.codeHashSortKey + "-" + compilationIndex.to_s |
| end |
| |
| def counter(origin) |
| @counters[origin] |
| end |
| |
| def totalCount |
| sum = 0 |
| @counters.values.each { |
| | value | |
| sum += value.count |
| } |
| sum |
| end |
| |
| def maxCount |
| max = 0 |
| @counters.values.each { |
| | value | |
| max = [max, value.count].max |
| } |
| max |
| end |
| |
| def to_s |
| "#{bytecode}-#{compilationIndex}-#{engine}" |
| end |
| end |
| |
| class DescriptionLine |
| attr_reader :actualCountsString, :sourceCountsString, :disassembly, :shouldShow |
| |
| def initialize(actualCountsString, sourceCountsString, disassembly, shouldShow) |
| @actualCountsString = actualCountsString |
| @sourceCountsString = sourceCountsString |
| @disassembly = disassembly |
| @shouldShow = shouldShow |
| end |
| |
| def codeAddress |
| if @disassembly =~ /^\s*(0x[0-9a-fA-F]+):/ |
| $1.hex |
| else |
| nil |
| end |
| end |
| end |
| |
| class Event |
| attr_reader :time, :bytecode, :compilation, :summary, :detail |
| |
| def initialize(json) |
| @time = json["time"].to_f |
| @bytecode = $bytecodes[json["bytecodesID"].to_i] |
| if json["compilationUID"] |
| @compilation = $compilationMap[json["compilationUID"]] |
| end |
| @summary = json["summary"] |
| @detail = json["detail"] |
| end |
| end |
| |
| def originToPrintStack(origin) |
| (0...(origin.size - 1)).map { |
| | index | |
| "bc\##{origin[index].bytecodeIndex} --> #{origin[index + 1].bytecodes}" |
| } |
| end |
| |
| def originToString(origin) |
| (originToPrintStack(origin) + ["bc\##{origin[-1].bytecodeIndex}"]).join(" ") |
| end |
| |
| if ARGV.length != 1 |
| $stderr.puts "Usage: display-profiler-output <path to profiler output file>" |
| $stderr.puts |
| $stderr.puts "The typical usage pattern for the profiler currently looks something like:" |
| $stderr.puts |
| $stderr.puts "Path/To/jsc -p profile.json myprogram.js" |
| $stderr.puts "display-profiler-output profile.json" |
| exit 1 |
| end |
| |
| $json = JSON::parse(IO::read(ARGV[0])) |
| $bytecodes = $json["bytecodes"].map { |
| | subJson | |
| Bytecodes.new(subJson) |
| } |
| $compilations = $json["compilations"].map { |
| | subJson | |
| Compilation.new(subJson) |
| } |
| $compilationMap = {} |
| $compilations.each { |
| | compilation | |
| $compilationMap[compilation.uid] = compilation |
| } |
| $events = $json["events"].map { |
| | subJson | |
| Event.new(subJson) |
| } |
| $engines = ["Baseline", "DFG", "FTL", "FTLForOSREntry"] |
| |
| def isOptimizing(engine) |
| engine == "DFG" or engine == "FTL" or engine == "FTLForOSREntry" |
| end |
| |
| $showCounts = true |
| $sortMode = :time |
| |
| def lpad(str, chars) |
| str = str.to_s |
| if str.length > chars |
| str |
| else |
| "%#{chars}s"%(str) |
| end |
| end |
| |
| def rpad(str, chars) |
| str = str.to_s |
| while str.length < chars |
| str += " " |
| end |
| str |
| end |
| |
| def center(str, chars) |
| str = str.to_s |
| while str.length < chars |
| str += " " |
| if str.length < chars |
| str = " " + str |
| end |
| end |
| str |
| end |
| |
| def mayBeHash(hash) |
| hash =~ /#/ or hash.size == 6 |
| end |
| |
| def sourceOnOneLine(source, limit) |
| source.gsub(/\s+/, ' ')[0...limit] |
| end |
| |
| def screenWidth |
| if $stdin.tty? |
| begin |
| HighLine::SystemExtensions.terminal_size[0] - 3 |
| rescue |
| HighLine::default_instance.terminal.terminal_size[0] - 3 |
| end |
| else |
| 200 |
| end |
| end |
| |
| def sortByMode(list) |
| if list.size == 1 |
| return list |
| end |
| case $sortMode |
| when :time |
| list |
| when :hash |
| puts "Will sort output by code hash instead of compilation time." |
| puts "Use 'sort time' to change back to the default." |
| puts |
| list.sort { | a, b | a.codeHashSortKey <=> b.codeHashSortKey } |
| else |
| raise |
| end |
| end |
| |
| def summary(mode, order) |
| remaining = screenWidth |
| |
| # Figure out how many columns we need for the code block names, and for counts |
| maxCount = 0 |
| maxName = 0 |
| $bytecodes.each { |
| | bytecodes | |
| maxCount = ([maxCount] + $engines.map { |
| | engine | |
| bytecodes.maxTopExecutionCount(engine) |
| } + $engines.map { |
| | engine | |
| bytecodes.maxBottomExecutionCount(engine) |
| }).max |
| maxName = [bytecodes.to_s.size, maxName].max |
| } |
| maxCountDigits = maxCount.to_s.size |
| |
| hashCols = [[maxName, 30].min, "CodeBlock".size].max |
| remaining -= hashCols + 1 |
| |
| countCols = [maxCountDigits * $engines.size + ($engines.size - 1), "Source Counts".size].max |
| remaining -= countCols + 1 |
| |
| if mode == :full |
| instructionCountCols = 6 |
| remaining -= instructionCountCols + 1 |
| |
| machineCountCols = [maxCountDigits * $engines.size, "Machine Counts".size].max |
| remaining -= machineCountCols + 1 |
| |
| compilationsCols = 7 |
| remaining -= compilationsCols + 1 |
| |
| inlinesCols = 9 |
| remaining -= inlinesCols + 1 |
| |
| exitCountCols = 7 |
| remaining -= exitCountCols + 1 |
| |
| recentOptsCols = 12 |
| remaining -= recentOptsCols + 1 |
| end |
| |
| if remaining > 0 |
| sourceCols = remaining |
| else |
| sourceCols = nil |
| end |
| |
| print(center("CodeBlock", hashCols)) |
| if mode == :full |
| print(" " + center("#Instr", instructionCountCols)) |
| end |
| print(" " + center("Source Counts", countCols)) |
| if mode == :full |
| print(" " + center("Machine Counts", machineCountCols)) |
| print(" " + center("#Compil", compilationsCols)) |
| print(" " + center("Inlines", inlinesCols)) |
| print(" " + center("#Exits", exitCountCols)) |
| print(" " + center("Last Opts", recentOptsCols)) |
| end |
| if sourceCols |
| print(" " + center("Source", sourceCols)) |
| end |
| puts |
| |
| print(center("", hashCols)) |
| if mode == :full |
| print(" " + (" " * instructionCountCols)) |
| end |
| print(" " + center("Base/DFG/FTL/FTLOSR", countCols)) |
| if mode == :full |
| print(" " + center("Base/DFG/FTL/FTLOSR", machineCountCols)) |
| print(" " + (" " * compilationsCols)) |
| print(" " + center("Src/Total", inlinesCols)) |
| print(" " + (" " * exitCountCols)) |
| print(" " + center("Get/Put/Call", recentOptsCols)) |
| end |
| puts |
| $bytecodes.sort { |
| | a, b | |
| case order |
| when :bytecode |
| b.totalMaxTopExecutionCount <=> a.totalMaxTopExecutionCount |
| when :machine |
| b.totalMaxBottomExecutionCount <=> a.totalMaxBottomExecutionCount |
| when :exits |
| b.totalExitCount <=> a.totalExitCount |
| when :compiles |
| b.compilations.size <=> a.compilations.size |
| else |
| raise |
| end |
| }.each { |
| | bytecode | |
| print(center(bytecode.name(hashCols), hashCols)) |
| if mode == :full |
| print(" " + center(bytecode.instructionCount.to_s, instructionCountCols)) |
| end |
| print(" " + |
| center($engines.map { |
| | engine | |
| bytecode.maxTopExecutionCount(engine).to_s |
| }.join("/"), countCols)) |
| if mode == :full |
| print(" " + center($engines.map { |
| | engine | |
| bytecode.maxBottomExecutionCount(engine).to_s |
| }.join("/"), machineCountCols)) |
| print(" " + center(bytecode.compilations.size.to_s, compilationsCols)) |
| print(" " + center(bytecode.sourceMachineInlineSites.to_s + "/" + bytecode.totalMachineInlineSites.to_s, inlinesCols)) |
| print(" " + center(bytecode.totalExitCount.to_s, exitCountCols)) |
| lastCompilation = bytecode.compilations[-1] |
| if lastCompilation |
| optData = [lastCompilation.numInlinedGetByIds, |
| lastCompilation.numInlinedPutByIds, |
| lastCompilation.numInlinedCalls] |
| else |
| optData = ["N/A"] |
| end |
| print(" " + center(optData.join('/'), recentOptsCols)) |
| end |
| if sourceCols |
| print(" " + sourceOnOneLine(bytecode.source, sourceCols)) |
| end |
| puts |
| } |
| end |
| |
| def queryCompilations(command, args) |
| compilationIndex = nil |
| |
| case args.length |
| when 1 |
| hash = args[0] |
| engine = nil |
| when 2 |
| if mayBeHash(args[0]) |
| hash = args[0] |
| engine = args[1] |
| else |
| engine = args[0] |
| hash = args[1] |
| end |
| else |
| puts "Usage: #{command} <code block hash> <engine>" |
| return |
| end |
| |
| if hash and hash =~ /-(-?[0-9]+)-/ |
| hash = $~.pre_match |
| engine = $~.post_match |
| compilationIndex = $1.to_i |
| end |
| |
| if engine and not $engines.index(engine) |
| pattern = Regexp.new(Regexp.escape(engine), "i") |
| trueEngine = nil |
| $engines.each { |
| | myEngine | |
| if myEngine =~ pattern |
| trueEngine = myEngine |
| break |
| end |
| } |
| unless trueEngine |
| puts "#{engine} is not a valid engine, try #{$engines.join(' or ')}." |
| return |
| end |
| engine = trueEngine |
| end |
| |
| if hash == "*" |
| hash = nil |
| end |
| |
| sortByMode($compilations).each { |
| | compilation | |
| next if hash and not compilation.bytecode.matches(hash) |
| next if engine and compilation.engine != engine |
| if compilationIndex |
| if compilationIndex < 0 |
| next unless compilation.bytecode.compilations[compilationIndex] == compilation |
| else |
| next unless compilation.compilationIndex == compilationIndex |
| end |
| end |
| |
| yield compilation |
| } |
| end |
| |
| def executeCommand(*commandArray) |
| command = commandArray[0] |
| args = commandArray[1..-1] |
| case command |
| when "help", "h", "?" |
| puts "summary (s) Print a summary of code block execution rates." |
| puts "full (f) Same as summary, but prints more information." |
| puts "source Show the source for a code block." |
| puts "bytecode (b) Show the bytecode for a code block, with counts." |
| puts "profiling (p) Show the (internal) profiling data for a code block." |
| puts "log (l) List the compilations, exits, and jettisons involving this code block." |
| puts "events (e) List of events involving this code block." |
| puts "display (d) Display details for a code block." |
| puts "inlines Show all inlining stacks that the code block was on." |
| puts "counts Set whether to show counts for 'bytecode' and 'display'." |
| puts "sort Set how to sort compilations before display." |
| puts "help (h) Print this message." |
| puts "quit (q) Quit." |
| when "quit", "q", "exit" |
| exit 0 |
| when "summary", "s" |
| summary(:summary, :bytecode) |
| when "full", "f" |
| if args[0] and (args[0] == "m" or args[0] == "machine") |
| summary(:full, :machine) |
| elsif args[0] and (args[0] == "e" or args[0] == "exits") |
| summary(:full, :exits) |
| elsif args[0] and (args[0] == "c" or args[0] == "compiles") |
| summary(:full, :compiles) |
| else |
| summary(:full, :bytecode) |
| end |
| when "source" |
| if args.length != 1 |
| puts "Usage: source <code block hash>" |
| return |
| end |
| $bytecodes.each { |
| | bytecode | |
| if bytecode.matches(args[0]) |
| puts bytecode.source |
| end |
| } |
| when "bytecode", "b" |
| if args.length != 1 |
| puts "Usage: source <code block hash>" |
| return |
| end |
| |
| hash = args[0] |
| |
| countCols = 10 * $engines.size |
| machineCols = 10 * $engines.size |
| pad = 1 |
| while (countCols + 1 + machineCols + pad) % 8 != 0 |
| pad += 1 |
| end |
| |
| sortByMode($bytecodes).each { |
| | bytecodes | |
| next unless bytecodes.matches(hash) |
| if $showCounts |
| puts(center("Source Counts", countCols) + " " + center("Machine Counts", machineCols) + |
| (" " * pad) + center("Bytecode for #{bytecodes}", screenWidth - pad - countCols - 1 - machineCols)) |
| puts(center("Base/DFG/FTL/FTLOSR", countCols) + " " + center("Base/DFG/FTL/FTLOSR", countCols)) |
| else |
| puts("Bytecode for #{bytecodes}:") |
| end |
| bytecodes.each { |
| | bytecode | |
| if $showCounts |
| if bytecode.shouldHaveCounts? |
| countsString = $engines.map { |
| | myEngine | |
| bytecode.topExecutionCount(myEngine) |
| }.join("/") |
| machineString = $engines.map { |
| | myEngine | |
| bytecode.bottomExecutionCount(myEngine) |
| }.join("/") |
| else |
| countsString = "" |
| machineString = "" |
| end |
| print(center(countsString, countCols) + " " + center(machineString, machineCols) + (" " * pad)) |
| end |
| puts(bytecode.description.chomp) |
| bytecode.osrExits.each { |
| | exit | |
| if $showCounts |
| print(center("!!!!!", countCols) + " " + center("!!!!!", machineCols) + (" " * pad)) |
| end |
| print(" " * 10) |
| puts("EXIT: in #{exit.compilation} due to #{exit.exitKind}, #{exit.count} times") |
| } |
| } |
| } |
| when "profiling", "p" |
| if args.length != 1 |
| puts "Usage: profiling <code block hash>" |
| return |
| end |
| |
| hash = args[0] |
| |
| first = true |
| sortByMode($compilations).each { |
| | compilation | |
| |
| compilation.profiledBytecodes.each { |
| | profiledBytecodes | |
| if profiledBytecodes.bytecodes.matches(hash) |
| if first |
| first = false |
| else |
| puts |
| end |
| |
| puts "Compilation #{compilation}:" |
| profiledBytecodes.header.each { |
| | header | |
| puts(" " * 6 + header) |
| } |
| profiledBytecodes.each { |
| | bytecode | |
| puts(" " * 8 + bytecode.description) |
| profiledBytecodes.bytecodes.bytecode(bytecode.bytecodeIndex).osrExits.each { |
| | exit | |
| if exit.compilation == compilation |
| puts(" !!!!! EXIT: due to #{exit.exitKind}, #{exit.count} times") |
| end |
| } |
| } |
| end |
| } |
| } |
| when "log", "l" |
| queryCompilations("log", args) { |
| | compilation | |
| puts "Compilation #{compilation}:" |
| puts " Total count: #{compilation.totalCount} Max count: #{compilation.maxCount}" |
| compilation.osrExits.values.each { |
| | exits | |
| exits.each { |
| | exit | |
| puts " EXIT: at #{originToString(exit.origin)} due to #{exit.exitKind}, #{exit.count} times" |
| } |
| } |
| if compilation.jettisonReason != "NotJettisoned" |
| puts " Jettisoned due to #{compilation.jettisonReason}" |
| if compilation.additionalJettisonReason |
| puts " #{compilation.additionalJettisonReason}" |
| end |
| end |
| } |
| when "events", "e" |
| if args.length != 1 |
| puts "Usage: inlines <code block hash>" |
| return |
| end |
| |
| hash = Regexp.new(Regexp.escape(args[0])) |
| |
| events = [] |
| $events.each { |
| | event | |
| if event.bytecode.to_s =~ hash |
| events << event |
| end |
| } |
| |
| timeCols = 0 |
| hashCols = 0 |
| compilationCols = 0 |
| summaryCols = 0 |
| events.each { |
| | event | |
| timeCols = [event.time.to_s.size, timeCols].max |
| hashCols = [event.bytecode.to_s.size, hashCols].max |
| if event.compilation |
| compilationCols = [event.compilation.to_s.size, compilationCols].max |
| end |
| summaryCols = [event.summary.size, summaryCols].max |
| } |
| |
| events.each { |
| | event | |
| print rpad(event.time.to_s, timeCols) |
| print " " |
| print rpad(event.bytecode.to_s, hashCols) |
| print " " |
| compilationStr = "" |
| if event.compilation |
| compilationStr = event.compilation.to_s |
| end |
| print rpad(compilationStr, compilationCols) |
| print " " |
| print rpad(event.summary, summaryCols) |
| print " " |
| puts event.detail |
| } |
| when "inlines" |
| if args.length != 1 |
| puts "Usage: inlines <code block hash>" |
| return |
| end |
| |
| hash = args[0] |
| |
| sortByMode($bytecodes).each { |
| | bytecodes | |
| next unless bytecodes.matches(hash) |
| |
| # FIXME: print something useful to say more about which code block this is. |
| |
| $compilations.each { |
| | compilation | |
| myOrigins = [] |
| compilation.descriptions.each { |
| | description | |
| if description.origin.index { |
| | myBytecode | |
| bytecodes == myBytecode.bytecodes |
| } |
| myOrigins << description.origin |
| end |
| } |
| myOrigins.uniq! |
| myOrigins.sort! { |
| | a, b | |
| result = 0 |
| [a.size, b.size].min.times { |
| | index | |
| result = a[index].bytecodeIndex <=> b[index].bytecodeIndex |
| break if result != 0 |
| } |
| result |
| } |
| |
| next if myOrigins.empty? |
| |
| printArray = [] |
| lastPrintStack = [] |
| |
| def printStack(printArray, stack, lastStack) |
| stillCommon = true |
| stack.each_with_index { |
| | entry, index | |
| next if stillCommon and entry == lastStack[index] |
| printArray << (" " * (index + 1) + entry) |
| stillCommon = false |
| } |
| end |
| |
| myOrigins.each { |
| | origin | |
| currentPrintStack = originToPrintStack(origin) |
| printStack(printArray, currentPrintStack, lastPrintStack) |
| lastPrintStack = currentPrintStack |
| } |
| |
| next if printArray.empty? |
| |
| puts "Compilation #{compilation}:" |
| printArray.each { |
| | entry | |
| puts entry |
| } |
| } |
| } |
| when "display", "d" |
| actualCountCols = 13 |
| sourceCountCols = 10 * $engines.size |
| |
| first = true |
| |
| queryCompilations("display", args) { |
| | compilation | |
| |
| if first |
| first = false |
| else |
| puts |
| end |
| |
| puts("Compilation #{compilation}:") |
| if $showCounts |
| puts(center("Actual Counts", actualCountCols) + " " + center("Source Counts", sourceCountCols) + " " + center("Disassembly in #{compilation.engine}", screenWidth - 1 - sourceCountCols - 1 - actualCountCols)) |
| puts((" " * actualCountCols) + " " + center("Base/DFG/FTL/FTLOSR", sourceCountCols)) |
| else |
| puts("Disassembly in #{compilation.engine}") |
| end |
| |
| lines = [] |
| |
| compilation.descriptions.each { |
| | description | |
| # FIXME: We should have a better way of detecting things like CountExecution nodes |
| # and slow path entries in the baseline JIT. |
| if description.description =~ /CountExecution\(/ and isOptimizing(compilation.engine) |
| shouldShow = false |
| else |
| shouldShow = true |
| end |
| if not description.origin.empty? and not description.origin[-1] |
| p description.origin |
| p description.description |
| end |
| if description.origin.empty? or not description.origin[-1].shouldHaveCounts? or (compilation.engine == "Baseline" and description.description =~ /^\s*\(S\)/) |
| actualCountsString = "" |
| sourceCountsString = "" |
| else |
| actualCountsString = compilation.counter(description.origin).count.to_s |
| sourceCountsString = $engines.map { |
| | myEngine | |
| description.origin[-1].topExecutionCount(myEngine) |
| }.join("/") |
| end |
| description.description.split("\n").each { |
| | line | |
| lines << DescriptionLine.new(actualCountsString, sourceCountsString, line.chomp, shouldShow) |
| } |
| } |
| |
| exitPrefix = "" |
| if $showCounts |
| exitPrefix += center("!!!!!", actualCountCols) + " " + center("!!!!!", sourceCountCols) + (" " * 15) |
| else |
| exitPrefix += " !!!!!" |
| end |
| exitPrefix += " " * 10 |
| |
| lines.each_with_index { |
| | line, index | |
| codeAddress = line.codeAddress |
| if codeAddress |
| list = compilation.osrExits[codeAddress] |
| if list |
| list.each { |
| | exit | |
| if exit.isWatchpoint |
| exit.dumpForDisplay(exitPrefix) |
| end |
| } |
| end |
| end |
| if line.shouldShow |
| if $showCounts |
| print(center(line.actualCountsString, actualCountCols) + " " + center(line.sourceCountsString, sourceCountCols) + " ") |
| end |
| puts(line.disassembly) |
| end |
| if codeAddress |
| # Find the next disassembly address. |
| endIndex = index + 1 |
| endAddress = nil |
| while endIndex < lines.size |
| myAddress = lines[endIndex].codeAddress |
| if myAddress |
| endAddress = myAddress |
| break |
| end |
| endIndex += 1 |
| end |
| |
| if endAddress |
| list = compilation.osrExits[endAddress] |
| if list |
| list.each { |
| | exit | |
| unless exit.isWatchpoint |
| exit.dumpForDisplay(exitPrefix) |
| end |
| } |
| end |
| end |
| end |
| } |
| } |
| when "counts" |
| if args.length != 1 |
| puts "Usage: counts on|off|toggle" |
| else |
| case args[0].downcase |
| when 'on' |
| $showCounts = true |
| when 'off' |
| $showCounts = false |
| when 'toggle' |
| $showCounts = !$showCounts |
| else |
| puts "Usage: counts on|off|toggle" |
| end |
| end |
| puts "Current value: #{$showCounts ? 'on' : 'off'}" |
| when "sort" |
| if args.length != 1 |
| puts "Usage: sort time|hash" |
| puts |
| puts "sort time: Sorts by the timestamp of when the code was compiled." |
| puts " This is the default." |
| puts |
| puts "sort hash: Sorts by the code hash. This is more deterministic," |
| puts " and is useful for diffs." |
| puts |
| else |
| case args[0].downcase |
| when 'time' |
| $sortMode = :time |
| when 'hash' |
| $sortMode = :hash |
| else |
| puts "Usage: sort time|hash" |
| end |
| end |
| puts "Current value: #{$sortMode}" |
| else |
| puts "Invalid command: #{command}" |
| end |
| end |
| |
| if $stdin.tty? |
| executeCommand("full") |
| end |
| |
| while commandLine = Readline.readline("> ", true) |
| executeCommand(*commandLine.split) |
| end |
| |
