therubyracer 0.9.0beta4 → 0.9.0beta5

data/ext/v8/upstream/scons/engine/SCons/Job.py

@@ -1,435 +0,0 @@
-"""SCons.Job
-
-This module defines the Serial and Parallel classes that execute tasks to
-complete a build. The Jobs class provides a higher level interface to start,
-stop, and wait on jobs.
-
-"""
-
-#
-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 The SCons Foundation
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
-# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-
-__revision__ = "src/engine/SCons/Job.py 4629 2010/01/17 22:23:21 scons"
-
-import os
-import signal
-
-import SCons.Errors
-
-# The default stack size (in kilobytes) of the threads used to execute
-# jobs in parallel.
-#
-# We use a stack size of 256 kilobytes. The default on some platforms
-# is too large and prevents us from creating enough threads to fully
-# parallelized the build. For example, the default stack size on linux
-# is 8 MBytes.
-
-explicit_stack_size = None
-default_stack_size = 256
-
-interrupt_msg = 'Build interrupted.'
-
-
-class InterruptState:
-   def __init__(self):
-       self.interrupted = False
-
-   def set(self):
-       self.interrupted = True
-
-   def __call__(self):
-       return self.interrupted
-
-
-class Jobs:
-    """An instance of this class initializes N jobs, and provides
-    methods for starting, stopping, and waiting on all N jobs.
-    """
-
-    def __init__(self, num, taskmaster):
-        """
-        create 'num' jobs using the given taskmaster.
-
-        If 'num' is 1 or less, then a serial job will be used,
-        otherwise a parallel job with 'num' worker threads will
-        be used.
-
-        The 'num_jobs' attribute will be set to the actual number of jobs
-        allocated.  If more than one job is requested but the Parallel
-        class can't do it, it gets reset to 1.  Wrapping interfaces that
-        care should check the value of 'num_jobs' after initialization.
-        """
-
-        self.job = None
-        if num > 1:
-            stack_size = explicit_stack_size
-            if stack_size is None:
-                stack_size = default_stack_size
-                
-            try:
-                self.job = Parallel(taskmaster, num, stack_size)
-                self.num_jobs = num
-            except NameError:
-                pass
-        if self.job is None:
-            self.job = Serial(taskmaster)
-            self.num_jobs = 1
-
-    def run(self, postfunc=lambda: None):
-        """Run the jobs.
-
-        postfunc() will be invoked after the jobs has run. It will be
-        invoked even if the jobs are interrupted by a keyboard
-        interrupt (well, in fact by a signal such as either SIGINT,
-        SIGTERM or SIGHUP). The execution of postfunc() is protected
-        against keyboard interrupts and is guaranteed to run to
-        completion."""
-        self._setup_sig_handler()
-        try:
-            self.job.start()
-        finally:
-            postfunc()
-            self._reset_sig_handler()
-
-    def were_interrupted(self):
-        """Returns whether the jobs were interrupted by a signal."""
-        return self.job.interrupted()
-
-    def _setup_sig_handler(self):
-        """Setup an interrupt handler so that SCons can shutdown cleanly in
-        various conditions:
-
-          a) SIGINT: Keyboard interrupt
-          b) SIGTERM: kill or system shutdown
-          c) SIGHUP: Controlling shell exiting
-
-        We handle all of these cases by stopping the taskmaster. It
-        turns out that it very difficult to stop the build process
-        by throwing asynchronously an exception such as
-        KeyboardInterrupt. For example, the python Condition
-        variables (threading.Condition) and Queue's do not seem to
-        asynchronous-exception-safe. It would require adding a whole
-        bunch of try/finally block and except KeyboardInterrupt all
-        over the place.
-
-        Note also that we have to be careful to handle the case when
-        SCons forks before executing another process. In that case, we
-        want the child to exit immediately.
-        """
-        def handler(signum, stack, self=self, parentpid=os.getpid()):
-            if os.getpid() == parentpid:
-                self.job.taskmaster.stop()
-                self.job.interrupted.set()
-            else:
-                os._exit(2)
-
-        self.old_sigint  = signal.signal(signal.SIGINT, handler)
-        self.old_sigterm = signal.signal(signal.SIGTERM, handler)
-        try:
-            self.old_sighup = signal.signal(signal.SIGHUP, handler)
-        except AttributeError:
-            pass
-
-    def _reset_sig_handler(self):
-        """Restore the signal handlers to their previous state (before the
-         call to _setup_sig_handler()."""
-
-        signal.signal(signal.SIGINT, self.old_sigint)
-        signal.signal(signal.SIGTERM, self.old_sigterm)
-        try:
-            signal.signal(signal.SIGHUP, self.old_sighup)
-        except AttributeError:
-            pass
-
-class Serial:
-    """This class is used to execute tasks in series, and is more efficient
-    than Parallel, but is only appropriate for non-parallel builds. Only
-    one instance of this class should be in existence at a time.
-
-    This class is not thread safe.
-    """
-
-    def __init__(self, taskmaster):
-        """Create a new serial job given a taskmaster. 
-
-        The taskmaster's next_task() method should return the next task
-        that needs to be executed, or None if there are no more tasks. The
-        taskmaster's executed() method will be called for each task when it
-        is successfully executed or failed() will be called if it failed to
-        execute (e.g. execute() raised an exception)."""
-        
-        self.taskmaster = taskmaster
-        self.interrupted = InterruptState()
-
-    def start(self):
-        """Start the job. This will begin pulling tasks from the taskmaster
-        and executing them, and return when there are no more tasks. If a task
-        fails to execute (i.e. execute() raises an exception), then the job will
-        stop."""
-        
-        while 1:
-            task = self.taskmaster.next_task()
-
-            if task is None:
-                break
-
-            try:
-                task.prepare()
-                if task.needs_execute():
-                    task.execute()
-            except:
-                if self.interrupted():
-                    try:
-                        raise SCons.Errors.BuildError(
-                            task.targets[0], errstr=interrupt_msg)
-                    except:
-                        task.exception_set()
-                else:
-                    task.exception_set()
-
-                # Let the failed() callback function arrange for the
-                # build to stop if that's appropriate.
-                task.failed()
-            else:
-                task.executed()
-
-            task.postprocess()
-        self.taskmaster.cleanup()
-
-
-# Trap import failure so that everything in the Job module but the
-# Parallel class (and its dependent classes) will work if the interpreter
-# doesn't support threads.
-try:
-    import Queue
-    import threading
-except ImportError:
-    pass
-else:
-    class Worker(threading.Thread):
-        """A worker thread waits on a task to be posted to its request queue,
-        dequeues the task, executes it, and posts a tuple including the task
-        and a boolean indicating whether the task executed successfully. """
-
-        def __init__(self, requestQueue, resultsQueue, interrupted):
-            threading.Thread.__init__(self)
-            self.setDaemon(1)
-            self.requestQueue = requestQueue
-            self.resultsQueue = resultsQueue
-            self.interrupted = interrupted
-            self.start()
-
-        def run(self):
-            while 1:
-                task = self.requestQueue.get()
-
-                if task is None:
-                    # The "None" value is used as a sentinel by
-                    # ThreadPool.cleanup().  This indicates that there
-                    # are no more tasks, so we should quit.
-                    break
-
-                try:
-                    if self.interrupted():
-                        raise SCons.Errors.BuildError(
-                            task.targets[0], errstr=interrupt_msg)
-                    task.execute()
-                except:
-                    task.exception_set()
-                    ok = False
-                else:
-                    ok = True
-
-                self.resultsQueue.put((task, ok))
-
-    class ThreadPool:
-        """This class is responsible for spawning and managing worker threads."""
-
-        def __init__(self, num, stack_size, interrupted):
-            """Create the request and reply queues, and 'num' worker threads.
-            
-            One must specify the stack size of the worker threads. The
-            stack size is specified in kilobytes.
-            """
-            self.requestQueue = Queue.Queue(0)
-            self.resultsQueue = Queue.Queue(0)
-
-            try:
-                prev_size = threading.stack_size(stack_size*1024) 
-            except AttributeError, e:
-                # Only print a warning if the stack size has been
-                # explicitly set.
-                if not explicit_stack_size is None:
-                    msg = "Setting stack size is unsupported by this version of Python:\n    " + \
-                        e.args[0]
-                    SCons.Warnings.warn(SCons.Warnings.StackSizeWarning, msg)
-            except ValueError, e:
-                msg = "Setting stack size failed:\n    " + str(e)
-                SCons.Warnings.warn(SCons.Warnings.StackSizeWarning, msg)
-
-            # Create worker threads
-            self.workers = []
-            for _ in range(num):
-                worker = Worker(self.requestQueue, self.resultsQueue, interrupted)
-                self.workers.append(worker)
-
-            # Once we drop Python 1.5 we can change the following to:
-            #if 'prev_size' in locals():
-            if 'prev_size' in locals().keys():
-                threading.stack_size(prev_size)
-
-        def put(self, task):
-            """Put task into request queue."""
-            self.requestQueue.put(task)
-
-        def get(self):
-            """Remove and return a result tuple from the results queue."""
-            return self.resultsQueue.get()
-
-        def preparation_failed(self, task):
-            self.resultsQueue.put((task, False))
-
-        def cleanup(self):
-            """
-            Shuts down the thread pool, giving each worker thread a
-            chance to shut down gracefully.
-            """
-            # For each worker thread, put a sentinel "None" value
-            # on the requestQueue (indicating that there's no work
-            # to be done) so that each worker thread will get one and
-            # terminate gracefully.
-            for _ in self.workers:
-                self.requestQueue.put(None)
-
-            # Wait for all of the workers to terminate.
-            # 
-            # If we don't do this, later Python versions (2.4, 2.5) often
-            # seem to raise exceptions during shutdown.  This happens
-            # in requestQueue.get(), as an assertion failure that
-            # requestQueue.not_full is notified while not acquired,
-            # seemingly because the main thread has shut down (or is
-            # in the process of doing so) while the workers are still
-            # trying to pull sentinels off the requestQueue.
-            #
-            # Normally these terminations should happen fairly quickly,
-            # but we'll stick a one-second timeout on here just in case
-            # someone gets hung.
-            for worker in self.workers:
-                worker.join(1.0)
-            self.workers = []
-
-    class Parallel:
-        """This class is used to execute tasks in parallel, and is somewhat 
-        less efficient than Serial, but is appropriate for parallel builds.
-
-        This class is thread safe.
-        """
-
-        def __init__(self, taskmaster, num, stack_size):
-            """Create a new parallel job given a taskmaster.
-
-            The taskmaster's next_task() method should return the next
-            task that needs to be executed, or None if there are no more
-            tasks. The taskmaster's executed() method will be called
-            for each task when it is successfully executed or failed()
-            will be called if the task failed to execute (i.e. execute()
-            raised an exception).
-
-            Note: calls to taskmaster are serialized, but calls to
-            execute() on distinct tasks are not serialized, because
-            that is the whole point of parallel jobs: they can execute
-            multiple tasks simultaneously. """
-
-            self.taskmaster = taskmaster
-            self.interrupted = InterruptState()
-            self.tp = ThreadPool(num, stack_size, self.interrupted)
-
-            self.maxjobs = num
-
-        def start(self):
-            """Start the job. This will begin pulling tasks from the
-            taskmaster and executing them, and return when there are no
-            more tasks. If a task fails to execute (i.e. execute() raises
-            an exception), then the job will stop."""
-
-            jobs = 0
-            
-            while 1:
-                # Start up as many available tasks as we're
-                # allowed to.
-                while jobs < self.maxjobs:
-                    task = self.taskmaster.next_task()
-                    if task is None:
-                        break
-
-                    try:
-                        # prepare task for execution
-                        task.prepare()
-                    except:
-                        task.exception_set()
-                        task.failed()
-                        task.postprocess()
-                    else:
-                        if task.needs_execute():
-                            # dispatch task
-                            self.tp.put(task)
-                            jobs = jobs + 1
-                        else:
-                            task.executed()
-                            task.postprocess()
-
-                if not task and not jobs: break
-
-                # Let any/all completed tasks finish up before we go
-                # back and put the next batch of tasks on the queue.
-                while 1:
-                    task, ok = self.tp.get()
-                    jobs = jobs - 1
-
-                    if ok:
-                        task.executed()
-                    else:
-                        if self.interrupted():
-                            try:
-                                raise SCons.Errors.BuildError(
-                                    task.targets[0], errstr=interrupt_msg)
-                            except:
-                                task.exception_set()
-
-                        # Let the failed() callback function arrange
-                        # for the build to stop if that's appropriate.
-                        task.failed()
-
-                    task.postprocess()
-
-                    if self.tp.resultsQueue.empty():
-                        break
-
-            self.tp.cleanup()
-            self.taskmaster.cleanup()
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4:

data/ext/v8/upstream/scons/engine/SCons/Memoize.py

@@ -1,292 +0,0 @@
-#
-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 The SCons Foundation
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
-# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-
-__revision__ = "src/engine/SCons/Memoize.py 4629 2010/01/17 22:23:21 scons"
-
-__doc__ = """Memoizer
-
-A metaclass implementation to count hits and misses of the computed
-values that various methods cache in memory.
-
-Use of this modules assumes that wrapped methods be coded to cache their
-values in a consistent way.  Here is an example of wrapping a method
-that returns a computed value, with no input parameters:
-
-    memoizer_counters = []                                      # Memoization
-
-    memoizer_counters.append(SCons.Memoize.CountValue('foo'))   # Memoization
-
-    def foo(self):
-
-        try:                                                    # Memoization
-            return self._memo['foo']                            # Memoization
-        except KeyError:                                        # Memoization
-            pass                                                # Memoization
-
-        result = self.compute_foo_value()
-
-        self._memo['foo'] = result                              # Memoization
-
-        return result
-
-Here is an example of wrapping a method that will return different values
-based on one or more input arguments:
-
-    def _bar_key(self, argument):                               # Memoization
-        return argument                                         # Memoization
-
-    memoizer_counters.append(SCons.Memoize.CountDict('bar', _bar_key)) # Memoization
-
-    def bar(self, argument):
-
-        memo_key = argument                                     # Memoization
-        try:                                                    # Memoization
-            memo_dict = self._memo['bar']                       # Memoization
-        except KeyError:                                        # Memoization
-            memo_dict = {}                                      # Memoization
-            self._memo['dict'] = memo_dict                      # Memoization
-        else:                                                   # Memoization
-            try:                                                # Memoization
-                return memo_dict[memo_key]                      # Memoization
-            except KeyError:                                    # Memoization
-                pass                                            # Memoization
-
-        result = self.compute_bar_value(argument)
-
-        memo_dict[memo_key] = result                            # Memoization
-
-        return result
-
-At one point we avoided replicating this sort of logic in all the methods
-by putting it right into this module, but we've moved away from that at
-present (see the "Historical Note," below.).
-
-Deciding what to cache is tricky, because different configurations
-can have radically different performance tradeoffs, and because the
-tradeoffs involved are often so non-obvious.  Consequently, deciding
-whether or not to cache a given method will likely be more of an art than
-a science, but should still be based on available data from this module.
-Here are some VERY GENERAL guidelines about deciding whether or not to
-cache return values from a method that's being called a lot:
-
-    --  The first question to ask is, "Can we change the calling code
-        so this method isn't called so often?"  Sometimes this can be
-        done by changing the algorithm.  Sometimes the *caller* should
-        be memoized, not the method you're looking at.
-
-    --  The memoized function should be timed with multiple configurations
-        to make sure it doesn't inadvertently slow down some other
-        configuration.
-
-    --  When memoizing values based on a dictionary key composed of
-        input arguments, you don't need to use all of the arguments
-        if some of them don't affect the return values.
-
-Historical Note:  The initial Memoizer implementation actually handled
-the caching of values for the wrapped methods, based on a set of generic
-algorithms for computing hashable values based on the method's arguments.
-This collected caching logic nicely, but had two drawbacks:
-
-    Running arguments through a generic key-conversion mechanism is slower
-    (and less flexible) than just coding these things directly.  Since the
-    methods that need memoized values are generally performance-critical,
-    slowing them down in order to collect the logic isn't the right
-    tradeoff.
-
-    Use of the memoizer really obscured what was being called, because
-    all the memoized methods were wrapped with re-used generic methods.
-    This made it more difficult, for example, to use the Python profiler
-    to figure out how to optimize the underlying methods.
-"""
-
-import new
-
-# A flag controlling whether or not we actually use memoization.
-use_memoizer = None
-
-CounterList = []
-
-class Counter:
-    """
-    Base class for counting memoization hits and misses.
-
-    We expect that the metaclass initialization will have filled in
-    the .name attribute that represents the name of the function
-    being counted.
-    """
-    def __init__(self, method_name):
-        """
-        """
-        self.method_name = method_name
-        self.hit = 0
-        self.miss = 0
-        CounterList.append(self)
-    def display(self):
-        fmt = "    %7d hits %7d misses    %s()"
-        print fmt % (self.hit, self.miss, self.name)
-    def __cmp__(self, other):
-        try:
-            return cmp(self.name, other.name)
-        except AttributeError:
-            return 0
-
-class CountValue(Counter):
-    """
-    A counter class for simple, atomic memoized values.
-
-    A CountValue object should be instantiated in a class for each of
-    the class's methods that memoizes its return value by simply storing
-    the return value in its _memo dictionary.
-
-    We expect that the metaclass initialization will fill in the
-    .underlying_method attribute with the method that we're wrapping.
-    We then call the underlying_method method after counting whether
-    its memoized value has already been set (a hit) or not (a miss).
-    """
-    def __call__(self, *args, **kw):
-        obj = args[0]
-        if obj._memo.has_key(self.method_name):
-            self.hit = self.hit + 1
-        else:
-            self.miss = self.miss + 1
-        return apply(self.underlying_method, args, kw)
-
-class CountDict(Counter):
-    """
-    A counter class for memoized values stored in a dictionary, with
-    keys based on the method's input arguments.
-
-    A CountDict object is instantiated in a class for each of the
-    class's methods that memoizes its return value in a dictionary,
-    indexed by some key that can be computed from one or more of
-    its input arguments.
-
-    We expect that the metaclass initialization will fill in the
-    .underlying_method attribute with the method that we're wrapping.
-    We then call the underlying_method method after counting whether the
-    computed key value is already present in the memoization dictionary
-    (a hit) or not (a miss).
-    """
-    def __init__(self, method_name, keymaker):
-        """
-        """
-        Counter.__init__(self, method_name)
-        self.keymaker = keymaker
-    def __call__(self, *args, **kw):
-        obj = args[0]
-        try:
-            memo_dict = obj._memo[self.method_name]
-        except KeyError:
-            self.miss = self.miss + 1
-        else:
-            key = apply(self.keymaker, args, kw)
-            if memo_dict.has_key(key):
-                self.hit = self.hit + 1
-            else:
-                self.miss = self.miss + 1
-        return apply(self.underlying_method, args, kw)
-
-class Memoizer:
-    """Object which performs caching of method calls for its 'primary'
-    instance."""
-
-    def __init__(self):
-        pass
-
-# Find out if we support metaclasses (Python 2.2 and later).
-
-class M:
-    def __init__(cls, name, bases, cls_dict):
-        cls.use_metaclass = 1
-        def fake_method(self):
-            pass
-        new.instancemethod(fake_method, None, cls)
-
-try:
-    class A:
-        __metaclass__ = M
-
-    use_metaclass = A.use_metaclass
-except AttributeError:
-    use_metaclass = None
-    reason = 'no metaclasses'
-except TypeError:
-    use_metaclass = None
-    reason = 'new.instancemethod() bug'
-else:
-    del A
-
-del M
-
-if not use_metaclass:
-
-    def Dump(title):
-        pass
-
-    try:
-        class Memoized_Metaclass(type):
-            # Just a place-holder so pre-metaclass Python versions don't
-            # have to have special code for the Memoized classes.
-            pass
-    except TypeError:
-        class Memoized_Metaclass:
-            # A place-holder so pre-metaclass Python versions don't
-            # have to have special code for the Memoized classes.
-            pass
-
-    def EnableMemoization():
-        import SCons.Warnings
-        msg = 'memoization is not supported in this version of Python (%s)'
-        raise SCons.Warnings.NoMetaclassSupportWarning, msg % reason
-
-else:
-
-    def Dump(title=None):
-        if title:
-            print title
-        CounterList.sort()
-        for counter in CounterList:
-            counter.display()
-
-    class Memoized_Metaclass(type):
-        def __init__(cls, name, bases, cls_dict):
-            super(Memoized_Metaclass, cls).__init__(name, bases, cls_dict)
-
-            for counter in cls_dict.get('memoizer_counters', []):
-                method_name = counter.method_name
-
-                counter.name = cls.__name__ + '.' + method_name
-                counter.underlying_method = cls_dict[method_name]
-
-                replacement_method = new.instancemethod(counter, None, cls)
-                setattr(cls, method_name, replacement_method)
-
-    def EnableMemoization():
-        global use_memoizer
-        use_memoizer = 1
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4: