104 lines
3.3 KiB
Plaintext
104 lines
3.3 KiB
Plaintext
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
|
|
|
|
"""
|