therubyracer 0.5.0-x86-linux → 0.11.0beta5-x86-linux

data/ext/v8/upstream/2.0.6/tools/splaytree.py

@@ -1,226 +0,0 @@
-# Copyright 2008 the V8 project authors. All rights reserved.
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-#       notice, this list of conditions and the following disclaimer.
-#     * 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.
-#     * Neither the name of Google Inc. nor the names of its
-#       contributors may be used to endorse or promote products derived
-#       from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
-# OWNER OR 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.
-
-
-class Node(object):
-  """Nodes in the splay tree."""
-
-  def __init__(self, key, value):
-    self.key = key
-    self.value = value
-    self.left = None
-    self.right = None
-
-
-class KeyNotFoundError(Exception):
-  """KeyNotFoundError is raised when removing a non-existing node."""
-
-  def __init__(self, key):
-    self.key = key
-
-
-class SplayTree(object):
-  """The splay tree itself is just a reference to the root of the tree."""
-
-  def __init__(self):
-    """Create a new SplayTree."""
-    self.root = None
-
-  def IsEmpty(self):
-    """Is the SplayTree empty?"""
-    return not self.root
-
-  def Insert(self, key, value):
-    """Insert a new node in the SplayTree."""
-    # If the tree is empty, insert the new node.
-    if self.IsEmpty():
-      self.root = Node(key, value)
-      return
-    # Splay on the key to move the last node on the search path for
-    # the key to the root of the tree.
-    self.Splay(key)
-    # Ignore repeated insertions with the same key.
-    if self.root.key == key:
-      return
-    # Insert the new node.
-    node = Node(key, value)
-    if key > self.root.key:
-      node.left = self.root
-      node.right = self.root.right
-      self.root.right = None
-    else:
-      node.right = self.root
-      node.left = self.root.left
-      self.root.left = None
-    self.root = node
-
-  def Remove(self, key):
-    """Remove the node with the given key from the SplayTree."""
-    # Raise exception for key that is not found if the tree is empty.
-    if self.IsEmpty():
-      raise KeyNotFoundError(key)
-    # Splay on the key to move the node with the given key to the top.
-    self.Splay(key)
-    # Raise exception for key that is not found.
-    if self.root.key != key:
-      raise KeyNotFoundError(key)
-    removed = self.root
-    # Link out the root node.
-    if not self.root.left:
-      # No left child, so the new tree is just the right child.
-      self.root = self.root.right
-    else:
-      # Left child exists.
-      right = self.root.right
-      # Make the original left child the new root.
-      self.root = self.root.left
-      # Splay to make sure that the new root has an empty right child.
-      self.Splay(key)
-      # Insert the original right child as the right child of the new
-      # root.
-      self.root.right = right
-    return removed
-
-  def Find(self, key):
-    """Returns the node with the given key or None if no such node exists."""
-    if self.IsEmpty():
-      return None
-    self.Splay(key)
-    if self.root.key == key:
-      return self.root
-    return None
-
-  def FindMax(self):
-    """Returns the node with the largest key value."""
-    if self.IsEmpty():
-      return None
-    current = self.root
-    while current.right != None:
-      current = current.right
-    return current
-
-  # Returns the node with the smallest key value.
-  def FindMin(self):
-    if self.IsEmpty():
-      return None
-    current = self.root
-    while current.left != None:
-      current = current.left
-    return current
-
-  def FindGreatestsLessThan(self, key):
-    """Returns node with greatest key less than or equal to the given key."""
-    if self.IsEmpty():
-      return None
-    # Splay on the key to move the node with the given key or the last
-    # node on the search path to the top of the tree.
-    self.Splay(key)
-    # Now the result is either the root node or the greatest node in
-    # the left subtree.
-    if self.root.key <= key:
-      return self.root
-    else:
-      tmp = self.root
-      self.root = self.root.left
-      result = self.FindMax()
-      self.root = tmp
-      return result
-
-  def ExportValueList(self):
-    """Returns a list containing all the values of the nodes in the tree."""
-    result = []
-    nodes_to_visit = [self.root]
-    while len(nodes_to_visit) > 0:
-      node = nodes_to_visit.pop()
-      if not node:
-        continue
-      result.append(node.value)
-      nodes_to_visit.append(node.left)
-      nodes_to_visit.append(node.right)
-    return result
-
-  def Splay(self, key):
-    """Perform splay operation.
-
-    Perform the splay operation for the given key. Moves the node with
-    the given key to the top of the tree.  If no node has the given
-    key, the last node on the search path is moved to the top of the
-    tree.
-
-    This uses the simplified top-down splaying algorithm from:
-
-    "Self-adjusting Binary Search Trees" by Sleator and Tarjan
-
-    """
-    if self.IsEmpty():
-      return
-    # Create a dummy node.  The use of the dummy node is a bit
-    # counter-intuitive: The right child of the dummy node will hold
-    # the L tree of the algorithm.  The left child of the dummy node
-    # will hold the R tree of the algorithm.  Using a dummy node, left
-    # and right will always be nodes and we avoid special cases.
-    dummy = left = right = Node(None, None)
-    current = self.root
-    while True:
-      if key < current.key:
-        if not current.left:
-          break
-        if key < current.left.key:
-          # Rotate right.
-          tmp = current.left
-          current.left = tmp.right
-          tmp.right = current
-          current = tmp
-          if not current.left:
-            break
-        # Link right.
-        right.left = current
-        right = current
-        current = current.left
-      elif key > current.key:
-        if not current.right:
-          break
-        if key > current.right.key:
-          # Rotate left.
-          tmp = current.right
-          current.right = tmp.left
-          tmp.left = current
-          current = tmp
-          if not current.right:
-            break
-        # Link left.
-        left.right = current
-        left = current
-        current = current.right
-      else:
-        break
-    # Assemble.
-    left.right = current.left
-    right.left = current.right
-    current.left = dummy.right
-    current.right = dummy.left
-    self.root = current

data/ext/v8/upstream/2.0.6/tools/stats-viewer.py

@@ -1,456 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2008 the V8 project authors. All rights reserved.
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-#       notice, this list of conditions and the following disclaimer.
-#     * 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.
-#     * Neither the name of Google Inc. nor the names of its
-#       contributors may be used to endorse or promote products derived
-#       from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
-# OWNER OR 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.
-
-
-"""A cross-platform execution counter viewer.
-
-The stats viewer reads counters from a binary file and displays them
-in a window, re-reading and re-displaying with regular intervals.
-"""
-
-
-import mmap
-import os
-import re
-import struct
-import sys
-import time
-import Tkinter
-
-
-# The interval, in milliseconds, between ui updates
-UPDATE_INTERVAL_MS = 100
-
-
-# Mapping from counter prefix to the formatting to be used for the counter
-COUNTER_LABELS = {"t": "%i ms.", "c": "%i"}
-
-
-# The magic numbers used to check if a file is not a counters file
-COUNTERS_FILE_MAGIC_NUMBER = 0xDEADFACE
-CHROME_COUNTERS_FILE_MAGIC_NUMBER = 0x13131313
-
-
-class StatsViewer(object):
-  """The main class that keeps the data used by the stats viewer."""
-
-  def __init__(self, data_name):
-    """Creates a new instance.
-
-    Args:
-      data_name: the name of the file containing the counters.
-    """
-    self.data_name = data_name
-
-    # The handle created by mmap.mmap to the counters file.  We need
-    # this to clean it up on exit.
-    self.shared_mmap = None
-
-    # A mapping from counter names to the ui element that displays
-    # them
-    self.ui_counters = {}
-
-    # The counter collection used to access the counters file
-    self.data = None
-
-    # The Tkinter root window object
-    self.root = None
-
-  def Run(self):
-    """The main entry-point to running the stats viewer."""
-    try:
-      self.data = self.MountSharedData()
-      # OpenWindow blocks until the main window is closed
-      self.OpenWindow()
-    finally:
-      self.CleanUp()
-
-  def MountSharedData(self):
-    """Mount the binary counters file as a memory-mapped file.  If
-    something goes wrong print an informative message and exit the
-    program."""
-    if not os.path.exists(self.data_name):
-      maps_name = "/proc/%s/maps" % self.data_name
-      if not os.path.exists(maps_name):
-        print "\"%s\" is neither a counter file nor a PID." % self.data_name
-        sys.exit(1)
-      maps_file = open(maps_name, "r")
-      try:
-        m = re.search(r"/dev/shm/\S*", maps_file.read())
-        if m is not None and os.path.exists(m.group(0)):
-          self.data_name = m.group(0)
-        else:
-          print "Can't find counter file in maps for PID %s." % self.data_name
-          sys.exit(1)
-      finally:
-        maps_file.close()
-    data_file = open(self.data_name, "r")
-    size = os.fstat(data_file.fileno()).st_size
-    fileno = data_file.fileno()
-    self.shared_mmap = mmap.mmap(fileno, size, access=mmap.ACCESS_READ)
-    data_access = SharedDataAccess(self.shared_mmap)
-    if data_access.IntAt(0) == COUNTERS_FILE_MAGIC_NUMBER:
-      return CounterCollection(data_access)
-    elif data_access.IntAt(0) == CHROME_COUNTERS_FILE_MAGIC_NUMBER:
-      return ChromeCounterCollection(data_access)
-    print "File %s is not stats data." % self.data_name
-    sys.exit(1)
-
-  def CleanUp(self):
-    """Cleans up the memory mapped file if necessary."""
-    if self.shared_mmap:
-      self.shared_mmap.close()
-
-  def UpdateCounters(self):
-    """Read the contents of the memory-mapped file and update the ui if
-    necessary.  If the same counters are present in the file as before
-    we just update the existing labels.  If any counters have been added
-    or removed we scrap the existing ui and draw a new one.
-    """
-    changed = False
-    counters_in_use = self.data.CountersInUse()
-    if counters_in_use != len(self.ui_counters):
-      self.RefreshCounters()
-      changed = True
-    else:
-      for i in xrange(self.data.CountersInUse()):
-        counter = self.data.Counter(i)
-        name = counter.Name()
-        if name in self.ui_counters:
-          value = counter.Value()
-          ui_counter = self.ui_counters[name]
-          counter_changed = ui_counter.Set(value)
-          changed = (changed or counter_changed)
-        else:
-          self.RefreshCounters()
-          changed = True
-          break
-    if changed:
-      # The title of the window shows the last time the file was
-      # changed.
-      self.UpdateTime()
-    self.ScheduleUpdate()
-
-  def UpdateTime(self):
-    """Update the title of the window with the current time."""
-    self.root.title("Stats Viewer [updated %s]" % time.strftime("%H:%M:%S"))
-
-  def ScheduleUpdate(self):
-    """Schedules the next ui update."""
-    self.root.after(UPDATE_INTERVAL_MS, lambda: self.UpdateCounters())
-
-  def RefreshCounters(self):
-    """Tear down and rebuild the controls in the main window."""
-    counters = self.ComputeCounters()
-    self.RebuildMainWindow(counters)
-
-  def ComputeCounters(self):
-    """Group the counters by the suffix of their name.
-
-    Since the same code-level counter (for instance "X") can result in
-    several variables in the binary counters file that differ only by a
-    two-character prefix (for instance "c:X" and "t:X") counters are
-    grouped by suffix and then displayed with custom formatting
-    depending on their prefix.
-
-    Returns:
-      A mapping from suffixes to a list of counters with that suffix,
-      sorted by prefix.
-    """
-    names = {}
-    for i in xrange(self.data.CountersInUse()):
-      counter = self.data.Counter(i)
-      name = counter.Name()
-      names[name] = counter
-
-    # By sorting the keys we ensure that the prefixes always come in the
-    # same order ("c:" before "t:") which looks more consistent in the
-    # ui.
-    sorted_keys = names.keys()
-    sorted_keys.sort()
-
-    # Group together the names whose suffix after a ':' are the same.
-    groups = {}
-    for name in sorted_keys:
-      counter = names[name]
-      if ":" in name:
-        name = name[name.find(":")+1:]
-      if not name in groups:
-        groups[name] = []
-      groups[name].append(counter)
-
-    return groups
-
-  def RebuildMainWindow(self, groups):
-    """Tear down and rebuild the main window.
-
-    Args:
-      groups: the groups of counters to display
-    """
-    # Remove elements in the current ui
-    self.ui_counters.clear()
-    for child in self.root.children.values():
-      child.destroy()
-
-    # Build new ui
-    index = 0
-    sorted_groups = groups.keys()
-    sorted_groups.sort()
-    for counter_name in sorted_groups:
-      counter_objs = groups[counter_name]
-      name = Tkinter.Label(self.root, width=50, anchor=Tkinter.W,
-                           text=counter_name)
-      name.grid(row=index, column=0, padx=1, pady=1)
-      count = len(counter_objs)
-      for i in xrange(count):
-        counter = counter_objs[i]
-        name = counter.Name()
-        var = Tkinter.StringVar()
-        value = Tkinter.Label(self.root, width=15, anchor=Tkinter.W,
-                              textvariable=var)
-        value.grid(row=index, column=(1 + i), padx=1, pady=1)
-
-        # If we know how to interpret the prefix of this counter then
-        # add an appropriate formatting to the variable
-        if (":" in name) and (name[0] in COUNTER_LABELS):
-          format = COUNTER_LABELS[name[0]]
-        else:
-          format = "%i"
-        ui_counter = UiCounter(var, format)
-        self.ui_counters[name] = ui_counter
-        ui_counter.Set(counter.Value())
-      index += 1
-    self.root.update()
-
-  def OpenWindow(self):
-    """Create and display the root window."""
-    self.root = Tkinter.Tk()
-
-    # Tkinter is no good at resizing so we disable it
-    self.root.resizable(width=False, height=False)
-    self.RefreshCounters()
-    self.ScheduleUpdate()
-    self.root.mainloop()
-
-
-class UiCounter(object):
-  """A counter in the ui."""
-
-  def __init__(self, var, format):
-    """Creates a new ui counter.
-
-    Args:
-      var: the Tkinter string variable for updating the ui
-      format: the format string used to format this counter
-    """
-    self.var = var
-    self.format = format
-    self.last_value = None
-
-  def Set(self, value):
-    """Updates the ui for this counter.
-
-    Args:
-      value: The value to display
-
-    Returns:
-      True if the value had changed, otherwise False.  The first call
-      always returns True.
-    """
-    if value == self.last_value:
-      return False
-    else:
-      self.last_value = value
-      self.var.set(self.format % value)
-      return True
-
-
-class SharedDataAccess(object):
-  """A utility class for reading data from the memory-mapped binary
-  counters file."""
-
-  def __init__(self, data):
-    """Create a new instance.
-
-    Args:
-      data: A handle to the memory-mapped file, as returned by mmap.mmap.
-    """
-    self.data = data
-
-  def ByteAt(self, index):
-    """Return the (unsigned) byte at the specified byte index."""
-    return ord(self.CharAt(index))
-
-  def IntAt(self, index):
-    """Return the little-endian 32-byte int at the specified byte index."""
-    word_str = self.data[index:index+4]
-    result, = struct.unpack("I", word_str)
-    return result
-
-  def CharAt(self, index):
-    """Return the ascii character at the specified byte index."""
-    return self.data[index]
-
-
-class Counter(object):
-  """A pointer to a single counter withing a binary counters file."""
-
-  def __init__(self, data, offset):
-    """Create a new instance.
-
-    Args:
-      data: the shared data access object containing the counter
-      offset: the byte offset of the start of this counter
-    """
-    self.data = data
-    self.offset = offset
-
-  def Value(self):
-    """Return the integer value of this counter."""
-    return self.data.IntAt(self.offset)
-
-  def Name(self):
-    """Return the ascii name of this counter."""
-    result = ""
-    index = self.offset + 4
-    current = self.data.ByteAt(index)
-    while current:
-      result += chr(current)
-      index += 1
-      current = self.data.ByteAt(index)
-    return result
-
-
-class CounterCollection(object):
-  """An overlay over a counters file that provides access to the
-  individual counters contained in the file."""
-
-  def __init__(self, data):
-    """Create a new instance.
-
-    Args:
-      data: the shared data access object
-    """
-    self.data = data
-    self.max_counters = data.IntAt(4)
-    self.max_name_size = data.IntAt(8)
-
-  def CountersInUse(self):
-    """Return the number of counters in active use."""
-    return self.data.IntAt(12)
-
-  def Counter(self, index):
-    """Return the index'th counter."""
-    return Counter(self.data, 16 + index * self.CounterSize())
-
-  def CounterSize(self):
-    """Return the size of a single counter."""
-    return 4 + self.max_name_size
-
-
-class ChromeCounter(object):
-  """A pointer to a single counter withing a binary counters file."""
-
-  def __init__(self, data, name_offset, value_offset):
-    """Create a new instance.
-
-    Args:
-      data: the shared data access object containing the counter
-      name_offset: the byte offset of the start of this counter's name
-      value_offset: the byte offset of the start of this counter's value
-    """
-    self.data = data
-    self.name_offset = name_offset
-    self.value_offset = value_offset
-
-  def Value(self):
-    """Return the integer value of this counter."""
-    return self.data.IntAt(self.value_offset)
-
-  def Name(self):
-    """Return the ascii name of this counter."""
-    result = ""
-    index = self.name_offset
-    current = self.data.ByteAt(index)
-    while current:
-      result += chr(current)
-      index += 1
-      current = self.data.ByteAt(index)
-    return result
-
-
-class ChromeCounterCollection(object):
-  """An overlay over a counters file that provides access to the
-  individual counters contained in the file."""
-
-  _HEADER_SIZE = 4 * 4
-  _NAME_SIZE = 32
-
-  def __init__(self, data):
-    """Create a new instance.
-
-    Args:
-      data: the shared data access object
-    """
-    self.data = data
-    self.max_counters = data.IntAt(8)
-    self.max_threads = data.IntAt(12)
-    self.counter_names_offset = \
-        self._HEADER_SIZE + self.max_threads * (self._NAME_SIZE + 2 * 4)
-    self.counter_values_offset = \
-        self.counter_names_offset + self.max_counters * self._NAME_SIZE
-
-  def CountersInUse(self):
-    """Return the number of counters in active use."""
-    for i in xrange(self.max_counters):
-      if self.data.ByteAt(self.counter_names_offset + i * self._NAME_SIZE) == 0:
-        return i
-    return self.max_counters
-
-  def Counter(self, i):
-    """Return the i'th counter."""
-    return ChromeCounter(self.data,
-                         self.counter_names_offset + i * self._NAME_SIZE,
-                         self.counter_values_offset + i * self.max_threads * 4)
-
-
-def Main(data_file):
-  """Run the stats counter.
-
-  Args:
-    data_file: The counters file to monitor.
-  """
-  StatsViewer(data_file).Run()
-
-
-if __name__ == "__main__":
-  if len(sys.argv) != 2:
-    print "Usage: stats-viewer.py <stats data>|<test_shell pid>"
-    sys.exit(1)
-  Main(sys.argv[1])