FM / multiprocessing

/opt/alt/python34/lib64/python3.4/multiprocessing/

/opt/alt/python34/lib64/python3.4/multiprocessing

Name	Size	Mode	Actions
dummy/	-	0755	rm
__pycache__/	-	0755	rm
connection.py	31247	0644	edit dl rm
context.py	10669	0644	edit dl rm
forkserver.py	8477	0644	edit dl rm
heap.py	7952	0644	edit dl rm
managers.py	36273	0644	edit dl rm
pool.py	25059	0644	edit dl rm
popen_fork.py	2420	0644	edit dl rm
popen_forkserver.py	1967	0644	edit dl rm
popen_spawn_posix.py	1915	0644	edit dl rm
popen_spawn_win32.py	2998	0644	edit dl rm
process.py	9144	0644	edit dl rm
queues.py	11557	0644	edit dl rm
reduction.py	8108	0644	edit dl rm
resource_sharer.py	5318	0644	edit dl rm
semaphore_tracker.py	4820	0644	edit dl rm
sharedctypes.py	6334	0644	edit dl rm
spawn.py	8847	0644	edit dl rm
synchronize.py	12224	0644	edit dl rm
util.py	10619	0644	edit dl rm
__init__.py	923	0644	edit dl rm

Edit: /opt/alt/python34/lib64/python3.4/multiprocessing/popen_fork.py (2420B)

import os
import sys
import signal
import errno

from . import util

__all__ = ['Popen']

#
# Start child process using fork
#

class Popen(object):
    method = 'fork'

def __init__(self, process_obj):
        sys.stdout.flush()
        sys.stderr.flush()
        self.returncode = None
        self._launch(process_obj)

def duplicate_for_child(self, fd):
        return fd

def poll(self, flag=os.WNOHANG):
        if self.returncode is None:
            while True:
                try:
                    pid, sts = os.waitpid(self.pid, flag)
                except OSError as e:
                    if e.errno == errno.EINTR:
                        continue
                    # Child process not yet created. See #1731717
                    # e.errno == errno.ECHILD == 10
                    return None
                else:
                    break
            if pid == self.pid:
                if os.WIFSIGNALED(sts):
                    self.returncode = -os.WTERMSIG(sts)
                else:
                    assert os.WIFEXITED(sts)
                    self.returncode = os.WEXITSTATUS(sts)
        return self.returncode

def wait(self, timeout=None):
        if self.returncode is None:
            if timeout is not None:
                from multiprocessing.connection import wait
                if not wait([self.sentinel], timeout):
                    return None
            # This shouldn't block if wait() returned successfully.
            return self.poll(os.WNOHANG if timeout == 0.0 else 0)
        return self.returncode

def terminate(self):
        if self.returncode is None:
            try:
                os.kill(self.pid, signal.SIGTERM)
            except ProcessLookupError:
                pass
            except OSError:
                if self.wait(timeout=0.1) is None:
                    raise

def _launch(self, process_obj):
        code = 1
        parent_r, child_w = os.pipe()
        self.pid = os.fork()
        if self.pid == 0:
            try:
                os.close(parent_r)
                if 'random' in sys.modules:
                    import random
                    random.seed()
                code = process_obj._bootstrap()
            finally:
                os._exit(code)
        else:
            os.close(child_w)
            util.Finalize(self, os.close, (parent_r,))
            self.sentinel = parent_r

cmd: