Python> High Performance Python(4)

import random

TESTCNT = 100000000

def monte_carlo():
    circleIn = 0

    for i in range(TESTCNT):
        tempX = random.random()
        tempY = random.random()
        if (tempX*tempX + tempY*tempY) <= 1:
            circleIn += 1

    print("shot cnt = %f" % (circleIn/TESTCNT))
    print("pi = %f" % (4.0*circleIn/TESTCNT))

startTime = time.time()
monte_carlo()
print("running time : " + str(time.time()-startTime))

$ python3 test9_2.py
shot cnt = 0.785400
pi = 3.141602
running time : 25.7069725990295

"""Estimate Pi using Threads and Processes"""
import time
import numpy as np
from multiprocessing import Pool


def estimate_nbr_points_in_quarter_circle(nbr_samples):
   # 각각의 새로운 프로세스에서 numpy를 위한 난수 시드를 생성한다.
   # 그렇제 않다면 fork로 만들어진 모든 프로세스가 동일한 상태를 공유한다.
    np.random.seed()
    xs = np.random.uniform(0, 1, nbr_samples)
    ys = np.random.uniform(0, 1, nbr_samples)
    estimate_inside_quarter_unit_circle = (xs * xs + ys * ys) <= 1
    nbr_trials_in_quarter_unit_circle = np.sum(
        estimate_inside_quarter_unit_circle)
    return nbr_trials_in_quarter_unit_circle


if __name__ == "__main__":
    nbr_samples_in_total = 100000000
    nbr_parallel_blocks = 8

    pool = Pool()

    nbr_samples_per_worker = int(nbr_samples_in_total / nbr_parallel_blocks)
    print(type(nbr_samples_per_worker))
    print("Making {} samples per worker".format(nbr_samples_per_worker))

    # confirm we have an integer number of jobs to distribute
    assert nbr_samples_per_worker == int(nbr_samples_per_worker)
    nbr_samples_per_worker == int(nbr_samples_per_worker)
    map_inputs = [nbr_samples_per_worker] * nbr_parallel_blocks
    print(type(map_inputs))
    t1 = time.time()
    results = pool.map(estimate_nbr_points_in_quarter_circle, map_inputs)
    pool.close()
    print("Dart throws in unit circle per worker:", results)
    print("Took {}s".format(time.time() - t1))
    nbr_in_circle = sum(results)
    combined_nbr_samples = sum(map_inputs)

    pi_estimate = float(nbr_in_circle) / combined_nbr_samples * 4
    print("Estimated pi", pi_estimate)
    print("Pi", np.pi)

import math
import time
import multiprocessing
from multiprocessing import Pool

FLAG_ALL_DONE = b"WORK_FINISHED"
FLAG_WORKER_FINISHED_PROCESSING = b"WORKER_FINISHED_PROCESSING"


def check_prime(possible_primes_queue, definite_primes_queue):
    while True:
        n = possible_primes_queue.get()
        if n == FLAG_ALL_DONE:
            definite_primes_queue.put(FLAG_WORKER_FINISHED_PROCESSING)
            break
        else:
            if n % 2 == 0:
                continue
            for i in range(int(math.sqrt(n) + 1), 2):
                if n % i == 0:
                    break

            else:
                definite_primes_queue.put(n)


if __name__ == "__main__":
    primes = []

    manager = multiprocessing.Manager()
    # We could limit the input queue size with e.g. `maxsize=3`
    possible_primes_queue = manager.Queue()
    definite_primes_queue = manager.Queue()

    NBR_PROCESSES = 4
    pool = Pool(processes=NBR_PROCESSES)
    processes = []

    for _ in range(NBR_PROCESSES):
        p = multiprocessing.Process(
            target=check_prime,
            args=(
                possible_primes_queue,
                definite_primes_queue))
        processes.append(p)
        p.start()

    t1 = time.time()
    number_range = range(1, 1000000)  # A
    # number_range = xrange(100000000, 100100000)  # B
    # number_range = range(100000000, 101000000)  # C
    # number_range = xrange(1000000000, 1000100000)  # D
    # number_range = xrange(100000000000, 100000100000)  # E

    for possible_prime in number_range:
        possible_primes_queue.put(possible_prime)
    
    print("ALL JOBS ADDED TO THE QUEUE")

    # add poison pills to stop the remote workers
    for n in range(NBR_PROCESSES):
        possible_primes_queue.put(FLAG_ALL_DONE)

    print("NOW WAITING FOR RESULTS...")
    processors_indicating_they_have_finished = 0
    while True:
        # block whilst waiting for results
        new_result = definite_primes_queue.get()
        if new_result == FLAG_WORKER_FINISHED_PROCESSING:
            print("WORKER {} HAS JUST FINISHED".format(processors_indicating_they_have_finished))
            processors_indicating_they_have_finished += 1
            if processors_indicating_they_have_finished == NBR_PROCESSES:
                break
        else:
            primes.append(new_result)
    assert processors_indicating_they_have_finished == NBR_PROCESSES

    print("Took:", time.time() - t1)
    print(len(primes), primes[:10], primes[-10:])

$ python3 test9_3_prime_sentinel.py 
ALL JOBS ADDED TO THE QUEUE
NOW WAITING FOR RESULTS...
WORKER 0 HAS JUST FINISHED
WORKER 1 HAS JUST FINISHED
WORKER 2 HAS JUST FINISHED
WORKER 3 HAS JUST FINISHED
Took: 199.00096464157104
500000 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19] [999981, 999983, 999985, 999987, 999989, 999991, 999993, 999995, 999997, 999999]

def check_prime(n):
    if n % 2 == 0:
        return False
    from_i = 3
    to_i = math.sqrt(n) + 1
    for i in xrange(from_i, int(to_i), 2):
        if n % i == 0:
            return False
return True

def check_prime(n, pool, nbr_processes):
    from_i = 3
    to_i = int(math.sqrt(n)) + 1
    ranges_to_check = create_range.create(from_i, to_i, nbr_processes)
    ranges_to_check = zip(len(ranges_to_check) * [n], ranges_to_check)
    assert len(ranges_to_check) == nbr_processes
    results = pool.map(check_prime_in_range, ranges_to_check)
    if False in results:
        return False
return True

def check_prime(n, pool, nbr_processes):
    # cheaply check high probability set of possible factors
    from_i = 3
    to_i = 21
    if not check_prime_in_range((n, (from_i, to_i))):
        return False

    from_i = to_i
    to_i = int(math.sqrt(n)) + 1
    ranges_to_check = create_range.create(from_i, to_i, nbr_processes)
    ranges_to_check = zip(len(ranges_to_check) * [n], ranges_to_check)
    assert len(ranges_to_check) == nbr_processes
    results = pool.map(check_prime_in_range, ranges_to_check)
    if False in results:
        return False
return True