lsst.ctrl.pool.pool.PoolMaster Class Reference

Inheritance diagram for lsst.ctrl.pool.pool.PoolMaster:

Public Member Functions
def	__init__ (self, *args, **kwargs)
def	__del__ (self)
def	log (self, msg, *args)
def	command (self, cmd)
def	map (self, context, func, dataList, *args, **kwargs)
	Scatter work to slaves and gather the results. More...
def	reduce (self, context, reducer, func, dataList, *args, **kwargs)
	Scatter work to slaves and reduce the results. More...
def	mapNoBalance (self, context, func, dataList, *args, **kwargs)
	Scatter work to slaves and gather the results. More...
def	reduceNoBalance (self, context, reducer, func, dataList, *args, **kwargs)
	Scatter work to slaves and reduce the results. More...
def	mapToPrevious (self, context, func, dataList, *args, **kwargs)
	Scatter work to the same target as before. More...
def	reduceToPrevious (self, context, reducer, func, dataList, *args, **kwargs)
	Reduction where work goes to the same target as before. More...
def	storeSet (self, context, **kwargs)
	Store data on slave for a particular context. More...
def	storeDel (self, context, *nameList)
def	storeClear (self, context)
def	cacheClear (self, context)
def	cacheList (self, context)
def	storeList (self, context)
def	exit (self)
def	isMaster (self)
def	__call__ (cls, *args, **kwargs)

Public Attributes
	root
	size
	comm
	rank
	debugger
	node

Detailed Description

Master node instance of MPI process pool

Only the master node should instantiate this.

WARNING: You should not let a pool instance hang around at program
termination, as the garbage collection behaves differently, and may
cause a segmentation fault (signal 11).

Definition at line 626 of file pool.py.

Constructor & Destructor Documentation

__init__()

def lsst.ctrl.pool.pool.PoolMaster.__init__	(		self,
		*	args,
		**	kwargs
	)

Definition at line 636 of file pool.py.

    def __init__(self, *args, **kwargs):
        super(PoolMaster, self).__init__(*args, **kwargs)
        assert self.root == self.rank, "This is the master node"
 

__del__()

def lsst.ctrl.pool.pool.PoolMaster.__del__

(

self

)

Ensure slaves exit when we're done

Definition at line 640 of file pool.py.

    def __del__(self):
        """Ensure slaves exit when we're done"""
        self.exit()
 

Member Function Documentation

__call__()

def lsst.ctrl.pool.pool.SingletonMeta.__call__ (   cls, *  args, **  kwargs  )

inherited

Definition at line 387 of file pool.py.

    def __call__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super(SingletonMeta, cls).__call__(*args, **kwargs)
        return cls._instance
 
 

cacheClear()

def lsst.ctrl.pool.pool.PoolMaster.cacheClear	(		self,
			context
	)

Reset cache for a particular context on master and slaves

Reimplemented from lsst.ctrl.pool.pool.PoolNode.

Definition at line 1023 of file pool.py.

    def cacheClear(self, context):
        """Reset cache for a particular context on master and slaves"""
        super(PoolMaster, self).cacheClear(context)
        self.command("cacheClear")
        self.comm.broadcast(context, root=self.root)
 

cacheList()

def lsst.ctrl.pool.pool.PoolMaster.cacheList	(		self,
			context
	)

List cache contents for a particular context on master and slaves

Reimplemented from lsst.ctrl.pool.pool.PoolNode.

Definition at line 1030 of file pool.py.

    def cacheList(self, context):
        """List cache contents for a particular context on master and slaves"""
        super(PoolMaster, self).cacheList(context)
        self.command("cacheList")
        self.comm.broadcast(context, root=self.root)
 

command()

def lsst.ctrl.pool.pool.PoolMaster.command	(		self,
			cmd
	)

Send command to slaves

A command is the name of the PoolSlave method they should run.

Definition at line 648 of file pool.py.

    def command(self, cmd):
        """Send command to slaves
 
        A command is the name of the PoolSlave method they should run.
        """
        self.log("command", cmd)
        self.comm.broadcast(cmd, root=self.root)
 

exit()

def lsst.ctrl.pool.pool.PoolMaster.exit

(

self

)

Command slaves to exit

Definition at line 1043 of file pool.py.

    def exit(self):
        """Command slaves to exit"""
        self.command("exit")
 
 

isMaster()

def lsst.ctrl.pool.pool.PoolNode.isMaster (   self )

inherited

Definition at line 526 of file pool.py.

    def isMaster(self):
        return self.rank == self.root
 

log()

def lsst.ctrl.pool.pool.PoolMaster.log	(		self,
			msg,
		*	args
	)

Log a debugging message

Reimplemented from lsst.ctrl.pool.pool.PoolNode.

Definition at line 644 of file pool.py.

    def log(self, msg, *args):
        """Log a debugging message"""
        self.debugger.log("Master", msg, *args)
 

map()

def lsst.ctrl.pool.pool.PoolMaster.map	(		self,
			context,
			func,
			dataList,
		*	args,
		**	kwargs
	)

Scatter work to slaves and gather the results.

    Work is distributed dynamically, so that slaves that finish
    quickly will receive more work.

    Each slave applies the function to the data they're provided.
    The slaves may optionally be passed a cache instance, which
    they can use to store data for subsequent executions (to ensure
    subsequent data is distributed in the same pattern as before,
    use the 'mapToPrevious' method).  The cache also contains
    data that has been stored on the slaves.

    The 'func' signature should be func(cache, data, *args, **kwargs)
    if 'context' is non-None; otherwise func(data, *args, **kwargs).

    @param context: Namespace for cache
    @param func: function for slaves to run; must be picklable
    @param dataList: List of data to distribute to slaves; must be picklable
    @param args: List of constant arguments
    @param kwargs: Dict of constant arguments
    @return list of results from applying 'func' to dataList

Definition at line 656 of file pool.py.

    def map(self, context, func, dataList, *args, **kwargs):
        """!Scatter work to slaves and gather the results
 
        Work is distributed dynamically, so that slaves that finish
        quickly will receive more work.
 
        Each slave applies the function to the data they're provided.
        The slaves may optionally be passed a cache instance, which
        they can use to store data for subsequent executions (to ensure
        subsequent data is distributed in the same pattern as before,
        use the 'mapToPrevious' method).  The cache also contains
        data that has been stored on the slaves.
 
        The 'func' signature should be func(cache, data, *args, **kwargs)
        if 'context' is non-None; otherwise func(data, *args, **kwargs).
 
        @param context: Namespace for cache
        @param func: function for slaves to run; must be picklable
        @param dataList: List of data to distribute to slaves; must be picklable
        @param args: List of constant arguments
        @param kwargs: Dict of constant arguments
        @return list of results from applying 'func' to dataList
        """
        return self.reduce(context, None, func, dataList, *args, **kwargs)
 

mapNoBalance()

def lsst.ctrl.pool.pool.PoolMaster.mapNoBalance	(		self,
			context,
			func,
			dataList,
		*	args,
		**	kwargs
	)

Scatter work to slaves and gather the results.

    Work is distributed statically, so there is no load balancing.

    Each slave applies the function to the data they're provided.
    The slaves may optionally be passed a cache instance, which
    they can store data in for subsequent executions (to ensure
    subsequent data is distributed in the same pattern as before,
    use the 'mapToPrevious' method).  The cache also contains
    data that has been stored on the slaves.

    The 'func' signature should be func(cache, data, *args, **kwargs)
    if 'context' is true; otherwise func(data, *args, **kwargs).

    @param context: Namespace for cache
    @param func: function for slaves to run; must be picklable
    @param dataList: List of data to distribute to slaves; must be picklable
    @param args: List of constant arguments
    @param kwargs: Dict of constant arguments
    @return list of results from applying 'func' to dataList

Definition at line 763 of file pool.py.

    def mapNoBalance(self, context, func, dataList, *args, **kwargs):
        """!Scatter work to slaves and gather the results
 
        Work is distributed statically, so there is no load balancing.
 
        Each slave applies the function to the data they're provided.
        The slaves may optionally be passed a cache instance, which
        they can store data in for subsequent executions (to ensure
        subsequent data is distributed in the same pattern as before,
        use the 'mapToPrevious' method).  The cache also contains
        data that has been stored on the slaves.
 
        The 'func' signature should be func(cache, data, *args, **kwargs)
        if 'context' is true; otherwise func(data, *args, **kwargs).
 
        @param context: Namespace for cache
        @param func: function for slaves to run; must be picklable
        @param dataList: List of data to distribute to slaves; must be picklable
        @param args: List of constant arguments
        @param kwargs: Dict of constant arguments
        @return list of results from applying 'func' to dataList
        """
        return self.reduceNoBalance(context, None, func, dataList, *args, **kwargs)
 

mapToPrevious()

def lsst.ctrl.pool.pool.PoolMaster.mapToPrevious	(		self,
			context,
			func,
			dataList,
		*	args,
		**	kwargs
	)

Scatter work to the same target as before.

    Work is distributed so that each slave handles the same
    indices in the dataList as when 'map' was called.
    This allows the right data to go to the right cache.

    It is assumed that the dataList is the same length as when it was
    passed to 'map'.

    The 'func' signature should be func(cache, data, *args, **kwargs).

    @param context: Namespace for cache
    @param func: function for slaves to run; must be picklable
    @param dataList: List of data to distribute to slaves; must be picklable
    @param args: List of constant arguments
    @param kwargs: Dict of constant arguments
    @return list of results from applying 'func' to dataList

Definition at line 885 of file pool.py.

    def mapToPrevious(self, context, func, dataList, *args, **kwargs):
        """!Scatter work to the same target as before
 
        Work is distributed so that each slave handles the same
        indices in the dataList as when 'map' was called.
        This allows the right data to go to the right cache.
 
        It is assumed that the dataList is the same length as when it was
        passed to 'map'.
 
        The 'func' signature should be func(cache, data, *args, **kwargs).
 
        @param context: Namespace for cache
        @param func: function for slaves to run; must be picklable
        @param dataList: List of data to distribute to slaves; must be picklable
        @param args: List of constant arguments
        @param kwargs: Dict of constant arguments
        @return list of results from applying 'func' to dataList
        """
        return self.reduceToPrevious(context, None, func, dataList, *args, **kwargs)
 

reduce()

def lsst.ctrl.pool.pool.PoolMaster.reduce	(		self,
			context,
			reducer,
			func,
			dataList,
		*	args,
		**	kwargs
	)

Scatter work to slaves and reduce the results.

    Work is distributed dynamically, so that slaves that finish
    quickly will receive more work.

    Each slave applies the function to the data they're provided.
    The slaves may optionally be passed a cache instance, which
    they can use to store data for subsequent executions (to ensure
    subsequent data is distributed in the same pattern as before,
    use the 'mapToPrevious' method).  The cache also contains
    data that has been stored on the slaves.

    The 'func' signature should be func(cache, data, *args, **kwargs)
    if 'context' is non-None; otherwise func(data, *args, **kwargs).

    The 'reducer' signature should be reducer(old, new). If the 'reducer'
    is None, then we will return the full list of results

    @param context: Namespace for cache
    @param reducer: function for master to run to reduce slave results; or None
    @param func: function for slaves to run; must be picklable
    @param dataList: List of data to distribute to slaves; must be picklable
    @param args: List of constant arguments
    @param kwargs: Dict of constant arguments
    @return reduced result (if reducer is non-None) or list of results
        from applying 'func' to dataList

Definition at line 683 of file pool.py.

    def reduce(self, context, reducer, func, dataList, *args, **kwargs):
        """!Scatter work to slaves and reduce the results
 
        Work is distributed dynamically, so that slaves that finish
        quickly will receive more work.
 
        Each slave applies the function to the data they're provided.
        The slaves may optionally be passed a cache instance, which
        they can use to store data for subsequent executions (to ensure
        subsequent data is distributed in the same pattern as before,
        use the 'mapToPrevious' method).  The cache also contains
        data that has been stored on the slaves.
 
        The 'func' signature should be func(cache, data, *args, **kwargs)
        if 'context' is non-None; otherwise func(data, *args, **kwargs).
 
        The 'reducer' signature should be reducer(old, new). If the 'reducer'
        is None, then we will return the full list of results
 
        @param context: Namespace for cache
        @param reducer: function for master to run to reduce slave results; or None
        @param func: function for slaves to run; must be picklable
        @param dataList: List of data to distribute to slaves; must be picklable
        @param args: List of constant arguments
        @param kwargs: Dict of constant arguments
        @return reduced result (if reducer is non-None) or list of results
            from applying 'func' to dataList
        """
        tags = Tags("request", "work")
        num = len(dataList)
        if self.size == 1 or num <= 1:
            return self._reduceQueue(context, reducer, func, list(zip(list(range(num)), dataList)),
                                     *args, **kwargs)
        if self.size == num:
            # We're shooting ourselves in the foot using dynamic distribution
            return self.reduceNoBalance(context, reducer, func, dataList, *args, **kwargs)
 
        self.command("reduce")
 
        # Send function
        self.log("instruct")
        self.comm.broadcast((tags, func, reducer, args, kwargs, context), root=self.root)
 
        # Parcel out first set of data
        queue = list(zip(range(num), dataList))  # index, data
        output = [None]*num if reducer is None else None
        initial = [None if i == self.rank else queue.pop(0) if queue else NoOp() for
                   i in range(self.size)]
        pending = min(num, self.size - 1)
        self.log("scatter initial jobs")
        self.comm.scatter(initial, root=self.rank)
 
        while queue or pending > 0:
            status = mpi.Status()
            report = self.comm.recv(status=status, tag=tags.request, source=mpi.ANY_SOURCE)
            source = status.source
            self.log("gather from slave", source)
            if reducer is None:
                index, result = report
                output[index] = result
 
            if queue:
                job = queue.pop(0)
                self.log("send job to slave", job[0], source)
            else:
                job = NoOp()
                pending -= 1
            self.comm.send(job, source, tag=tags.work)
 
        if reducer is not None:
            results = self.comm.gather(None, root=self.root)
            output = None
            for rank in range(self.size):
                if rank == self.root:
                    continue
                output = reducer(output, results[rank]) if output is not None else results[rank]
 
        self.log("done")
        return output
 

reduceNoBalance()

def lsst.ctrl.pool.pool.PoolMaster.reduceNoBalance	(		self,
			context,
			reducer,
			func,
			dataList,
		*	args,
		**	kwargs
	)

Scatter work to slaves and reduce the results.

    Work is distributed statically, so there is no load balancing.

    Each slave applies the function to the data they're provided.
    The slaves may optionally be passed a cache instance, which
    they can store data in for subsequent executions (to ensure
    subsequent data is distributed in the same pattern as before,
    use the 'mapToPrevious' method).  The cache also contains
    data that has been stored on the slaves.

    The 'func' signature should be func(cache, data, *args, **kwargs)
    if 'context' is true; otherwise func(data, *args, **kwargs).

    The 'reducer' signature should be reducer(old, new). If the 'reducer'
    is None, then we will return the full list of results

    @param context: Namespace for cache
    @param reducer: function for master to run to reduce slave results; or None
    @param func: function for slaves to run; must be picklable
    @param dataList: List of data to distribute to slaves; must be picklable
    @param args: List of constant arguments
    @param kwargs: Dict of constant arguments
    @return reduced result (if reducer is non-None) or list of results
        from applying 'func' to dataList

Definition at line 789 of file pool.py.

    def reduceNoBalance(self, context, reducer, func, dataList, *args, **kwargs):
        """!Scatter work to slaves and reduce the results
 
        Work is distributed statically, so there is no load balancing.
 
        Each slave applies the function to the data they're provided.
        The slaves may optionally be passed a cache instance, which
        they can store data in for subsequent executions (to ensure
        subsequent data is distributed in the same pattern as before,
        use the 'mapToPrevious' method).  The cache also contains
        data that has been stored on the slaves.
 
        The 'func' signature should be func(cache, data, *args, **kwargs)
        if 'context' is true; otherwise func(data, *args, **kwargs).
 
        The 'reducer' signature should be reducer(old, new). If the 'reducer'
        is None, then we will return the full list of results
 
        @param context: Namespace for cache
        @param reducer: function for master to run to reduce slave results; or None
        @param func: function for slaves to run; must be picklable
        @param dataList: List of data to distribute to slaves; must be picklable
        @param args: List of constant arguments
        @param kwargs: Dict of constant arguments
        @return reduced result (if reducer is non-None) or list of results
            from applying 'func' to dataList
        """
        tags = Tags("result", "work")
        num = len(dataList)
        if self.size == 1 or num <= 1:
            return self._reduceQueue(context, reducer, func, list(zip(range(num), dataList)), *args, **kwargs)
 
        self.command("mapNoBalance")
 
        # Send function
        self.log("instruct")
        self.comm.broadcast((tags, func, args, kwargs, context), root=self.root)
 
        # Divide up the jobs
        # Try to give root the least to do, so it also has time to manage
        queue = list(zip(range(num), dataList))  # index, data
        if num < self.size:
            distribution = [[queue[i]] for i in range(num)]
            distribution.insert(self.rank, [])
            for i in range(num, self.size - 1):
                distribution.append([])
        elif num % self.size == 0:
            numEach = num//self.size
            distribution = [queue[i*numEach:(i+1)*numEach] for i in range(self.size)]
        else:
            numEach = num//self.size
            distribution = [queue[i*numEach:(i+1)*numEach] for i in range(self.size)]
            for i in range(numEach*self.size, num):
                distribution[(self.rank + 1) % self.size].append
            distribution = list([] for i in range(self.size))
            for i, job in enumerate(queue, self.rank + 1):
                distribution[i % self.size].append(job)
 
        # Distribute jobs
        for source in range(self.size):
            if source == self.rank:
                continue
            self.log("send jobs to ", source)
            self.comm.send(distribution[source], source, tag=tags.work)
 
        # Execute our own jobs
        output = [None]*num if reducer is None else None
 
        def ingestResults(output, nodeResults, distList):
            if reducer is None:
                for i, result in enumerate(nodeResults):
                    index = distList[i][0]
                    output[index] = result
                return output
            if output is None:
                output = nodeResults.pop(0)
            for result in nodeResults:
                output = reducer(output, result)
            return output
 
        ourResults = self._processQueue(context, func, distribution[self.rank], *args, **kwargs)
        output = ingestResults(output, ourResults, distribution[self.rank])
 
        # Collect results
        pending = self.size - 1
        while pending > 0:
            status = mpi.Status()
            slaveResults = self.comm.recv(status=status, tag=tags.result, source=mpi.ANY_SOURCE)
            source = status.source
            self.log("gather from slave", source)
            output = ingestResults(output, slaveResults, distribution[source])
            pending -= 1
 
        self.log("done")
        return output
 

reduceToPrevious()

def lsst.ctrl.pool.pool.PoolMaster.reduceToPrevious	(		self,
			context,
			reducer,
			func,
			dataList,
		*	args,
		**	kwargs
	)

Reduction where work goes to the same target as before.

    Work is distributed so that each slave handles the same
    indices in the dataList as when 'map' was called.
    This allows the right data to go to the right cache.

    It is assumed that the dataList is the same length as when it was
    passed to 'map'.

    The 'func' signature should be func(cache, data, *args, **kwargs).

    The 'reducer' signature should be reducer(old, new). If the 'reducer'
    is None, then we will return the full list of results

    @param context: Namespace for cache
    @param reducer: function for master to run to reduce slave results; or None
    @param func: function for slaves to run; must be picklable
    @param dataList: List of data to distribute to slaves; must be picklable
    @param args: List of constant arguments
    @param kwargs: Dict of constant arguments
    @return reduced result (if reducer is non-None) or list of results
        from applying 'func' to dataList

Definition at line 908 of file pool.py.

    def reduceToPrevious(self, context, reducer, func, dataList, *args, **kwargs):
        """!Reduction where work goes to the same target as before
 
        Work is distributed so that each slave handles the same
        indices in the dataList as when 'map' was called.
        This allows the right data to go to the right cache.
 
        It is assumed that the dataList is the same length as when it was
        passed to 'map'.
 
        The 'func' signature should be func(cache, data, *args, **kwargs).
 
        The 'reducer' signature should be reducer(old, new). If the 'reducer'
        is None, then we will return the full list of results
 
        @param context: Namespace for cache
        @param reducer: function for master to run to reduce slave results; or None
        @param func: function for slaves to run; must be picklable
        @param dataList: List of data to distribute to slaves; must be picklable
        @param args: List of constant arguments
        @param kwargs: Dict of constant arguments
        @return reduced result (if reducer is non-None) or list of results
            from applying 'func' to dataList
        """
        if context is None:
            raise ValueError("context must be set to map to same nodes as previous context")
        tags = Tags("result", "work")
        num = len(dataList)
        if self.size == 1 or num <= 1:
            # Can do everything here
            return self._reduceQueue(context, reducer, func, list(zip(range(num), dataList)), *args, **kwargs)
        if self.size == num:
            # We're shooting ourselves in the foot using dynamic distribution
            return self.reduceNoBalance(context, reducer, func, dataList, *args, **kwargs)
 
        self.command("mapToPrevious")
 
        # Send function
        self.log("instruct")
        self.comm.broadcast((tags, func, args, kwargs, context), root=self.root)
 
        requestList = self.comm.gather(None, root=self.root)
        self.log("listen", requestList)
        initial = [dataList[index] if (index is not None and index >= 0) else None for index in requestList]
        self.log("scatter jobs", initial)
        self.comm.scatter(initial, root=self.root)
        pending = min(num, self.size - 1)
 
        if reducer is None:
            output = [None]*num
        else:
            thread = ReductionThread(reducer)
            thread.start()
 
        while pending > 0:
            status = mpi.Status()
            index, result, nextIndex = self.comm.recv(status=status, tag=tags.result, source=mpi.ANY_SOURCE)
            source = status.source
            self.log("gather from slave", source)
            if reducer is None:
                output[index] = result
            else:
                thread.add(result)
 
            if nextIndex >= 0:
                job = dataList[nextIndex]
                self.log("send job to slave", source)
                self.comm.send(job, source, tag=tags.work)
            else:
                pending -= 1
 
            self.log("waiting on", pending)
 
        if reducer is not None:
            output = thread.join()
 
        self.log("done")
        return output
 

storeClear()

def lsst.ctrl.pool.pool.PoolMaster.storeClear	(		self,
			context
	)

Reset data store for a particular context on master and slaves

Reimplemented from lsst.ctrl.pool.pool.PoolNode.

Definition at line 1016 of file pool.py.

    def storeClear(self, context):
        """Reset data store for a particular context on master and slaves"""
        super(PoolMaster, self).storeClear(context)
        self.command("storeClear")
        self.comm.broadcast(context, root=self.root)
 

storeDel()

def lsst.ctrl.pool.pool.PoolMaster.storeDel	(		self,
			context,
		*	nameList
	)

Delete stored data on slave for a particular context

Reimplemented from lsst.ctrl.pool.pool.PoolNode.

Definition at line 1007 of file pool.py.

    def storeDel(self, context, *nameList):
        """Delete stored data on slave for a particular context"""
        super(PoolMaster, self).storeDel(context, *nameList)
        self.command("storeDel")
        self.log("tell names")
        self.comm.broadcast((context, nameList), root=self.root)
        self.log("done")
 

storeList()

def lsst.ctrl.pool.pool.PoolMaster.storeList	(		self,
			context
	)

List store contents for a particular context on master and slaves

Reimplemented from lsst.ctrl.pool.pool.PoolNode.

Definition at line 1037 of file pool.py.

    def storeList(self, context):
        """List store contents for a particular context on master and slaves"""
        super(PoolMaster, self).storeList(context)
        self.command("storeList")
        self.comm.broadcast(context, root=self.root)
 

storeSet()

def lsst.ctrl.pool.pool.PoolMaster.storeSet	(		self,
			context,
		**	kwargs
	)

Store data on slave for a particular context.

    The data is made available to functions through the cache. The
    stored data differs from the cache in that it is identical for
    all operations, whereas the cache is specific to the data being
    operated upon.

    @param context: namespace for store
    @param kwargs: dict of name=value pairs

Reimplemented from lsst.ctrl.pool.pool.PoolNode.

Definition at line 989 of file pool.py.

    def storeSet(self, context, **kwargs):
        """!Store data on slave for a particular context
 
        The data is made available to functions through the cache. The
        stored data differs from the cache in that it is identical for
        all operations, whereas the cache is specific to the data being
        operated upon.
 
        @param context: namespace for store
        @param kwargs: dict of name=value pairs
        """
        super(PoolMaster, self).storeSet(context, **kwargs)
        self.command("storeSet")
        self.log("give data")
        self.comm.broadcast((context, kwargs), root=self.root)
        self.log("done")
 

Member Data Documentation

comm

lsst.ctrl.pool.pool.PoolNode.comm

inherited

Definition at line 497 of file pool.py.

debugger

lsst.ctrl.pool.pool.PoolNode.debugger

inherited

Definition at line 503 of file pool.py.

node

lsst.ctrl.pool.pool.PoolNode.node

inherited

Definition at line 504 of file pool.py.

rank

lsst.ctrl.pool.pool.PoolNode.rank

inherited

Definition at line 498 of file pool.py.

root

lsst.ctrl.pool.pool.PoolMaster.root

Definition at line 638 of file pool.py.

size

lsst.ctrl.pool.pool.PoolMaster.size

Definition at line 713 of file pool.py.

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/ctrl_pool/22.0.1-2-g92698f7+dcf3732eb2/python/lsst/ctrl/pool/pool.py