blob: 35e1c0e5f949232dd609a953bebab76745a36b79 [file] [log] [blame]
#!/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?
HighLine::SystemExtensions.terminal_size[0] - 3
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