diff --git a/Concurrent Programming.py b/Concurrent Programming.py deleted file mode 100644 index 18c49f5..0000000 --- a/Concurrent Programming.py +++ /dev/null @@ -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 - -"""