From 6948c79dcb4e367043de050dfb3ce27d1c3aa0df Mon Sep 17 00:00:00 2001 From: Rochas Date: Sat, 20 Dec 2025 12:47:18 +0100 Subject: [PATCH] =?UTF-8?q?ReadMe,=20Explication=20strat=C3=A9gies=20et=20?= =?UTF-8?q?tests?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 57 ++++++++++++++++++++++++-- src/impl/DiffusionAtomique.java | 8 ++-- src/impl/DiffusionSequencielle.java | 10 ++--- src/test/TestAlgoDiffusionAtom.java | 61 +++++++++++++++++++--------- src/test/TestAlgoDiffusionEpoq.java | 35 ++++++++-------- src/test/TestAlgoDiffusionSeq.java | 62 +++++++++++++++++------------ 6 files changed, 160 insertions(+), 73 deletions(-) diff --git a/README.md b/README.md index 7c5bfa1..8defa39 100644 --- a/README.md +++ b/README.md @@ -10,9 +10,60 @@ ## Stratégies de diffusions : -### Diffusion Atomique : +Nous avons ajouté dans l'interface ``AlgoDiffusion`` la fonction ``getValue()``, cette fonction permet de retourner une valeur du capteur gardé en mémoire par l'algorithme de diffusion. La valeur gardée en mémoire est gérée différemment en fonction de la stratégie de diffusion. +On a donc aussi ajouté à l'interface ``Capteur`` la focntion ``getValueDiffusion()`` permettant de récupérer la valeur de l'algo de diffusion. -### Diffusion Sequencielle : +### - Diffusion Atomique : -### Diffusion Epoque : +La diffusion atomique permet que tous les afficheurs affichent toutes les valeurs du capteur, ils affichent donc les mêmes valeurs. +Le capteur change de valeur toutes les 500 ms alors que les canaux prennent entre 2s et 3s pour passer à la valeur suivante, les afficheurs prennent donc du retard. Si les capteurs tournent 1h, les afficheurs auront jusqu'à 5h de retard et au mieux 3h de retard. +On doit donc enregistrer les valeurs du capteur dans une file d'attente ``Queue values``. Alors ``getValue()`` de l'aglo de diffusion n'a qu'à faire un ``peek()`` sur cette file d'attente. À chaque appel de ``execute()`` on rajoute la valeur. +Pour que les canaux soient synchronisés, on a une liste ``List> futures`` qui stocke les Future en cours de traitement (cette liste a donc au maxium comme taille le nombre de canaux). +À chaque appel de ``execute()``, on retire de la liste les Future terminés, quand la liste est vide alors ils sont tous terminés, on retire l'élément à la file d'attente, et on relance des nouveaux Future en faisant un ``update()`` sur chaque canal. + +### - Diffusion Sequencielle : + +Ici, il faut simplement que les afficheurs aient des valeurs synchronisées et que les valeurs soient dans l'ordre chronologique. On n'a donc pas besoin d'afficher toutes les valeurs du capteur. + +On a donc simplement besoin d'une valeur ``int value`` permettant de garder en mémoire une valeur du capteur commune pour tous les afficheurs. C'est cette valeur qui est retournée dans le ``getValue()``. +On a encore une liste ``List> futures`` qui a le même fonctionnement que pour Atomique, à la différence qu'il remplace simplement ``value`` par la nouvelle valeur quand ``futures`` est vide. + + +### - Diffusion Epoque : + +Cette dernière stratégie est la plus simple, les afficheurs doivent juste afficher chacune des valeurs dans l'ordre chronologique. Il n'y a donc pas de synchronisation entre les afficheurs, et pas non plus besoin d'afficher toutes les valeurs. + +Il nous reste donc plus que ``futures``, mais cette fois en tant que tableau de taille fixe ``Future[] futures`` (nombre de canaux). On n'a pas besoin d'attendre que tous les Future soient finis pour passer à la suite, dès qu'un Future est fini, on relance directement un update() sur le canal associé. +La fonction ``getValue()`` retourne donc directement la valeur courante du capteur sans rien sauvegarder au préalable. + +## Tests : + + +### - Tests : + +L'exécution dans chaque test on environ la même forme : + - on initialise les afficheurs, le Sceduler, le capteur, l'algo de diffusion, les canaux + - on lance le tick avec le scheduler. + - on laisse tourner pendant quelques secondes (5s pour la stratégie atomique, et 10s pour les 2 autres) + - on attend les potentiels derniers Future (25s pour la stratégie atomique, et 3s pour les 2 autres) + - affichage des résulat des afficheur pour debug + +ps : Pour l'ago de diffusion atomique une constante ``TEST_TIME`` est au début du test pour modifier la durée totale du test (1/6 de run + 5/6 d'attente) + +Dans l'afficheur, nous avons ajouté une liste ``ArrayList vals`` permettant de sauvegarder les valeurs affichées, qui sera utilisée ensuite par l'oracle. + +### - Oracle + +Notre capteur envoie des valeurs de 1 en 1 à chaque ticket en commençant par 1 + +#### - Diffusion Atomique +On a deux oracles : +- Un qui vérifie que les éléments sont strictement croissants de 1 en 1 en commençant par 1 +- Et un second qui vérifie que tous les canaux ont les mêmes éléments entre eux. +#### - Diffusion Sequencielle +On a deux oracles : +- Un qui vérifie que les éléments sont strictement croissants. +- Et un second qui vérifie que tous les canaux ont les mêmes éléments entre eux. +#### - Diffusion Epoque +Ici on a qu'un seul oracle qui vérifie simplement que les valeurs sont strictement dans l'ordre croissant \ No newline at end of file diff --git a/src/impl/DiffusionAtomique.java b/src/impl/DiffusionAtomique.java index 08d686d..be46e23 100644 --- a/src/impl/DiffusionAtomique.java +++ b/src/impl/DiffusionAtomique.java @@ -1,7 +1,7 @@ package impl; +import java.util.ArrayDeque; import java.util.ArrayList; -import java.util.LinkedList; import java.util.List; import java.util.Queue; import java.util.concurrent.Future; @@ -19,7 +19,7 @@ public class DiffusionAtomique implements AlgoDiffusion { public DiffusionAtomique(CapteurImpl c){ this.capteur = c; this.futures = new ArrayList>(); - this.values = new LinkedList<>(); + this.values = new ArrayDeque<>(); } @@ -45,8 +45,8 @@ public class DiffusionAtomique implements AlgoDiffusion { } } - // si futures est empty, alors tous les futures canaux précédents sont finis - // et on peut relancer des futures sans attendre le prochain ticket + // si futures est empty, alors tous les Future des canaux précédents sont finis + // et on peut relancer des futures sans attendre le prochain ticket, pour ne pas accumuler encore plus de retard if(this.futures.isEmpty()){ if(!this.values.isEmpty()){ //le capteur ne répond pas (car stopé ici) for (ObserverDeCapteurAsync canal : capteur.observers) { diff --git a/src/impl/DiffusionSequencielle.java b/src/impl/DiffusionSequencielle.java index adda1fe..4e20f56 100644 --- a/src/impl/DiffusionSequencielle.java +++ b/src/impl/DiffusionSequencielle.java @@ -26,7 +26,11 @@ public class DiffusionSequencielle implements AlgoDiffusion { @Override public void execute() { - if(this.futures.isEmpty()){ + if(!this.futures.isEmpty()){ + futures.removeIf(Future::isDone); + } + + if(this.futures.isEmpty()){ //pas de else pour ne pas perdre 500ms à ne rien faire this.value = capteur.getValue(); System.out.println("execute"); for (ObserverDeCapteurAsync canal : capteur.observers) { @@ -34,9 +38,5 @@ public class DiffusionSequencielle implements AlgoDiffusion { this.futures.add(f); } } - else{ - futures.removeIf(Future::isDone); - - } } } diff --git a/src/test/TestAlgoDiffusionAtom.java b/src/test/TestAlgoDiffusionAtom.java index 28dd302..8d3ad83 100644 --- a/src/test/TestAlgoDiffusionAtom.java +++ b/src/test/TestAlgoDiffusionAtom.java @@ -10,8 +10,6 @@ import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertTrue; - - import impl.Afficheur; import impl.Canal; import impl.CapteurImpl; @@ -21,10 +19,21 @@ import impl.Scheduler; public class TestAlgoDiffusionAtom { static int NB_CANAUX = 3; - static int TEST_TIME = 30; // TEST_TIME/6 + TEST_TIME-TEST_TIME/6 + static int TEST_TIME = 30; // TEST_TIME/6 + 5*TEST_TIME/6 public static List[] rAtom; + private static void display(List[] res){ + for(int i = 0; i< NB_CANAUX; i++){ + System.out.println("canal " + i + ":"); + for(int j = 0; j< res[i].size(); j++){ + System.out.print(res[i].get(j)); + if(j0; i--){ + for(int i = 5*TEST_TIME/6; i>0; i--){ System.out.println("restant " + i + "s"); Thread.sleep(1000); } @@ -70,35 +78,50 @@ public class TestAlgoDiffusionAtom { future.cancel(false); clock.shutdown(); - //Thread.sleep(1500); for(int i = 0; i[] rEpoq; + + private static void display(List[] res){ + for(int i = 0; i< NB_CANAUX; i++){ + System.out.println("canal " + i + ":"); + for(int j = 0; j< res[i].size(); j++){ + System.out.print(res[i].get(j)); + if(j future = clock.scheduleAtFixedRate(() -> c.tick(), 0, 500, TimeUnit.MILLISECONDS); @@ -62,31 +68,26 @@ public class TestAlgoDiffusionEpoq { Thread.sleep(3100); //3000ms max + 100ms de marge clock.shutdown(); - //Thread.sleep(1500); for(int i = 0; ivalTest; - valTest=rEpoq[i].get(j); + r = r && rEpoq[i].get(j)>test; + test=rEpoq[i].get(j); } - System.out.println(" "); } assertTrue(r); } diff --git a/src/test/TestAlgoDiffusionSeq.java b/src/test/TestAlgoDiffusionSeq.java index 0a61d61..06cc8f9 100644 --- a/src/test/TestAlgoDiffusionSeq.java +++ b/src/test/TestAlgoDiffusionSeq.java @@ -10,8 +10,6 @@ import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertTrue; - - import impl.Afficheur; import impl.Canal; import impl.CapteurImpl; @@ -24,6 +22,18 @@ public class TestAlgoDiffusionSeq { public static List[] rSeq; + + private static void display(List[] res){ + for(int i = 0; i< NB_CANAUX; i++){ + System.out.println("canal " + i + ":"); + for(int j = 0; j< res[i].size(); j++){ + System.out.print(res[i].get(j)); + if(j test; + test = rSeq[i].get(j); + } + } + assertTrue(r); + } + + @Test + void sameElements(){ boolean r = true; for(int i = 0; i< NB_CANAUX-1 && r; i++){ r = rSeq[i].size()==rSeq[i+1].size(); } - if(!r) System.out.println("pas de la même taille :"); - - int test = 0; - for(int j = 0; j< rSeq[0].size() && r; j++){ - for(int i = 0; i< NB_CANAUX && r; i++){ - if(i==0){ - r = r && rSeq[i].get(j)>test; - test = rSeq[i].get(j); - } - else{ - r = r && rSeq[i].get(j) == test; - } - } + if(!r){ + System.err.println("Pas de la même taille !"); } - - //display - for(int i = 0; i< NB_CANAUX && r; i++){ - System.out.println("canal " + i + ":"); - for(int j = 0; j< rSeq[i].size() && r; j++){ - System.out.print(rSeq[i].get(j)); - if(j