Gem-graph/Concurrent Programming

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

local_threads_number = 7  #  in a more realistic model:   local threads number  <<  global arrows state size
                          #  then,   locations would be picked at random in this great global arrows state
                          #  but the goal of this "micro-model" is not to explore the algorithms of choice of an arrow in the state
                          #  it is to fix the way the scheduler terminates the local threads that have done their task
                          #  in a realistic model, the number of cycles is infinite  (the user decides when to stop a running simulation)
                          #  and the size of the "renew" list (the list of the active local threads) depends on the computational power available
                          #  this "micro-model" allows to explore the ineractions  [scheduler  <-> local threads] when the the "renew" list size varies
renew_length = 16         #  renew_length can vary from 1 to number_of_cycles (if more, a part of it remains empty)
number_of_cycles = 20     #  in a realistic model: number_of_cycles   >>   renew_length

renew = []
done = []
arrows = []
copy = []

def init():
    for i in range(0, renew_length):
        renew.append(0)
    for j in range(0, local_threads_number):
        arrows.append(random.randint(10,99))
        copy.append(arrows[j])
    print('  ',arrows,'   <  initial global arrows state',' '*11,'now    start  delta     ',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}     {: >.3f} - {: >.3f} = {!s:.4}     {}'.format(
                        arrows,
                        coord,
                        prev,
                        next,
                        str(id),
                        datetime.now().timestamp() / 10 - int(datetime.now().timestamp() / 10),
                        start / 10 - int(start / 10),
                        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 = arrows[coord]
    next = arrows[coord] = 10 + val % 89 # ou n'importe quelle autre modification !...
    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 (0, number_of_cycles):
    for i in range (0, renew_length):
        if  renew[i] == 0:
            renew[i] = id
            break
    # là où les local_thread qui se terminent ont écrit un zéro,
    # les local_thread nouvellement créés devraient apparaitre !?
    t = Thread(target=local_thread, args=(random.randint(0, len(arrows) - 1), id))
    t.start()
time.sleep(1)
print('  ',copy,'   <  initial global arrows 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

"""