# ALP-projet



## Getting started



## Diagramme de classe UML :
```mermaid
classDiagram
    Capteur <|.. CapteurImpl
    AlgoDiffusion <|.. DiffusionAtomique
    AlgoDiffusion <|.. DiffusionEpoque
    AlgoDiffusion <|.. DiffusionSequentielle
    CapteurAsync <|.. Canal
    ObserverDeCapteurAsync <|.. Canal
    ObserverDeCapteur <|.. Afficheur
    Callable <|.. UpdateReq
    Callable <|.. GetValueReq

    Canal "1" --> "1" ObserverDeCapteur
    CapteurImpl "1" o-- "0..*" ObserverDeCapteurAsync
    CapteurImpl "1" --> "1" AlgoDiffusion
    Canal "1" --> "1" Capteur
    Canal "1" --> "1" Scheduler 

    class Capteur{
        <<interface>>
      +attach(o: ObserverDeCapteurAsync):void
      +tick() :void
      +getValue():int
      +getValueDiffusion():int
    }
    class CapteurImpl{
        -value : int
        -diffusion : AlgoDiffusion
        #observers : List~ObserverDeCapteurAsync~
        -lock : boolean
        -initialTime : long
      +attach(o: ObserverDeCapteurAsync):void
      +tick() :void
      +setAlgoDiffusion( diffusion: AlgoDiffusion) : void 
      +getValue():int
      +getValueDiffusion():int
      +stop() : void
      +isStop() :void 
    }
    class AlgoDiffusion{
        <<interface>>
      +execute() : void
        +getValue() : int
    }
    class DiffusionAtomique{
        +capteur : CapteurImpl
        -futures : List~Future~?~~
        -values : Queue~Integer~

        +DiffusionAtomique(c:CapteurImpl)
        +execute():void
        +getValue():int
    }
    class DiffusionEpoque{
        +capteur : CapteurImpl
        -futures : Future~?~[]

        +DiffusionEpoque(c:CapteurImpl)
        +execute():void
        +getValue():int
    }
    class DiffusionSequentielle{
        +capteur : CapteurImpl
        -futures : List~Future~?~~
        -value : int

        +DiffusionSequentielle(c:CapteurImpl)
        +execute():void
        +getValue():int
    }
    class CapteurAsync{
        <<interface>>
        getValue() : Future~Integer~
    }
    class ObserverDeCapteurAsync{
        <<interface>>
      update() : Future~?~ 
    }
    class Canal{
        - scheduler : scheduler
        - afficher : ObserverdeCapteur
        - capteur : Capteur
        +Canal(capteur: Capteur, scheduler: Scheduler, afficher: ObserverdeCapteur)
        +update() : Future~?~
        +getValue() : Future~Integer~
    }

    class ObserverDeCapteur{
        <<interface>>
      update(capteurAsync : CapteurAsync) : void 
    }
    class Afficheur{
        -id : int
        +vals : ArrayList~Integer~
        +setId(id : int): void
        +update(capteurAsync : CapteurAsync)
    }

    class Callable~V~{
        <<interface>>
      call() : V
    }

    class GetValueReq{
        -capteur : Capteur
        +GetValueReq(capteur : Capteur)
        +call() : Integer
    }

    class UpdateReq{
        -canalProxy : CapteurAsync
        -afficheur : ObserverdeCapteur
        +UpdateReq(canalProxy : CapteurAsync, afficheur : ObserverdeCapteur)
        +call() : Void
    }
    class Scheduler{
        - scheduler : ScheduledExecutorService
        + Scheduler(nbCanaux : int)
        + getScheduler(): ScheduledExecutorService
        + enquete(task : Callable<T>, delay : long) : Future~T~
    }
```

## Stratégies de diffusions :

Nous avons ajouté dans l'interface ``AlgoDiffusion`` la fonction ``getValue()``, elle 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 Atomique :

La diffusion atomique permet que tous les afficheurs affichent chacun toutes les valeurs du capteur.
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.

On doit donc enregistrer les valeurs du capteur dans une file d'attente ``Queue<Integer> values``. Alors ``getValue()`` de l'aglo de diffusion n'a qu'à faire un ``peek()`` sur cette file d'attente. Et à chaque appel de ``execute()`` on rajoute la valeur à la file.
Pour que les canaux soient synchronisés, on a une liste ``List<Future<?>> 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 et on retire la valeur qui vient de finir d'être traitée de la file d'attente, et on relance de nouveaux Future en faisant un ``update()`` sur chaque canal.

### - Diffusion Séquentielle :

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<Future<?>> 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 la liste ``futures``, mais cette fois en tant que tableau de taille fixe ``Future<?>[] futures`` (avec comme taille le 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 ont environ la même forme : 
 - on initialise les afficheurs, le Scheduler, 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 afficheurs 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<Integer> 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 tick 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 Séquentielle
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.