pythonkurs/teil12/pool_squares.py

#encoding: UTF-8

import datetime
from timeit import default_timer as timer
import multiprocessing
import time
import random
from multiprocessing import Pool

__verbose__ = False

# gibt den String s nur aus, wenn __verbose__ True ist.
def print_verbose(s):
  if __verbose__:
    print(s)

# Arbeitsfunktion läuft in der Zahlenliste von start bis ende
# und summiert die Quadratzahlen in dem Bereich auf.
# Die Methode wird in jedem Prozess mit unterschiedlichen Werten
# für start und ende abgearbeitet.
def calc_sum_square(zahlen, *args,**kwargs):
  print(f'calc_sum_square() {args}')
  time.sleep(1.0)
  start = kwargs['start']
  ende =  kwargs['end']
  threadnr = kwargs['threadnr']
  summe  = 0

  print_verbose(f'von {start} bis {ende}')
  for n in range(start,ende):
    i = zahlen[n]
    print_verbose(f'Berechnung:{threadnr}: {i}, {i*i}')
    summe = summe + i*i

  return summe

# Diese Methode wird initial pro Prozess von der Poolsteuerung aufgerufen und
# steuert die Verteilung der Parameter.
# f ist der Zeiger auf die aufzurufende Methode
# *arg wnthält das Tupel mit den Argumenten
# 
def smap(f, *arg):

# Auflösen des Tupels: args enthält die Liste mit den Zahlen,
# kwarg das Dictionary mit den Parametern für jeden Prozess
  args, kwargs = arg
  
# Aufruf der übergebenen Funktion mit den Parametern
  return f(args, **kwargs)


if __name__ == '__main__':


  start = timer()
 # Liste mit 10 Mio Integerzahlen anlegen.
  zahlen = [i for i in range(10000000)]
  ende = timer()
  print(f'Zahlenliste erzeugt in {ende-start}s')

  split = int(len(zahlen) / 3)
  print_verbose(f'split={split}')
  time.sleep(1.0)

  start = timer()
# Pool mit drei Prozesssen
  with Pool(processes=3) as pool:
# Die Methode pool.starmap() bekommt neben der aufzurufenden Methode smap() eine Liste von Tupeln.
# Jedes Tupel enthält pro Prozess die auszuführende Methode, die Liste mit den Zahlen und ein Dictionary mit
# den Parametern 'threadnr', 'start' und 'end'
# starmap() wartet solange, bis alle drei Teilprozesse beendet sind und gibt dann eine Liste mit den return Werten
# zurück.
    result = pool.starmap(smap, [(calc_sum_square, zahlen, {'threadnr':1,'start':0, 'end':split}), (calc_sum_square, zahlen, {'threadnr':2,'start':split+1,'end':split*2}), (calc_sum_square, zahlen,{'threadnr':3,'start':(split*2)+1,'end':split*3})])
    print(f'Ergebnis: {result}')
  ende = timer()
  print(f'Ausführzeit: {ende-start}s')