Delete Concurrent Programming.py
This commit is contained in:
Adrien Bourmault
parent
42d2bacac5
commit
6d3931b09e
|
|
@ -1,149 +0,0 @@
|
||||||
from threading import Thread
|
|
||||||
import random # juste pour que le temps de travail des threads soit aléatoire
|
|
||||||
import time
|
|
||||||
|
|
||||||
|
|
||||||
arrows = []
|
|
||||||
local_threads_number = 10
|
|
||||||
|
|
||||||
def init():
|
|
||||||
for j in range(0, local_threads_number):
|
|
||||||
arrows.append(j % 10)
|
|
||||||
print(arrows,' < initial arrows state')
|
|
||||||
|
|
||||||
def local_thread(coord):
|
|
||||||
while True:
|
|
||||||
time.sleep(random.randint(0,1))
|
|
||||||
arrows[coord] = (arrows[coord] + 1) % 10
|
|
||||||
print(arrows,' ',coord)
|
|
||||||
return
|
|
||||||
|
|
||||||
init() # Scheduler
|
|
||||||
for i in range(0, local_threads_number):
|
|
||||||
t = Thread(target=local_thread, args=(range(i,i+1)))
|
|
||||||
# argument after * must be an iterable, not int < ?
|
|
||||||
t.start()
|
|
||||||
|
|
||||||
# Je ne l'isole pas dans un autre fichier
|
|
||||||
###########################################################################################
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
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 = 24 # 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) # pourquoi y a-t-il toujours au moins un local thread qui travaille (ou dort !...) pendant toute la durée de la simulation ?
|
|
||||||
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
|
|
||||||
# time.sleep(100000) faute de savoir les arrêter, j'essaie de les "endormir"... mais ça ne marche pas !
|
|
||||||
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 !?
|
|
||||||
# c'est peut-être un problème d'affichage: comme les local_threads ne sont pas terminés,
|
|
||||||
# ils continuent à afficher un zéro dans "renew" ?
|
|
||||||
t = Thread(target=local_thread, args=(random.randint(0, len(arrows) - 1), id))
|
|
||||||
t.start()
|
|
||||||
time.sleep(1.5)
|
|
||||||
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
|
|
||||||
|
|
||||||
"""
|
|
||||||
Loading…
Reference in New Issue