johnson 2.0.0.pre0 → 2.0.0.pre1

data/vendor/tracemonkey/tracevis/binlog.py

@@ -0,0 +1,140 @@
+# Parse the binary log file of activity timings.
+#
+# If run as a script, print a summary of the log, giving the total
+# time in each activity.
+
+import sys
+import struct
+
+from config import *
+from acts import *
+
+S_INTERP = 1
+assert states[S_INTERP] == 'interpret'
+
+REASON_COUNT = len(reasons)
+
+def tuple_to_reason_index(rec):
+    if rec[1]:
+        return rec[1]
+    return REASON_COUNT + rec[0]
+
+def reason_index_label(i):
+    if i == REASON_COUNT:
+        return 'start'
+    if i > REASON_COUNT:
+        return states[i - REASON_COUNT]
+    return reasons[i]
+
+class History(object):
+    def __init__(self):
+        # list of (state, reason, time from start) tuples
+        self.transitions = []
+        # list of total time
+        self.state_summary = [ 0 ] * len(states)
+        # list of (count, total time) tuples
+        self.reason_summary = [ [0, 0] for _ in range(len(reasons) + len(states)) ]
+
+        self.t0 = None
+        self.stack = []
+        self.to_interp = None
+
+    def write(self, state, reason, time):
+        self.transitions.append((state, reason, time - self.t0))
+
+    def transition(self, rec0, rec1):
+        t1 = rec1[2]
+        dt = rec1[2] - rec0[2]
+        self.state_summary[rec0[0]] += dt
+
+        self.write(rec0[0], 0, rec1[2])
+        
+        # Transition to interpreter
+        if rec0[0] != S_INTERP and rec1[0] == S_INTERP:
+            self.to_interp = (rec0[0], rec1[1], rec1[2])
+        
+        # Transition from interpreter
+        if rec0[0] == S_INTERP and rec1[0] != S_INTERP:
+            rs_tup = self.reason_summary[tuple_to_reason_index(self.to_interp)]
+            rs_tup[0] += 1
+            rs_tup[1] += dt
+
+    def enter(self, rec):
+        if rec[0] >= event_start:
+            self.write(*rec)
+        else:
+            if self.t0 is None:
+                self.t0 = rec[2]
+                self.stack.append([0, 0, rec[2]])
+            self.transition(self.stack[-1], rec)
+            self.stack.append(rec)
+
+    def exit(self, rec):
+        entry = self.stack.pop()
+        prior = self.stack[-1]
+        exit = rec
+        exit[0] = prior[0]
+        self.transition(entry, exit)
+        prior[1] = rec[1]
+        prior[2] = rec[2]
+
+def read_history(filename):
+    h = History()
+    f = open(filename)
+    while True:
+        raw = f.read(8)
+        if not raw:
+            break
+        ull = struct.unpack_from('Q', raw, 0)[0]
+        rec = [(ull >> 60) & 0xf,
+               (ull >> 55) & 0x1f,
+               ull & ~(0x1ff << 55)]
+        if rec[0]:
+            h.enter(rec)
+        else:
+            h.exit(rec)
+    return h
+
+def summary(hist):
+    ep = 0       # estimated progress
+
+    print 'Activity duration summary:'
+    print
+    cycles = hist.state_summary
+    for sn, cyc, xf in zip(states, cycles, speedups):
+        if sn == 'exitlast': continue
+        ep += xf * cyc
+        print '%-12s %12.6f'%(sn, cyc/CPU_SPEED * 1000)
+    print '-'*25
+    print '%-12s %12.6f'%('Subtotal', sum(cycles[1:])/CPU_SPEED * 1000)
+    print '%-12s %12.6f'%('Non-JS', cycles[0]/CPU_SPEED * 1000)
+    print '='*25
+    print '%-12s %12.6f'%('Total', sum(cycles)/CPU_SPEED * 1000)
+
+    print 'Estimated speedup:  %.2fx'%(ep/sum(cycles[1:]))
+
+    print
+    print 'Reasons for transitions to interpret:'
+    print '%-12s %12s %8s %12s'%(
+        'Reason', 'sum (ms)', 'N', 'mean (us)')
+    rl = [ (rc[1], rc[0], reason_index_label(i))
+            for i, rc in enumerate(hist.reason_summary) ]
+    rl.sort(reverse=1)
+    for cyc, n, label in rl:
+        if cyc == 0: continue
+        print '%-12s %12.3f %8d %12.3f'%(
+            label, 
+            cyc/CPU_SPEED*1000, 
+            n, 
+            cyc/CPU_SPEED*1000000/n,
+            )
+
+if __name__ == '__main__':
+    if len(sys.argv) <= 1:
+        print >> sys.stderr, "usage: python binlog.py infile"
+        sys.exit(1);
+
+    filename = sys.argv[1]
+    history = read_history(filename)
+
+    summary(history)

data/vendor/tracemonkey/tracevis/config.py

@@ -0,0 +1,5 @@
+# Local machine configuration.
+
+# CPU speed in clock cycles per second
+CPU_SPEED = 2.2e9
+

data/vendor/tracemonkey/tracevis/tree.py

@@ -0,0 +1,282 @@
+#!/usr/bin/python
+# vim: set ts=2 sw=2 tw=99 noet: 
+import re
+import sys
+import string
+
+class Node:
+	def __init__(self, address):
+		self.address = address
+
+class Fragment:
+	def __init__(self, address, root, pc, file, line, offset):
+		self.address = 'x' + address[2:]
+		if root == None:
+			self.root = self
+		else:
+			self.root = root
+		self.pc = pc
+		self.file = file
+		self.line = line
+		self.exits = []
+		self.marked = False
+		self.offset = offset
+		self.stackTypes = None
+		self.globalTypes = None
+		self.lastExit = None
+		self.nodes = {}
+
+	def addNode(self, exit):
+		node = Node('L' + self.address + 'E' + exit.address)
+		self.nodes[exit.address] = node
+		return node
+
+	def nodeName(self, exit):
+		return self.nodes[exit.address].address
+
+	def type(self):
+		if self == self.root:
+			return 'loop'
+		else:
+			return 'branch'
+
+	def describe(self):
+		if self.stackTypes == None:
+			return '<' + self.type() + '<br/>' + self.line + '@' + self.offset + \
+						 '<br/>' + self.address + '>'
+		else:
+			return '<' + self.type() + '<br/>' + self.line + '@' + self.offset + \
+						 '<br/>' + self.address + ', ' + self.stackTypes + ',' + self.globalTypes + '>'
+
+	def addExit(self, e):
+		e.owner = self
+		self.exits.append(e)
+
+class Exit:
+	def __init__(self, address, type, pc, file, line, offs, _s, _g):
+		self.address = 'x' + address[2:]
+		self.type = type
+		self.pc = pc
+		self.file = file
+		self.line = line
+		self.offset = offs
+		self.stackTypes = _s
+		self.globalTypes = _g
+		self.owner = None
+		self.target = None
+		self.treeGuard = None
+		self.marked = False
+
+	def describe(self):
+		return '<' + self.type + '<br/>' + self.address + ', line ' + self.line + '@' + self.offset + \
+					 '<br/>' + self.stackTypes + ',' + self.globalTypes + '>'
+
+class TraceRecorder:
+	def __init__(self):
+		self.trees = {}
+		self.fragments = {}
+		self.exits = {}
+		self.currentFrag = None
+		self.currentAnchor = None
+		self.edges = []
+		self.treeEdges = []
+
+	def createTree(self, ROOT, PC, FILE, LINE, STACK, GLOBALS, OFFS):
+		f = Fragment(ROOT, None, PC, FILE, LINE, OFFS)
+		f.stackTypes = STACK
+		f.globalTypes = GLOBALS
+		self.trees[ROOT] = f
+		self.fragments[ROOT] = f
+		return f
+
+	def createBranch(self, ROOT, FRAG, PC, FILE, LINE, ANCHOR, OFFS):
+		root = self.trees[ROOT]
+		branch = Fragment(FRAG, root, PC, FILE, LINE, OFFS)
+		self.fragments[FRAG] = branch
+		return branch
+
+	def record(self, FRAG, ANCHOR):
+		self.currentFrag = self.fragments[FRAG]
+		if self.currentFrag.root != self.currentFrag:
+			self.currentAnchor = self.exits[ANCHOR]
+		else:
+			self.currentAnchor = None
+
+	def addExit(self, EXIT, TYPE, FRAG, PC, FILE, LINE, OFFS, STACK, GLOBALS):
+		if EXIT not in self.exits:
+			e = Exit(EXIT, TYPE, PC, FILE, LINE, OFFS, STACK, GLOBALS)
+			e.owner = self.fragments[FRAG]
+			self.exits[EXIT] = e
+		else:
+			e = self.exits[EXIT]
+		self.currentFrag.addExit(e)
+
+	def changeExit(self, EXIT, TYPE):
+		exit = self.exits[EXIT]
+		exit.type = TYPE
+
+	def endLoop(self, EXIT):
+		exit = self.exits[EXIT]
+		if self.currentAnchor != None:
+			self.currentAnchor.target = self.currentFrag
+		self.currentFrag.lastExit = exit
+		self.currentFrag = None
+		self.currentAnchor = None
+
+	def closeLoop(self, EXIT, PEER):
+		exit = self.exits[EXIT]
+		if self.currentAnchor != None:
+			self.currentAnchor.target = self.currentFrag
+		if exit.type != "LOOP" and PEER != "0x0":
+			peer = self.trees[PEER]
+			exit.target = peer
+		self.currentFrag.lastExit = exit
+		self.currentFrag = None
+		self.currentAnchor = None
+
+	def join(self, ANCHOR, FRAG):
+		exit = self.exits[ANCHOR]
+		fragment = self.fragments[FRAG]
+		exit.target = fragment
+
+	def treeCall(self, INNER, EXIT, GUARD):
+		exit = self.exits[EXIT]
+		inner = self.trees[INNER]
+		guard = self.exits[GUARD]
+		exit.target = inner
+		exit.treeGuard = guard
+
+	def trash(self, FRAG):
+		pass
+
+	def readLine(self, line):
+		cmd = re.match(r"TREEVIS ([^ ]+) (.*)$", line)
+		if cmd == None:
+			return
+		cmd = cmd.groups()
+		keys = dict([w.split('=') for w in string.split(cmd[1])])
+		if cmd[0] == "CREATETREE":
+			self.createTree(**keys)
+		elif cmd[0] == "RECORD":
+			self.record(**keys)
+		elif cmd[0] == "ADDEXIT":
+			self.addExit(**keys)
+		elif cmd[0] == "CREATEBRANCH":
+			self.createBranch(**keys)
+		elif cmd[0] == "CLOSELOOP":
+			self.closeLoop(**keys)
+		elif cmd[0] == "CHANGEEXIT":
+			self.changeExit(**keys)
+		elif cmd[0] == "ENDLOOP":
+			self.endLoop(**keys)
+		elif cmd[0] == "JOIN":
+			self.join(**keys)
+		elif cmd[0] == "TRASH":
+			self.trash(**keys)
+		elif cmd[0] == "TREECALL":
+			self.treeCall(**keys)
+		else:
+			raise Exception("unknown command: " + cmd[0])
+
+	def describeTree(self, fragment):
+		return '<' + 'tree call to<br/>' + fragment.line + '@' + fragment.offset + '>'
+
+	def emitExit(self, fragment, exit):
+		if exit.type == "NESTED":
+			print '\t\ttc_' + exit.address + ' [ shape = octagon, label = ' + \
+						self.describeTree(exit.target) + ' ]'
+			self.edges.append(['tc_' + exit.address, exit.target.address])
+		node = fragment.addNode(exit)
+		print '\t\t' + node.address + ' [ label = ' + exit.describe() + ' ]'
+
+	def emitTrace(self, fragment):
+		if fragment.marked == True:
+			raise Exception('fragment already marked')
+		print "\t\t" + fragment.address + " [ label = <start> ] "
+		for e in fragment.exits:
+			if e.target == None and (e != fragment.lastExit and e.type != 'LOOP'):
+				continue
+			self.emitExit(fragment, e)
+		last = fragment.address
+		for e in fragment.exits:
+			if e.target == None and (e != fragment.lastExit and e.type != 'LOOP'):
+				continue
+			if e.type == "NESTED":
+				print '\t\t' + last + ' -> tc_' + e.address
+				print '\t\ttc_' + e.address + ' -> ' + fragment.nodeName(e) + \
+							' [ arrowtail = dot, arrowhead = onormal ] '
+				if e.treeGuard != None:
+					self.treeEdges.append([e, fragment.nodeName(e)])
+			else:
+				print '\t\t' + last + ' -> ' + fragment.nodeName(e)
+				if e.target == None and e.type == 'LOOP':
+					self.edges.append([fragment.nodeName(e), fragment.root.address])
+				elif e.target != None:
+					self.edges.append([fragment.nodeName(e), e.target.address])
+			last = fragment.nodeName(e)
+
+	def emitBranch(self, fragment):
+		if fragment.root == fragment:
+			raise Exception('branches have root!=frag')
+		if fragment.lastExit == None:
+			fragment.marked = True
+			return
+		print '\tsubgraph cluster_' + fragment.address + ' {'
+		print '\t\tlabel = ' + fragment.describe()
+		self.emitTrace(fragment)
+		fragment.marked = True
+		print "\t}"
+		self.emitBranches(fragment)
+
+	def emitBranches(self, fragment):
+		for e in fragment.exits:
+			if not e.target or e.target.marked:
+				continue
+			if e.target == e.target.root:
+				self.emitTree(e.target)
+			else:
+				self.emitBranch(e.target)
+
+	def emitTree(self, fragment):
+		if fragment.root != fragment:
+			raise Exception('trees have root=frag')
+		if fragment.lastExit == None:
+			fragment.marked = True
+			return
+		print '\tsubgraph cluster_' + fragment.address + ' {'
+		print '\t\tlabel = ' + fragment.describe()
+		self.emitTrace(fragment)
+		print "\t}"
+		fragment.marked = True
+		self.emitBranches(fragment)
+
+	def emitGraph(self):
+		print "digraph G {"
+		worklist = [self.trees[fragment] for fragment in self.trees]
+		for fragment in worklist:
+			if fragment.marked:
+				continue
+			self.emitTree(fragment)
+		for edge in self.edges:
+			name = edge[0]
+			address = edge[1]
+			print '\t' + name + ' -> ' + address
+		for edge in self.treeEdges:
+			fromName = edge[0].treeGuard.owner.nodeName(edge[0].treeGuard)
+			toName = edge[1]
+			print '\t' + fromName + ' -> ' + toName + \
+					  ' [ arrowtail = dot ]'
+		print "}"
+
+	def fromFile(self, file):
+		line = file.readline()
+		while line != "":
+			self.readLine(line)
+			line = file.readline()
+
+tr = TraceRecorder()
+f = open(sys.argv[1], "r")
+tr.fromFile(f)
+f.close()
+tr.emitGraph()
+

data/vendor/tracemonkey/tracevis/vis.py

@@ -0,0 +1,233 @@
+import os, struct, sys
+import Image, ImageDraw, ImageFont
+
+from config import *
+from acts import *
+from binlog import read_history
+from progressbar import ProgressBar
+from time import clock
+
+BLACK = (0, 0, 0)
+WHITE = (255, 255, 255)
+font = ImageFont.load_default()
+
+states = [
+    (0, 0, 0),
+    (225, 225, 225), #(170, 20, 10),
+    (225, 30, 12),
+    (140, 0, 255),
+    (0, 0, 255),
+    (180, 180, 30),
+    (0, 160, 30),
+]
+
+timeslices_ms = [
+    1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000 ]
+
+class Data(object):
+    def __init__(self, duration, summary, transitions):
+        self.duration = duration
+        self.summary = summary
+        self.transitions = transitions
+
+def parse_raw(filename):
+    hist = read_history(filename)
+    return Data(hist.transitions[-1][2] - hist.transitions[0][2],
+                hist.state_summary,
+                hist.transitions)
+
+def parse_cooked(filename):
+    f = open(filename)
+    header = f.read(20)
+    if header != 'TraceVis-History0001':
+        print "Invalid header"
+        sys.exit(1)
+
+    duration = struct.unpack_from('Q', f.read(8))[0]
+    summary = []
+    state_count = struct.unpack_from('I', f.read(4))[0]
+    for i in range(state_count):
+        summary.append(struct.unpack_from('Q', f.read(8))[0])
+
+    # This method is actually faster than reading it all into a buffer and decoding
+    # from there.
+    pos = f.tell()
+    f.seek(0, os.SEEK_END)
+    n = (f.tell() - pos) / 10
+    f.seek(pos)
+
+    pb = ProgressBar('read input', n)
+    blip = n / 100
+
+    transitions = []
+    for i in range(n):
+        if i % blip == 0:
+            pb.update(i)
+        raw = f.read(10)
+        s = struct.unpack_from('B', raw)[0]
+        r = struct.unpack_from('B', raw, 1)[0]
+        t = struct.unpack_from('Q', raw, 2)[0]
+        transitions.append((s, r, t))
+    pb.finish()
+    
+    return Data(duration, summary, transitions)
+
+def draw(data, outfile):
+    total, summary, ts = data.duration, data.summary, data.transitions
+
+    W, H, HA, HB = 1600, 256, 64, 64
+    HZ = H + 4 + HA + 4 + HB
+    im = Image.new('RGBA', (W, HZ + 20))
+    d = ImageDraw.Draw(im)
+
+    # Filter
+    if 0:
+        a, b = 10*2.2e9, 12*2.2e9
+        ts = [(s, t-a) for s, t in ts if a <= t <= b ]
+    total_ms = total / CPU_SPEED * 1000
+
+    pp = 1.0 * total / (W*H)
+    pc_us = 1.0 * total / CPU_SPEED / W * 1e6
+    print "Parsed %d items, t=%f, t/pixel=%f"%(len(ts), total/CPU_SPEED, pp/CPU_SPEED*1000)
+
+    d.rectangle((0, H + 4, W, H + 4 + HA), (255, 255, 255))
+
+    eps = []
+
+    # estimated progress of program run 
+    ep = 0
+
+    # text progress indicator for graph generation
+    pb = ProgressBar('draw main', W*H)
+    blip = W*H//50
+
+    # Flush events. We need to save them and draw them after filling the main area
+    # because otherwise they will be overwritten. Format is (x, y, r) to plot flush at,
+    # where r is reason code.
+    events = []
+
+    ti = 0
+    for i in range(W*H):
+        if i % blip == 0:
+            pb.update(i)
+        x, y = i/H, i%H
+
+        t0 = pp * i
+        t1 = t0 + pp
+        color = [ 0, 0, 0 ]
+        tx = t0
+        while ti < len(ts):
+            state, reason, time = ts[ti];
+            # States past this limit are actually events rather than state transitions
+            if state >= event_start:
+                events.append((x, y, reason))
+                ti += 1
+                continue
+
+            q = (min(time, t1)-tx)/pp
+            c = states[state]
+            color[0] += q * c[0]
+            color[1] += q * c[1]
+            color[2] += q * c[2]
+            ep += q * speedups[state]
+            if time > t1:
+                break
+            tx = time
+            ti += 1
+        
+        color[0] = int(color[0])
+        color[1] = int(color[1])
+        color[2] = int(color[2])
+
+        d.point((x, y), fill=tuple(color))
+
+        if i % H == H - 1:
+            eps.append(ep)
+            ep = 0
+
+    for x, y, r in events:
+        d.ellipse((x-5, y-5, x+5, y+5), fill=(255, 222, 222), outline=(160, 10, 10))
+        ch = flush_reasons[r]
+        d.text((x-2, y-5), ch, fill=BLACK, font=font)
+
+    pb.finish()
+
+    epmax = 2.5*H
+
+    d.line((0, H+4+HA-1.0*H/epmax*HA, W,  H+4+HA-1.0*H/epmax*HA), fill=(192, 192, 192))
+    d.line((0, H+4+HA-2.5*H/epmax*HA, W,  H+4+HA-2.5*H/epmax*HA), fill=(192, 192, 192))
+
+    last = None
+    for i in range(W):
+        n = 0
+        sm = 0
+        for j in range(max(0, i-3), min(W-1, i+3)):
+            sm += eps[j]
+            n += 1
+        ep = sm / n
+
+        ep_scaled = 1.0 * ep / epmax * HA
+        px = (i, H + 4 + HA - int(ep_scaled))
+        if last:
+            d.line((px, last), fill=(0, 0, 0))
+        last = px
+        #d.point((i, H + 4 + HA - int(ep_scaled)), fill=(0, 0, 0))
+
+    t = 0
+    ppt = 1.0 * W / total
+    if True:
+        for dt, c in zip(summary, states):
+            x1 = int(t * ppt)
+            y1 = H + 4 + HA + 5 
+            x2 = int((t+dt) * ppt)
+            y2 = H + 4 + HA + 4 + HB
+            d.rectangle((x1, y1, x2, y2), fill=c)
+            t += dt
+
+    # Time lines
+    i = 0
+    while True:
+        divs = total_ms / timeslices_ms[i]
+        if divs < 15: break
+        if i == len(timeslices_ms) - 1: break
+        i += 1
+
+    timeslice = timeslices_ms[i]
+    t = timeslice
+    c = (128, 128, 128)
+    while t < total_ms:
+        x = t / total_ms * W
+        y = 0
+        while y < HZ:
+            d.line((x, y, x, y + 8), fill=c)
+            y += 12
+        text = '%d ms'%t
+        w, h = font.getsize(text)
+        d.text((x-w/2, HZ), text, fill=BLACK, font=font)
+        t += timeslice
+
+    d.text((0, HZ), '[%.1fus]'%pc_us, fill=BLACK)
+
+    im.save(outfile, "PNG")
+
+if __name__ == '__main__':
+    from optparse import OptionParser
+    parser = OptionParser()
+    parser.add_option('-c', action='store_true', dest='cooked', default=False,
+                      help='process cooked format input file')
+    options, args = parser.parse_args()
+
+    if len(sys.argv) <= 2:
+        print >> sys.stderr, "usage: python vis.py infile outfile"
+        sys.exit(1);
+    filename = sys.argv[1]
+    outfile  = sys.argv[2]
+    if not outfile.endswith('.png'):
+        print >> sys.stderr, "warning: output filename does not end with .png; output is in png format."
+
+    if options.cooked:
+        data = parse_cooked(filename)
+    else:
+        data = parse_raw(filename)
+
+    draw(data, outfile)