Cominciamo col disegnare il diagramma delle precedenze, tenendo conto del fattore operazione singola e della necessità di eseguire in parallelo più operazioni possibili.

Possiamo quindi passare al codice. Di regola teniamo presente che il ramo di destra di una biforcazione rappresenta sempre il figlio o il figlio relativo di una fork.

import os
import sys

'''
Trova il valore di p sapende che ogni funzione deve/può  calcolare solo una operazione alla vota
p = 2*(3 + 2) + (7 - 4) - [(2*3)*(5-1)] = 37
p =     x     +    y    -         z  
'''

def calcolax():
    x = 3 + 2
    return x

def calcolay():
    y = 7 - 4
    return y

def calcolaz1():
    z1 = 2 * 3
    return z1

def calcolaz2():
    z2 = 5 - 1
    return z2
    

if __name__ == "__main__":
    pid = os.fork()
    if pid == 0:
        print ("Sono il processo figlio Mio padre è ", os.getppid(),"Il mio pid figlio è ", os.getpid())
        y = calcolay()
        print (y)
        os._exit(y)
    else:
        pid2= os.fork()
        if pid2 == 0:
            print ("sono il secondo figlio Mio padre è ", os.getppid(),"Il mio pid figlio è ", os.getpid())
            '''
            qui dovrei calcolare la z ma si può dividere
            in due sottoprocessi z1 e z2
            '''
            pid3= os.fork()
            if pid3 == 0:
                print ("sono il lio Mio padre è ", os.getppid(),"Il mio pid figlio è ", os.getpid())
                z2 = calcolaz2()
                os._exit(z2)
            else:
                z1 = calcolaz1()
                pid3,status = os.waitpid(pid3,0) 
                z2 = os.WEXITSTATUS(status)
            z = z1*z2
            os._exit(z)
        else:    
            print ("Sono ancora il processo padre Il mio pid è ", os.getpid())
            x = calcolax()
            x = 2*x

        '''
        Devo introdurre la funzione che ricongiunge i tre rami padre/figli
        e si chiama join
        '''
        pid,status = os.waitpid(pid,0) 
        y = os.WEXITSTATUS(status)
        print (y)
        pid2,status = os.waitpid(pid2,0)
        z = os.WEXITSTATUS(status)
        
        p = x + y + z
        print ("p= ", p)

L'articolo Esercizio fork-join proviene da alfredocentinaro.it.

Nella programmazione parallela il fork join è un modello mediante il quale possiamo parallelizzare ed eseguire programmi paralleli, meglio ancora eseguire rami dei programmi in parallelo, individuando punti del programma in cui si può suddividere l’esecuzione (il fork) in parallelo per poi riunirli (il join) e riprendere l’esecuzione sequenziale. Le sezioni parallele vedremo possono suddividersi ulteriormente per suddividere un compito al livello di grana più fine.

L’esempio è volutamente semplice due operazioni aritmetiche nelle rispettive parentesi, non correlate tra di loro, ovvero che non dipendono l’una dall’altra e possono quindi essere eseguite in parallelo senza che una necessiti del risultato dell’altra. Sarà invece il prodotto che verrà eseguito in modo sequenziale al termine delle due parentesi e di aver quindi prelevato i loro risultati in un unico flusso di esecuzione.

Le rispettive parantesi le calcoliamo all’interno di due funzioni senza parametri per rendere più leggibile il codice e simulare anche un comportamento più realistico a fronte di operazioni e codici più complessi.

'''
Vogliamo eseguire l'operazione 
P= (5+3) * (4-2)
     x       y
'''

import os

def calcolaX():
  print ("Elab. parallela x=5+3")
  x = 5 + 3
  return x

def calcolaY():
  print ("Elab. parallela y=4-2")
  y = 4-2
  return y

#programma principale
if __name__== "__main__":
  pid = os.fork()
  if pid == 0:
    print ("Sono il figlio")
    x = calcolaX()
    os._exit(x)
  else:
    #sono il padre
    y = calcolaY()

  '''
  faccio il join: ovvero ricongiungo
  i risultati prelevando il calcolo
  fatto dal figlio. Il padre ovviamente deve aspettare che il figlio finisca
  Il frammento di codice sottostante è eseguito dal padre
  '''

  pid,status = os.wait()
  x = os.WEXITSTATUS(status)
  P = x * y
  print("P= " + str(P))

L'articolo Il costrutto fork vs join proviene da alfredocentinaro.it.