Gem-graph/Concurrent Programming

import threading
from datetime import timedelta
from datetime import datetime
import random
import time

def local_worker(coord, id):
    start = datetime.now().timestamp()
    val = random.randint(1,1000)
    time.sleep(val / 1000)
    prev = space[coord]
    next = space[coord] = 10 + val % 89
    print('{}       on [{}] : {} > {}    by local thread n°{:>3}     {!s:.4}'.format(
                                space,
                                coord,
                                prev,
                                next,
                                str(id),
                                datetime.now().timestamp() - start
                                )
         )

from threading import Thread
space = []
for i in range(0,10):
    space.append(random.randint(10,99))
print(space,'   <  initialglobal state')
for k in range (1,20):
    t = Thread(target=local_worker, args=(random.randint(0,len(space) - 1), k))
    t.start()


"""
    Le **scheduler**, ou processus principal, effectue un calcul sur l'**état global**.
Pour cela, il génère des threads de calcul locaux ou '**local_workers**'
auxquels il confie une partie de l'état global.
Il est seul à avoir accès à l'état global et à la liste des local_workers.
Il n'a pas accès aux **règles de transition**.
    Chaque local_worker effectue un calcul local puis en soumet le résultat au scheduler.
Le scheduler assigne les résultats des local_workers à l'état global.
Il délègue à un **superviseur** des vérification périodiques de l'intégrité de l'état global et peut interrompre le processus en cas d'erreur.
Il délègue à la **CLI** les fonctions de communications avec les modules périphériques.

    Il exécute un **cycle** qui comporte **deux étapes** principales:

 1. recherche aléatoire d'un espace local
 + si trouvé:
    - arrêt de cette recherche 
    - préemption de cet espace local 
    - initiation d'un nouveau thread de calcul auquel est attibué cet espace local
 + sinon arrêt de cette recherche en un temps fini
    
 2. recherche des threads de calcul en fin d'exécution 
   (ces threads se signalent dans une liste; leur temps de calcul est aléatoire)
 + si trouvé(s):
    - arrêt de cette recherche 
    - mise à jour de l'état global (insertion du ou des états locaux calculés)
    - terminaison des threads de calcul concernés et libération des verrous associés
 + sinon arrêt de cette recherche en un temps fini
 
 3. mesures / recueil des commandes / retour d'information
 
 """