lsst.ctrl.pool.pool Namespace Reference

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

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 108 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 235 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 97 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 163 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 72 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 47 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 188 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 102 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.

Process Pool

Use this class to automatically provide 'context' to
the PoolMaster class.  If you want to call functions
that don't take a 'cache' object, use the PoolMaster
class directly, and specify context=None.

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.

Parameters

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

Definition at line 1217 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 61 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 38 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 35 of file pool.py.

---

Generated on Thu Aug 8 2019 20:21:06 for LSSTApplications by   1.8.13