lsst.ctrl.pool.pool Namespace Reference

Classes
class	PickleHolder
class	Comm
class	NoOp
class	Tags
class	Cache
class	SingletonMeta
	Metaclass to produce a singleton. More...
class	Debugger
class	ReductionThread
class	PoolNode
class	PoolMaster
class	PoolSlave
class	PoolWrapperMeta
class	PoolWrapper
class	Pool

Functions
def	unpickleInstanceMethod (obj, name)
def	pickleInstanceMethod (method)
def	unpickleFunction (moduleName, funcName)
def	pickleFunction (function)
def	getBatchType ()
def	setBatchType (batchType)
def	abortOnError (func)
def	guessPickleObj ()
def	pickleSniffer (abort=False)
def	catchPicklingError (func)
def	startPool (comm=None, root=0, killSlaves=True)
	Start a process pool. More...

Variables
string	NODE = "%s:%d" % (os.uname()[1], os.getpid())

Function Documentation

abortOnError()

def lsst.ctrl.pool.pool.abortOnError

(

func

)

Function decorator to throw an MPI abort on an unhandled exception

Definition at line 107 of file pool.py.

def abortOnError(func):
    """Function decorator to throw an MPI abort on an unhandled exception"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            sys.stderr.write("%s on %s in %s: %s\n" % (type(e).__name__, NODE, func.__name__, e))
            import traceback
            traceback.print_exc(file=sys.stderr)
            sys.stdout.flush()
            sys.stderr.flush()
            if getBatchType() is not None:
                mpi.COMM_WORLD.Abort(1)
            else:
                raise
    return wrapper
 
 

catchPicklingError()

def lsst.ctrl.pool.pool.catchPicklingError

(

func

)

Function decorator to catch errors in pickling and print something useful

Definition at line 234 of file pool.py.

def catchPicklingError(func):
    """Function decorator to catch errors in pickling and print something useful"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        with pickleSniffer(True):
            return func(*args, **kwargs)
    return wrapper
 
 

getBatchType()

def lsst.ctrl.pool.pool.getBatchType

(

)

Return a string giving the type of batch system in use

Definition at line 96 of file pool.py.

def getBatchType():
    """Return a string giving the type of batch system in use"""
    return _batchType
 
 

guessPickleObj()

def lsst.ctrl.pool.pool.guessPickleObj

(

)

Try to guess what's not pickling after an exception

This tends to work if the problem is coming from the
regular pickle module.  If it's coming from the bowels
of mpi4py, there's not much that can be done.

Definition at line 162 of file pool.py.

def guessPickleObj():
    """Try to guess what's not pickling after an exception
 
    This tends to work if the problem is coming from the
    regular pickle module.  If it's coming from the bowels
    of mpi4py, there's not much that can be done.
    """
    import sys
    excType, excValue, tb = sys.exc_info()
    # Build a stack of traceback elements
    stack = []
    while tb:
        stack.append(tb)
        tb = tb.tb_next
 
    try:
        # This is the code version of a my way to find what's not pickling in pdb.
        # This should work if it's coming from the regular pickle module, and they
        # haven't changed the variable names since python 2.7.3.
        return stack[-2].tb_frame.f_locals["obj"]
    except Exception:
        return None
 
 
@contextmanager

pickleFunction()

def lsst.ctrl.pool.pool.pickleFunction

(

function

)

Pickle a function

This assumes that we can recreate the function object by grabbing
it from the proper module.  This may be violated if the function
is a lambda or in __main__.  In that case, I recommend recasting
the function as an object with a __call__ method.

Another problematic case may be a wrapped (e.g., decorated) method
in a class: the 'method' is then a function, and recreating it is
not as easy as we assume here.

Definition at line 71 of file pool.py.

def pickleFunction(function):
    """Pickle a function
 
    This assumes that we can recreate the function object by grabbing
    it from the proper module.  This may be violated if the function
    is a lambda or in __main__.  In that case, I recommend recasting
    the function as an object with a __call__ method.
 
    Another problematic case may be a wrapped (e.g., decorated) method
    in a class: the 'method' is then a function, and recreating it is
    not as easy as we assume here.
    """
    moduleName = function.__module__
    funcName = function.__name__
    return unpickleFunction, (moduleName, funcName)
 
 
copyreg.pickle(types.FunctionType, pickleFunction)
 
try:
    _batchType

pickleInstanceMethod()

def lsst.ctrl.pool.pool.pickleInstanceMethod

(

method

)

Pickle an instance method

The instance method is divided into the object and the
method name.

Definition at line 46 of file pool.py.

def pickleInstanceMethod(method):
    """Pickle an instance method
 
    The instance method is divided into the object and the
    method name.
    """
    obj = method.__self__
    name = method.__name__
    return unpickleInstanceMethod, (obj, name)
 
 
copyreg.pickle(types.MethodType, pickleInstanceMethod)
 
 

pickleSniffer()

def lsst.ctrl.pool.pool.pickleSniffer

(

abort = False

)

Context manager to sniff out pickle problems

If there's a pickle error, you're normally told what the problem
class is.  However, all SWIG objects are reported as "SwigPyObject".
In order to figure out which actual SWIG-ed class is causing
problems, we need to go digging.

Use like this:

    with pickleSniffer():
        someOperationInvolvingPickle()

If 'abort' is True, will call MPI abort in the event of problems.

Definition at line 187 of file pool.py.

def pickleSniffer(abort=False):
    """Context manager to sniff out pickle problems
 
    If there's a pickle error, you're normally told what the problem
    class is.  However, all SWIG objects are reported as "SwigPyObject".
    In order to figure out which actual SWIG-ed class is causing
    problems, we need to go digging.
 
    Use like this:
 
        with pickleSniffer():
            someOperationInvolvingPickle()
 
    If 'abort' is True, will call MPI abort in the event of problems.
    """
    try:
        yield
    except Exception as e:
        if "SwigPyObject" not in str(e) or "pickle" not in str(e):
            raise
        import sys
        import traceback
 
        sys.stderr.write("Pickling error detected: %s\n" % e)
        traceback.print_exc(file=sys.stderr)
        obj = guessPickleObj()
        heldObj = PickleHolder().obj
        if obj is None and heldObj is not None:
            # Try to reproduce using what was being pickled using the regular pickle module,
            # so we've got a chance of figuring out what the problem is.
            import pickle
            try:
                pickle.dumps(heldObj)
                sys.stderr.write("Hmmm, that's strange: no problem with pickling held object?!?!\n")
            except Exception:
                obj = guessPickleObj()
        if obj is None:
            sys.stderr.write("Unable to determine class causing pickle problems.\n")
        else:
            sys.stderr.write("Object that could not be pickled: %s\n" % obj)
        if abort:
            if getBatchType() is not None:
                mpi.COMM_WORLD.Abort(1)
            else:
                sys.exit(1)
 
 

setBatchType()

def lsst.ctrl.pool.pool.setBatchType

(

batchType

)

Return a string giving the type of batch system in use

Definition at line 101 of file pool.py.

def setBatchType(batchType):
    """Return a string giving the type of batch system in use"""
    global _batchType
    _batchType = batchType
 
 

startPool()

def lsst.ctrl.pool.pool.startPool	(		comm = None,
			root = 0,
			killSlaves = True
	)

Start a process pool.

Returns a PoolMaster object for the master node.
Slave nodes are run and then optionally killed.

If you elect not to kill the slaves, note that they
will emerge at the point this function was called,
which is likely very different from the point the
master is at, so it will likely be necessary to put
in some rank dependent code (e.g., look at the 'rank'
attribute of the returned pools).

Note that the pool objects should be deleted (either
by going out of scope or explicit 'del') before program
termination to avoid a segmentation fault.

@param comm: MPI communicator
@param root: Rank of root/master node
@param killSlaves: Kill slaves on completion?

Definition at line 1216 of file pool.py.

def startPool(comm=None, root=0, killSlaves=True):
    """!Start a process pool.
 
    Returns a PoolMaster object for the master node.
    Slave nodes are run and then optionally killed.
 
    If you elect not to kill the slaves, note that they
    will emerge at the point this function was called,
    which is likely very different from the point the
    master is at, so it will likely be necessary to put
    in some rank dependent code (e.g., look at the 'rank'
    attribute of the returned pools).
 
    Note that the pool objects should be deleted (either
    by going out of scope or explicit 'del') before program
    termination to avoid a segmentation fault.
 
    @param comm: MPI communicator
    @param root: Rank of root/master node
    @param killSlaves: Kill slaves on completion?
    """
    if comm is None:
        comm = Comm()
    if comm.rank == root:
        return PoolMaster(comm, root=root)
    slave = PoolSlave(comm, root=root)
    slave.run()
    if killSlaves:
        del slave  # Required to prevent segmentation fault on exit
        sys.exit()
    return slave

unpickleFunction()

def lsst.ctrl.pool.pool.unpickleFunction	(		moduleName,
			funcName
	)

Unpickle a function

This has to be a named function rather than a lambda because
pickle needs to find it.

Definition at line 60 of file pool.py.

def unpickleFunction(moduleName, funcName):
    """Unpickle a function
 
    This has to be a named function rather than a lambda because
    pickle needs to find it.
    """
    import importlib
    module = importlib.import_module(moduleName)
    return getattr(module, funcName)
 
 

unpickleInstanceMethod()

def lsst.ctrl.pool.pool.unpickleInstanceMethod	(		obj,
			name
	)

Unpickle an instance method

This has to be a named function rather than a lambda because
pickle needs to find it.

Definition at line 37 of file pool.py.

def unpickleInstanceMethod(obj, name):
    """Unpickle an instance method
 
    This has to be a named function rather than a lambda because
    pickle needs to find it.
    """
    return getattr(obj, name)
 
 

Variable Documentation

NODE

string lsst.ctrl.pool.pool.NODE = "%s:%d" % (os.uname()[1], os.getpid())

Definition at line 34 of file pool.py.