Gem-graph/Concurrent Programming

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

renew_length = 12
local_workers_number = 10
number_of_cycles = 20
renew = []
done = []
space = []
copy = []

def init():
    for i in range(0, renew_length - 1):
        renew.append(-1)
    for j in range(0, local_workers_number):
        space.append(random.randint(10,99))
        copy.append(space[j])
    print('  ',space,'   <  initial global state')

def disp(coord, id, start, prev, next):
    print('   {}       at [{}]  {} > {}    by thread n°{:>3}     {!s:.4}     {}'.format(
                        space,
                        coord,
                        prev,
                        next,
                        str(id),
                        datetime.now().timestamp() - start,
                        renew
                        )
         )


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
    done.append(id)
    for i in renew:
        if renew[i] == id:
            renew[i] = -1
            break
    disp(coord, id, start, prev, next)

init()
for k in range (1, number_of_cycles):
    n = 0
    while renew[n] == -1: # a diagonal of zeros is expected !
        renew[n] = 0
        if n < renew_length - 2:
            n += 1
            break
    # for n in range(0, renew_length - 1):
    #     if renew[n] == -1:
    #         renew[n] = 0
    #         break
    t = Thread(target=local_worker, args=(random.randint(0, len(space) - 1), k))
    t.start()
time.sleep(1)
print('  ',copy,'   <  initial global state  (to compare)')
print(done)
done.sort()
print(done)





"""
    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

"""