This repository has been archived by the owner. It is now read-only.
optimise python code using staticness assertions
Python
Switch branches/tags
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
promise
.gitignore update for python2.7 compatability Apr 14, 2011
ChangeLog.txt
IDEAS.txt add IDEAS.txt listing some ideas for the future Jan 14, 2010
LICENSE.txt switch from BSD to MIT license Dec 8, 2009
MANIFEST.in added ChangeLog Jan 6, 2010
README.md
setup.py

README.md

Status: Unmaintained

No Maintenance Intended

I am no longer actively maintaining this project.

promise: bytecode optimisation using staticness assertions.

This is a module for applying some simple optimisations to function bytecode. By promising that a function doesn't do certain things at run-time, it's possible to apply optimisations that are not legal in the general case.

As a simple example, it's possible to promise that a function doesn't modify (or care if anyone else modifies) any builtin functions by decorating it thus:

@promise.constant(__builtins__)
def function():
    ...

Such a promise will allow the builtins to be stored as direct object references in the function bytecode, avoiding name lookups during function execution.

As another example, it's possible to promise that a function is pure; i.e. that it's a simple algorithm for mapping input values to an output value:

@promise.pure()
def calculate(a,b):
    return 2*a*a + 3*b + 7

If a pure function is then used by another function as a constant, it can be directly inlined into the bytecode to avoid the overhead of a function call:

@promise.constant(("calculate",))
def aggregate(pairs):
    #  calculate() is a pure constant, so it will be inlined here.
    return sum(calculate(a,b) for (a,b) in pairs)

The currently available promises are:

* invariant(names):  promise that variables having the given names will
                     not change value during execution of the function.

* constant(names):   promise that variables having the given names will
                     always refer to the same object, across all calls
                     to the function.

* pure():   promise that the function is a transparent mapping from inputs
            to outputs; this opens up the possibility of inling it directly
            into other functions.

* sensible():   promise that the function is "sensibly behaved".  All
                builtins and module-level functions are considered
                constant; all other module-level names are considered
                invariant.

Promise is built on Noam Raphael's fantastic "byteplay" module. It used be be bundled as part of promise because it needed some patches to work with newer versions of Python; now it's just bundled for your convenience.