Multiprocessing & Parallelism

# cpu_bench.py - measure the threading/multiprocessing gap instead of asserting it
import multiprocessing as mp
import threading
import time
from concurrent.futures import ProcessPoolExecutor

def fib(n):
    """Deliberately naive: pure Python recursion, so it needs the GIL throughout"""
    return n if n < 2 else fib(n - 1) + fib(n - 2)

def timed(fn):
    start = time.perf_counter()
    fn()
    return time.perf_counter() - start

N = 35
TASKS = 4

def sequential():
    for _ in range(TASKS):
        fib(N)

def threaded():
    ts = [threading.Thread(target=fib, args=(N,)) for _ in range(TASKS)]
    for t in ts:
        t.start()
    for t in ts:
        t.join()

def processes():
    with ProcessPoolExecutor(max_workers=TASKS) as ex:
        list(ex.map(fib, [N] * TASKS))

if __name__ == '__main__':
    print(f"cores: {mp.cpu_count()}  |  fib({N}) = {fib(N)}  |  {TASKS} tasks")

    seq = timed(sequential)
    thr = timed(threaded)
    proc = timed(processes)

    print(f"  sequential    {seq:6.2f}s")
    print(f"  {TASKS} threads     {thr:6.2f}s   ({seq / thr:.2f}x vs sequential)")
    print(f"  {TASKS} processes   {proc:6.2f}s   ({seq / proc:.2f}x vs sequential)")

import multiprocessing as mp

def square(x):
    return x * x

if __name__ == '__main__':
    # Three ways to start a process:
    #   'fork'       - clone the parent process (fast; Unix only; unsafe with threads)
    #   'spawn'      - launch a fresh interpreter (safe; default on macOS & Windows)
    #   'forkserver' - fork from a clean helper process (Unix; safe with threads)

    # Option A: set the default once (guard it with __main__)
    mp.set_start_method('spawn')

    # Option B: get an explicit context WITHOUT changing the global default
    ctx = mp.get_context('spawn')
    with ctx.Pool(processes=4) as pool:
        print(pool.map(square, range(8)))

# Why it matters:
# - 'spawn' re-imports your module in every child, so everything the child
#   needs must be importable and behind if __name__ == '__main__'.
# - 'fork' is fast (copy-on-write memory) but can deadlock if the parent held
#   a lock in another thread. Python 3.14 stops defaulting to 'fork' on Linux.

import multiprocessing as mp
import time

def process(n):
    # Deliberately uneven work, so imap_unordered has something to reorder
    time.sleep(0.05 * (n % 4))
    return n * n

if __name__ == '__main__':
    data = range(8)

    with mp.Pool(processes=4) as pool:
        # map(): blocks until everything is done, returns a list IN ORDER
        print("map:           ", pool.map(process, data))

        # chunksize: send fewer, bigger batches to cut IPC overhead
        print("map chunksize: ", pool.map(process, data, chunksize=4))

        # imap(): lazy iterator, still ordered - good for streaming huge inputs
        print("imap:          ", list(pool.imap(process, data)))

        # imap_unordered(): yields results AS THEY FINISH, so the order differs
        print("imap_unordered:", list(pool.imap_unordered(process, data)))

        # apply_async(): run a single call in the background, collect it later
        future = pool.apply_async(process, args=(10,))
        print("apply_async:   ", future.get(timeout=5))

import multiprocessing as mp

# The function, its arguments, AND its return value all cross the process
# boundary - so every one of them has to be picklable.

run = lambda x: x * x  # a lambda cannot be pickled, even bound to a global name

def with_lambda():
    """Won't work: lambdas and local (nested) functions are not picklable"""
    with mp.Pool() as pool:
        return pool.map(run, range(5))

def square(x):
    """Works: top-level (module-level) functions ARE picklable"""
    return x * x

if __name__ == '__main__':
    # Run the broken version rather than just asserting it breaks. Note what
    # pickle actually complains about: it stores a function by name, and the
    # name of a lambda is "<lambda>", which it cannot look up again.
    try:
        with_lambda()
    except Exception as e:
        print(f"{type(e).__name__}: {e}")

    with mp.Pool() as pool:
        print(pool.map(square, range(5)))

# Common non-picklable culprits: lambdas, closures, open files/sockets,
# database connections, and most locks. Pass plain data, not live handles.