Gem-graph/Concurrent Programming

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

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

def init():
    for i in range(0, renew_length):
        renew.append(0)
    for j in range(0, local_threads_number):
        space.append(random.randint(10,99))
        copy.append(space[j])
    print('  ',space,'   <  initial global state',' '*27,end='[')
    for i in range(0, renew_length): print('{:>4}'.format(renew[i]), end='')
    print(']')

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
                        ),
                        end =''
         )
    for i in range(0, renew_length): print('{:>4}'.format(renew[i]), end='')
    print(']')


def local_thread(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 range(0, renew_length):
        if  renew[i] == id:
            renew[i] = 0
            break
    disp(coord, id, start, prev, next)

init()  #   Scheduler
for id in range (1, number_of_cycles):
    if  renew[id % renew_length] == 0:
        renew[id % renew_length] = id

    t = Thread(target=local_thread, args=(random.randint(0, len(space) - 1), id))
    t.start()
time.sleep(1)
print('  ',copy,'   <  initial global state  (to compare)')
print('history: ',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_threads**'
auxquels il confie une partie de l'état global.
Il est seul à avoir accès à l'état global et à la liste des local_threads.
Il n'a pas accès aux **règles de transition**.
    Chaque local_thread effectue un calcul local puis en soumet le résultat au scheduler.
Le scheduler assigne les résultats des local_threads à 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

"""