I have started work on a PEP for the inclusion of the PyProcessing module (http://pypi.python.org/pypi/processing/ and http://developer.berlios.de/projects/pyprocessing) for inclusion into the stdlib in an upcoming release.
The pyprocessing module "mostly mimicks" the threading module API to provide a "drop in" process-based approach to concurrency allowing applications within python to utilize multiple cores. For example:
from threading import Thread class threads_object(Thread): def run(self): function_to_run()
from processing import Process class process_object(Process): def run(self): function_to_run()
Currently, the module runs on Unix/Linux/OSX and Windows. It supports the following features:
* Objects can be transferred between processes using pipes or multi-producer/multi-consumer queues.
* Objects can be shared between processes using a server process or (for simple data) shared memory.
* Equivalents of all the synchronization primitives in ``threading`` are available.
* A ``Pool`` class makes it easy to submit tasks to a pool of worker processes.
In addition to local concurrency ala "just like threading" model - the processing module allows users to also share data and processes across a cluster of machines via the server Managers and Proxy objects (secured data transfer is supported, data is transferred via pickles). I believe that prior/during inclusion, additional tests will be desired to enhance coverage - but the tests which are already provided test and showcase the module well.
I have spoken to the writer, Richard Oudkerk about his willingness to maintain the processing module according to normal stdlib requirements and he is more than willing to do so.
I believe inclusion into the standard library will be very beneficial for a lot of people looking to larger-scale applications and for a method to side-step the current threading/GIL implementation. This module easily allows users to exploit their "$N core" machines, in a fashion they are already familiar with.
I would suggest that the module is placed at the top-level next to the threading module, however, there is the thought that both this module, and the threading module should be moved to a concurrent.* namespace (i.e: concurrent.threading, concurrent.processing) to allow for additional library inclusion at a later date.
IMHO: I think this is simply a "first step" in the evolution of the python stdlib to support these sorts of things - but I also believe it is an excellent first step.
Please feel free to ask any questions, comments, etc. The more feedback the better the PEP will be!