libtbx.symmetric_multi_processing
index
/net/chevy/raid1/rwgk/dist/cctbx_project/libtbx/symmetric_multi_processing.pyc

Python threading is useless in the context of symmetric multiprocessor
(SMP) machines because the interpreter data structures are not thread-safe.
As a result, a global interpreter lock (GIL) ensures that one and only one
thread can run the interpreter at any time. As a result, it is impossible
to concurrently run Python functions on several processors. The BDL has made
it quite clear the situation will not change in the foreseeable future.
 
However multiprocessor machines are now mundane. Hence this module. For the
time being, only UNIX systems are supported, through the use of 'fork'.

 
Modules
       
cPickle
cStringIO
libtbx.easy_pickle
libtbx.forward_compatibility
os
select
signal
sys

 
Classes
       
__builtin__.object
logging
child
child_proxy
parent
parallelized_function

 
class child(logging)
    
Method resolution order:
child
logging
__builtin__.object

Methods defined here:
__init__(self, func, read_fd, write_fd, debug)
exit(self)
handle_pipe_other_end_closing(self, signum, frame)
log(self, msg, newline=True)
loop(self)
read(self, length)

Data and other attributes defined here:
input_closed = <class libtbx.symmetric_multi_processing.input_closed at 0x2588230>

Data descriptors inherited from logging:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class child_proxy(logging)
    
Method resolution order:
child_proxy
logging
__builtin__.object

Methods defined here:
__eq__(self, other)
__hash__(self)
__init__(self, pid, read_fd, write_fd, debug)
receive(self)
send(self, x)

Methods inherited from logging:
log(self, msg, newline=True)

Data descriptors inherited from logging:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class logging(__builtin__.object)
     Methods defined here:
log(self, msg, newline=True)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class parallelized_function(parent)
    
Method resolution order:
parallelized_function
parent
logging
__builtin__.object

Methods defined here:
__call__(self, iterable)
__init__(self, func, n_workers, timeout=0.001, stdout=None, debug=False)

Methods inherited from parent:
each(self, iterable)
poll(self, block)
spawn(self, func)

Methods inherited from logging:
log(self, msg, newline=True)

Data descriptors inherited from logging:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class parent(logging)
    
Method resolution order:
parent
logging
__builtin__.object

Methods defined here:
__init__(self, polling_timeout, stdout=None, debug=False)
each(self, iterable)
poll(self, block)
spawn(self, func)

Methods inherited from logging:
log(self, msg, newline=True)

Data descriptors inherited from logging:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
Functions
       
os_fork = fork(...)
fork() -> pid
 
Fork a child process.
Return 0 to child process and PID of child to parent process.

 
Data
        division = _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
generators = _Feature((2, 2, 0, 'alpha', 1), (2, 3, 0, 'final', 0), 0)
is_available = True