#!/usr/bin/env python3

import sys
from random import randrange
from math import log, ceil, trunc
import copy
from multiprocessing import cpu_count, Process, SimpleQueue

def minCut(g):
    '''Runs the random contraction algorithm and returns the min cut (# of
    edges) [MOCK].'''

    a = 1
    for i in range(1000):
        a *= 1.1

    return randrange(10, 100)


# message ids
MSG_PROGRESS, MSG_END = range(2)

def minCutIterative(g, n, queue=None):
    '''Calculates the min cut of the graph found by running n iterations.

    Returns the result by writing it to queue and by simply return. Also,
    reports the number of processed iterations after the latest report once
    in a while.
    '''

    min_cut = 10 ** 6
    last_report = -1
    report_period = randrange(15, 51)
    for i in range(0, n):
        if ((i % report_period) == 0) and queue:
            queue.put((MSG_PROGRESS, i - last_report))
            last_report = i

        mc = minCut(g)
        if mc < min_cut:
            min_cut = mc

    if queue:
        queue.put((MSG_PROGRESS, i - last_report))
        queue.put((MSG_END, min_cut))

    return min_cut


def main():
    g = {}
    n = 1000

    process_count = cpu_count()
    print('Found', process_count, 'cores')

    run_count = ceil(n ** 2)
    run_count_per_process = ceil(run_count / process_count)
    run_count = run_count_per_process * process_count
    print('Will run {} times ({} per process)'.format(run_count,
        run_count_per_process))

    # queue to get results from the subprocesses. since we don't care which
    # process got which value, we'll use one queue
    queue = SimpleQueue()
    plist = []
    # start worker processes
    for i in range(0, process_count):
        p = Process(target=minCutIterative, args=(g, run_count_per_process,
            queue))
        plist.append(p)
        p.start()

    print('Working, please wait…')

    total_iterations = 0
    min_cuts = []
    # monitor progress and get all the numbers
    while True:
        (msg, val) = queue.get()
        if msg == MSG_PROGRESS:
            total_iterations += val
            progress = trunc(total_iterations / run_count * 100)
            print('\r[{0:10s}] {1}%'.format('#' * (progress // 10), progress), end='')

        elif msg == MSG_END:
            min_cuts.append(val)
            if len(min_cuts) == process_count:
                break

    print('\nGathered min cuts:', min_cuts)
    min_cut = min(min_cuts)
    print('Final min cut:', min_cut)

    # join the child processes. even though it's not strictly necessary, the
    # multiprocessing programming guide advises us to join zombie processes
    for proc in plist:
        proc.join()

if __name__ == '__main__':
    main()

[####      ] 44%