import multiprocessing

multiprocessing.cpu_count()

import os
os.getpid()

%%file mp.py
from multiprocessing import Process
import os

def worker():
    print("Worker process {}".format(os.getpid()))

if __name__ == "__main__":
    proc1 = Process(target=worker)
    proc1.start()
    proc2 = Process(target=worker)
    proc2.start()

%%bash
python mp.py

%%file mp.py
from multiprocessing import Process
import os

def worker(arg):
    print("Worker process {}, argument was {}".format(os.getpid(), arg))

if __name__ == "__main__":
    proc1 = Process(target=worker, args=(10,))
    proc1.start()
    proc2 = Process(target=worker, args=(11,))
    proc2.start()

%%bash
python mp.py

%%file mp2.py
from multiprocessing import Process, Queue
import os

def worker(tasks, results):
    t = tasks.get()
    result = t * 2
    results.put([os.getpid(), t, "->", result])

if __name__ == "__main__":
    n = 20
    my_tasks = Queue()
    my_results = Queue()
    
    workers = [Process(target=worker, args=(my_tasks, my_results)) for i in range(n)]
    
    for proc in workers:
        proc.start()
    
    for i in range(n):
        my_tasks.put(i)
    
    for i in range(n):
        result = my_results.get()
        print(result)

%%bash
python mp2.py

from multiprocessing import Queue

q = Queue()

q.get?

%%file mp3.py
from multiprocessing import Process, Manager
import os

def worker(l):
    p = os.getpid()
    l[int(str(p)[-2:])] = p


if __name__ == "__main__":
    n = 100
    manager = Manager()
    l = manager.list()
    l.extend([0] * n)
    
    processes = [Process(target=worker, args=(l,)) for i in range(20)]
    
    for proc in processes:
        proc.start()
    
    for proc in processes:
        proc.join()
    
    print(l)

%%bash
python mp3.py

%%file mp.py
import multiprocessing
import os


def task(args):
    print "Running process", os.getpid(), "with args", args
    return os.getpid(), args


if __name__ == "__main__":
    pool = multiprocessing.Pool(processes=4)
    result = pool.map(task, [1,2,3,4]*3)
    print(result)

%%bash
python mp.py

%%file mp.py
import multiprocessing
import os

def task(args):
    print "Running process", os.getpid(), "with args", args
    return os.getpid(), args


if __name__ == "__main__":
    pool = multiprocessing.Pool(processes=4)
    result = pool.map_async(task, [1,2,3,4])
    print(result.get())

%%bash
python mp.py

from IPython.parallel import Client

cli = Client()

cli = Client()

cli.ids

def get_pid():
    import os
    return os.getpid()

cli[0].apply_sync(get_pid)

get_pid()

cli[:].apply_sync(get_pid)

dview = cli[:]

@dview.parallel(block=True)
def pstr(x):
    return str(x)

str(range(10))

pstr(range(10))

pstr.map(range(10))

from numpy import random

@dview.parallel(block=True)
def task(delay):
    import os, time
    
    t0 = time.time()
    pid = os.getpid()
    time.sleep(delay)
    t1 = time.time()
    
    return [pid, t0, t1]

delays = random.rand(4)

task.map(delays)

def visualize_tasks(results):
    res = np.array(results)
    fig, ax = plt.subplots(figsize=(10, res.shape[1]))
    
    yticks = []
    yticklabels = []
    tmin = min(res[:,1])
    for n, pid in enumerate(np.unique(res[:,0])):
        yticks.append(n)
        yticklabels.append("%d" % pid)
        for m in np.where(res[:,0] == pid)[0]:
            ax.add_patch(Rectangle((res[m,1] - tmin, n-0.25),
                         res[m,2] - res[m,1], 0.5, color="green", alpha=0.5))
        
    ax.set_ylim(-.5, n+.5)
    ax.set_xlim(0, max(res[:,2]) - tmin + 0.)
    ax.set_yticks(yticks)
    ax.set_yticklabels(yticklabels)
    ax.set_ylabel("PID")
    ax.set_xlabel("seconds")

delays = random.rand(100) / 4.

result = task.map(delays)

visualize_tasks(result)

lbview = cli.load_balanced_view()

@lbview.parallel(block=True)
def lb_task(delay):
    import os, time
    
    t0 = time.time()
    pid = os.getpid()
    time.sleep(delay)
    t1 = time.time()
    
    return [pid, t0, t1]

result = lb_task.map(delays)

visualize_tasks(result)

with dview.sync_imports():
    import numpy
    import os

%%px
os.getpid()

dview.push(dict(a=np.arange(5), b=np.zeros(5)), block=True)

dview.pull("a", block=True)

dview["a"]

dview["c"] = "See"

dview.pull("c", block=True)

dview.scatter('x', np.arange(95), block=True)

%%px
x

def x_mean():
    return x.mean()

dview.apply_sync(x_mean)

dview.gather("x", targets=1, block=True)

from IPython.parallel import require

@require("os")
def get_pid():
    return os.getpid()

dview.apply_sync(get_pid)

def factorize(n):
    if n < 2:
        return []
    factors = []
    p = 2

    while True:
        if n == 1:
            return factors
        r = n % p
        if r == 0:
            factors.append(p)
            n = n / p
        elif p * p >= n:
            factors.append(n)
            return factors
        elif p > 2:
            p += 2
        else:
            p += 1