Re'sume' de cours (suite)
=================

se'quence = cours1 + td + tp1 + cours2 + tp2


4. Calculs d'horloge (vu en td)
--------------------

4.1 Notation

4.2 Re`gles

4.3 Exemple : Abs
    process Abs = {}
     ( ? integer E  ! integer S )
     (| N := E<0          % e1: P(N) = P(E)                   %
      | M := -E when N    % e2: P(M) = P(-E).T(N) = P(E).T(N) %
                          % e3: T(N)<=P(N) & e1 => T(N)<=P(E) %
                          % e4: e2&e3&2a => P(M) = T(N)       %
      | S := M default E  % e5: P(S) = P(M)+P(E) = T(N)+P(E)  %
      |)                  % e6: e3&e5&2b => P(S) = P(E)       %
    where
     boolean N;
     integer M;
    end

4.4 Autres cas
    Si la de'monstration aboutit a` :
    * P(S)>=X ou P(S)<=X
      l'horloge de S n'est que partiellement de'termine'e
      il faut ajouter une e'quation d'horloge  S ^= ...
    * P(S)=P(S)
      l'horloge de S est inde'termine'e
      il faut ajouter une e'quation d'horloge  S ^= ...
    * P(S)=X+Y et P(S)<=X (par exemple)
      les contraintes d'horloge sont incompatibles
      il faut modifier les e'quations de signaux et/ou d'horloge

4.5 Conseils
    - de'composer au maximum (un seul ope'rateur par e'quation)
      et ne pas he'siter a` cre'er des signaux interme'diaires
    - traiter le cas le plus particulier d'abord
      (notamment pas de constante apre`s un default)
    - e'crire les e'quations d'horloge en commentaire dans les .SIG
    - nume'roter les e'quations d'horloge


5. Modularite' (sous-processus)
-------------------------------

5.1 De'claration
    where
      process moy = ( ? dreal X1, X2  ! dreal M )
        (| M := ( X1 + X2 ) / 2.0 |)
      end

5.2 Appel
    C := moy( A, B )
    e'quivalent a`  C := ( A + B ) / 2.0

5.3 Exemple avec un parame`tre et avec plusieurs sorties
    De'claration:
    where
      process proc = {integer P1, P2} ( ? integer E1, E2  ! integer S1, S2 )
        (| S1 := E1 + P1 | S2 := E2 - P2 |)
    end

    Appel:  (Res1, Res2) := proc{Param1, Param2} (Donnee1, Donnee2)






5.4 Exemple de programme complet
    % MAIN.SIG %
    process MAIN = ( ? integer E1,E2  ! integer S1,S2 )
      (|  S1 := INC( E1 )  |  S2 := INC( E2 )  |)
    where
      process INC = ( ? integer E  ! integer S )
        (|  S := E + 1  |)
    end

5.5 Multi-fichiers
    % MAIN.SIG %
    process MAIN =
      ( ? integer E1,E2  ! integer S1,S2 )
      (|  S1 := INC( E1 )  |  S2 := INC( E2 )  |)
    where
      use mINC;
    end;

    % mINC.SIG %
    module mINC =
      process INC =
        ( ? integer E  ! integer S )
        (|  S := E + 1  |)
    end;


6. Tableaux
-----------

   * e'le'ments de me^me type (ni event ni tableau)
   * taille constante, indices commencent a` 0
   * plusieurs dimensions
   * tous les e'le'ments sont synchrones

6.1. De'claration
     [taille] type nom
     [3,3] integer Masque
     type Tab = [3,3] integer;  Tab Masque;

6.2. Utilisation
     X := Masque[0,0]
     M := Masque default Masque2
     M := Masque + Masque2

6.3. E'nume'ration
     Tab := [ [0]:10, [1]:20, [2]:30 ]
     Tab := [ {to 2}:0, [1]:1 ]
     M   := [ {to 2, to 2}:0, {i to 2}:[i,i]:1 ]
     {indice in debut to fin step pas}

6.4. Concatenation
     Tab := { T1 || T2 }

6.5. Fene^tre glissante
     * W1 := X window 3
       [3] integer W1 init [ [0]:-2, [1]:-1 ]
     * W2 := X $ 2 window 3
       [3] integer W2 init [ {to 3}:0 ]
     * chronogramme:
       X         1          2        3        4        5
       W1    [-2,-1,1]  [-1,1,2]  [1,2,3]  [2,3,4]  [3,4,5]
       W2    [ 0,0,0 ]  [ 0,0,0]  [0,0,1]  [0,1,2]  [1,2,3]
       zeros   1 2 3      2 3 4    3 4      4
     * ==> initialisation: (taille+retard-1) valeurs

6.6. Tableaux constants
     * constante nomme'e:
       constant [3,3] integer IDENTITE = [ [1,0,0], [0,1,0], [0,0,1] ];
     * fichier de parame`tres
       process proc = { integer N; [N] real TC }
       proc.par:
       3, [ [0]:2.5, [1]:1.5, [2]:0.5 ]





7. Processus particuliers
-------------------------

7.1. Le portier
     * Compter le nombre de PRESents dans une piece a partir de signaux
       d'ENTRant et de SORTant.
     * - process portier1 = ( ? event ENTR, SORT  ! integer PRES )
       - NE     := NEprec+1 when ENTR  default NEprec
         NEprec := NE $ 1
         NS     := NSprec+1 when SORT  default NSprec
         NSprec := NS $ 1
         PRES   := NE - NS
       - where integer NE, NEprec init 0, NS, NSprec init 0
       - horloge partiellement de'termine'e => PRES ^= ENTR ^+ SORT
       - beaucoup de signaux; et au bout d'un certain temps ...
       - auto-test ==>
         sortie supplementaire: event DEF
         DEF := when PRES < 0
     * - process portier2 =
           ( ? event ENTR, SORT  ! integer PRES; event DEF )
       - me^me e'quation d'horloge
       - PRES := PRESprec+1 when ENTR
                 default PRESprec-1 when SORT
         PRESprec := PRES $ 1
       - where integer PRESprec init 0
       - que se passe-t-il si ENTR et SORT simultane's ?
     * - si ENTR alors
            si SORT alors
               ne rien changer
            sinon, donc uniquement ENTR
               ajouter 1
            finsi
         sinon, donc uniquement SORT
            enlever 1
       - PRES := ( PRESprec when SORT  default PRESprec + 1)
                 when ENTR
                 default PRESprec - 1

7.2. Duree separant deux evenements
     * Compter le nombre de TOP d'horloge separant les
       evenements DEBUT et FIN.
     * - process duree =
           ( ? event TOP, DEBUT, FIN  ! integer DUREE )
       - N     := 0 when DEBUT  default Nprec + 1
         Nprec := N $ 1
         N     ^= DEBUT ^+ FIN ^+ TOP }
         DUREE := N when FIN
       - where integer N, Nprec init 0 end

7.3. Presence entre deux evenements
     * Tester si un evenement E est survenu entre les
       evenements DEBUT et FIN.
     * - process dansfo =
           ( ? event E, DEBUT, FIN  ! boolean DANS )
       - S     := DEBUT            % true  when DEBUT %
                  default not FIN  % false when FIN   %
                  default Sprec
         Sprec := S $ 1
         DANS  := S when E
         S     ^= DEBUT ^+ FIN ^+ E
       - where boolean S, Sprec init false end
       - et si E quand DEBUT ?  et si E quand FIN ?
         ==> [DEBUT,FIN[
     * - process dansof (solution inelegante)
         DANS := (not DEBUT default FIN default S) when E
     * - process dansoo (solution inelegante)
         DANS := (not DEBUT default not FIN default S) when E
     * - process dansff (solution inelegante)
         DANS := (DEBUT default FIN default S) when E

7.4. Automate
     * Un automate reagit a un certain nombre d'evenements; son etat doit
       donc evoluer a chaque fois qu'un de ces evenements se produit :
       S ^= A ^+ B ^+ ...
     * La reaction a un evenement depend de l'etat precedent :
       S := ( 2 when event A
              default 3 when event B
              default ...            ) when Sprec = 1
            default ( 3 when event B ) when Sprec = 2
            default ...
            default Sprec  % pas d'evt ==> bouclage sur etat courant %
       Sprec := S $ 1
     * % Actions sur transitions %
       X := 0 when Sprec=1 and S=2
            default Xprec+1 when event B
            default ...
     * where integer S, Sprec init 1 end

7.5. Synchronisation sur l'horloge des sorties
     * process capteur = ( ? integer A  ! integer S )
         (| ES := event S  |  S := (A cell ES) when ES |)
       where event ES end
     * ==> horloge de S doit etre fixee par l'exterieur
     * when ES car S ne doit pas etre present aux instants de A

7.6. Sur-echantillonnage
     * process sur = ( ? integer E  ! integer S )
       BASC     := not BASCprec
       BASCprec := BASC $ 1
       S ^= BASC        % sortie 2 fois plus     %
       E ^= when BASC   % frequente que l'entree %
       where BASC, BASCprec init false end  % 1er instant true %
     * BASC  t f t f t f t f
       P(S)  t t t t t t t t    
       P(E)  t   t   t   t