/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D U   S I M U L A T E U R   D E   M E M O I R E   V I R T U E L L E                                  */
/*        A V E C   N / 2   S E R V E U R S   E T   N / 2   C L I E N T S   F O N C T I O N N A N T                                  */
/*        E N   L E C T U R E / E C R I T U R E   A V E C   S Y N C H R O N I S A T I O N  :                                         */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*             *     * * * * * *   * * * * * *   * * * * * *   *         *   * * * * * *   *   * * * * * *   *         *             */
/*                        *             *        *             **        *        *        *   *         *   **        *             */
/*            * *         *             *        *             * *       *        *        *   *         *   * *       *             */
/*                        *             *        *             *  *      *        *        *   *         *   *  *      *             */
/*           *   *        *             *        *             *   *     *        *        *   *         *   *   *     *             */
/*                        *             *        * * *         *    *    *        *        *   *         *   *    *    *             */
/*          * * * *       *             *        *             *     *   *        *        *   *         *   *     *   *             */
/*                        *             *        *             *      *  *        *        *   *         *   *      *  *             */
/*         *       *      *             *        *             *       * *        *        *   *         *   *       * *             */
/*                        *             *        *             *        **        *        *   *         *   *        **             */
/*        *         *     *             *        * * * * * *   *         *        *        *   * * * * * *   *         *             */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        ATTENTION :                                                                                                                */
/*                                                                                                                                   */
/*                    Ce fichier ('$xtc/nCube.21$I') est                                                                             */
/*                  reference dans 'v $xiMd/nCube.21$I.$m4' a                                                                        */
/*                  a des fins de demonstration 'WWW'.                                                                               */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/nCube.21$I' :                                                                                              */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, AAAAMMJJhhmmss).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        I N C L U D E S   S T A N D A R D S  :                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  < fcntl.h >
#include  < stdio.h >
#include  < time.h >

#define   STANDARD_OUT                                                                                                                  \
                    1                                                                                                                   \
                                        /* Sortie standard...                                                                        */

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N S   T R E S   G E N E R A L E S  :                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   PREMIER_ELEMENT                                                                                                               \
                    0                                                                                                                   \
                                        /* Premier element de tout...                                                                */

#define   CLEAR                                                                                                                         \
                    0                                                                                                                   \
                                        /* Valeur d'effacement generale...                                                           */
#define   UNITE                                                                                                                         \
                    1                                                                                                                   \
                                        /* Unite...                                                                                  */

#ifndef   pNULL
#    define    pNULL                                                                                                                    \
                         CLEAR                                                                                                          \
                                        /* Pointeur nul. On notera le changement en 'pNULL' (un "p" ajoute devant) qui a eu lieu le  */ \
                                        /* 20041103114722 a cause du fait que d'une part le nom anterieur est utilise par '$M4'      */ \
                                        /* ('v $xiMoG/GENERE.02$Y DNULL') et que d'autre part 'v $xiMd/nCube.21$I.$m4 nCube.21.P.I'. */
#else
#endif

#define   RIEN                                                                                                                          \
                    CLEAR                                                                                                               \
                                        /* Absence...                                                                                */

#define   OK                                                                                                                            \
                    CLEAR                                                                                                               \
                                        /* Code de retour general...                                                                 */
#define   NOK                                                                                                                           \
                    (OK + UNITE)                                                                                                        \
                                        /* Negation de 'OK'...                                                                       */

#define   UNDEF                                                                                                                         \
                    31415                                                                                                               \
                                        /* Pour quelque chose d'indefini...                                                          */

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F O N C T I O N S   D E   B I B L I O T H E Q U E  :                                                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
extern    int       atoi();
extern    char      *getenv();

extern    clock_t   clock();
extern    int       system();

extern    void      *malloc();
extern    void      free();

#define   Malloc(pointeur,taille)                                                                                                       \
                    {                                                                                                                   \
                    pointeur = malloc(taille);                                                                                          \
                    if   (pointeur == pNULL)                                                                                            \
                         {                                                                                                              \
                         fprintf(stderr,"\n impossible d'allouer de la memoire");                                                       \
                         exit();                                                                                                        \
                         }                                                                                                              \
                    else                                                                                                                \
                         {                                                                                                              \
                         }                                                                                                              \
                    }                                                                                                                   \
                                        /* Procedure d'allocation memoire...                                                         */

extern    double    pow();

#define   PUISSANCE2(n)                                                                                                                 \
                    ((int)(0.001 + pow((double)(2),(double)(n))))                                                                       \
                                        /* ATTENTION, d'une part, ne pas ecrire :                                                    */ \
                                        /*                                                                                           */ \
                                        /*                   ((int)pow((FLOTTANT)(2),(FLOTTANT)(n)))                                 */ \
                                        /*                                                                                           */ \
                                        /* puisque la fonction 'pow(...)' est une fonction de la librairie C qui attend un argument  */ \
                                        /* en double precision, et d'autre part, il est imperatif d'ajouter un petit epsilon, car,   */ \
                                        /* en effet, la valeur donnee par 'PUISSANCE2(n)' est legerement inferieure a la valeur      */ \
                                        /* entiere attendue des que 'n' est plus grand que 2...                                      */

#define   Get(valeur_de_la_variable,nom_de_la_variable)                                                                                 \
                    {                                                                                                                   \
                    valeur_de_la_variable = atoi(getenv(nom_de_la_variable));                                                           \
                    }                                                                                                                   \
                                        /* Procedure de recuperation de variables d'environnement.                                   */

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E   L A   P R E C I S I O N  :                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   CHAR                                                                                                                          \
                    unsigned char                                                                                                       \
                                        /* Type des images...                                                                        */

#define   iLONGUEUR_caractere                                                                                                           \
                    (int)sizeof(CHAR)
#define   iLONGUEUR_entier                                                                                                              \
                    (int)sizeof(int)

#define   FLOTTANT                                                                                                                      \
                    double
#define   iLONGUEUR_flottant                                                                                                            \
                    (int)sizeof(FLOTTANT)

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E   B A S E   D E S   M E S S A G E S  :                                                           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
extern    void      whoami();
extern    int       nread();
extern    int       nwrite();

#define   iITYPE                                                                                                                        \
                    UNDEF                                                                                                               \
                                        /* Type des operations 'read(...)' et 'write(...)', mais actuellement inutilise...           */
#define   iUNDEF                                                                                                                        \
                    UNDEF                                                                                                               \
                                        /* Valeur actuellement inutilisee de 'flag' des fonctions 'read(...)' et 'write(...)...      */
#define   ANY                                                                                                                           \
                    (-1)                                                                                                                \
                                        /* Numero d'un processeur quelconque...                                                      */

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E   L A   M E M O I R E   V I R T U E L L E   G L O B A L E  :                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition :                                                                                                               */
/*                                                                                                                                   */
/*                    Supposons que l'on dispose de 2xN                                                                              */
/*                  processeurs. Cet ensemble est decoupe                                                                            */
/*                  en deux sous-ensembles : d'une part                                                                              */
/*                  celui des clients, et d'autre part                                                                               */
/*                  celui des serveurs. Un client ne peut                                                                            */
/*                  dialoguer qu'avec un serveur...                                                                                  */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                                       ------------------------------------------------                                            */
/*                                      |                                                                                            */
/*                  Memoire virtuelle : |                                                           (...)                            */
/*                                      |                                                                                            */
/*                                       ------------------------------------------------                                            */
/*                                                                                                                                   */
/*                                          /\                  /\                  /\                                               */
/*                                          ||                  ||                  ||                                               */
/*                                          ||                  ||                  ||                                               */
/*                                          \/                  \/                  \/                                               */
/*                                                                                                                                   */
/*                                       --------            --------            --------                                            */
/*                                      |        |          |        |          |        |                                           */
/*                  Serveurs :          | P0==S0 |          | P2==S1 |          | P4==S2 |          (...)                            */
/*                                      |        |          |        |          |        |                                           */
/*                                       --------            --------            --------                                            */
/*                                                                                                                                   */
/*                                          /\                  /\                  /\                                               */
/*                                          ||                  ||                  ||                                               */
/*                                          ||                  ||                  ||                                               */
/*                                          \/                  \/                  \/                                               */
/*                                                                                                                                   */
/*                                       ------------------------------------------------                                            */
/*                                      |                                                                                            */
/*                                      |                   commutation                             (...)                            */
/*                                      |                                                                                            */
/*                                       ------------------------------------------------                                            */
/*                                                                                                                                   */
/*                                          /\                  /\                  /\                                               */
/*                                          ||                  ||                  ||                                               */
/*                                          ||                  ||                  ||                                               */
/*                                          \/                  \/                  \/                                               */
/*                                                                                                                                   */
/*                                       --------            --------            --------                                            */
/*                                      |        |          |        |          |        |                                           */
/*                  Clients :           | P1==C0 |          | P3==C1 |          | P5==C2 |          (...)                            */
/*                                      |        |          |        |          |        |                                           */
/*                                       --------            --------            --------                                            */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                    La memoire virtuelle est donc                                                                                  */
/*                  supportee par les serveurs uniquement                                                                            */
/*                  et est lue et ecrite par les clients.                                                                            */
/*                  A chaque Client 'C' est associe un                                                                               */
/*                  serveur naturel 'S' (par exemple 'S2'                                                                            */
/*                  est associe a 'C1'), mais cela ne limite                                                                         */
/*                  aucunement les acces. Ainsi donc a un                                                                            */
/*                  client 'C' est associe naturellement                                                                             */
/*                  un fragment (dit "local") de la memoire                                                                          */
/*                  virtuelle, dans lequel il aura interet                                                                           */
/*                  travailler afin de limiter le trafic...                                                                          */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   LOG2_TAILLE_MEMOIRE_VIRTUELLE                                                                                                 \
                    20                                                                                                                  \
                                        /* Logarithme en base 2 de la taille de la memoire virtuelle exprimee en octets.             */
#define   TAILLE_DE_LA_MEMOIRE_VIRTUELLE                                                                                                \
                    PUISSANCE2(LOG2_TAILLE_MEMOIRE_VIRTUELLE)                                                                           \
                                        /* Taille de la memoire virtuelle exprimee en octets ; celle-ci doit etre une puissance      */ \
                                        /* de 2, d'ou cette definition partant du logarithme...                                      */

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D U   M A P P I N G   E N T R E   L E S                                                              */
/*        P R O C E S S E U R S   E T   L A   M E M O I R E   V I R T U E L L E  :                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   PROCESSEURS                                                                                                                   \
                    (UNITE + UNITE)                                                                                                     \
                                        /* Nombre de types de processeurs (les "serveurs" et les "clients").                         */

#define   PREMIER_PROCESSEUR                                                                                                            \
                    PREMIER_ELEMENT                                                                                                     \
                                        /* Numero du premier processeur.                                                             */

#define   PAGE_0                                                                                                                        \
                    PREMIER_ELEMENT                                                                                                     \
                                        /* Premiere page.                                                                            */
#define   ADRESSE_ABSOLUE_0                                                                                                             \
                    PREMIER_ELEMENT                                                                                                     \
                                        /* Premiere adresse absolue.                                                                 */
#define   ADRESSE_RELATIVE_0                                                                                                            \
                    PREMIER_ELEMENT                                                                                                     \
                                        /* Premiere adresse relative.                                                                */

#define   PREMIER_SERVEUR                                                                                                               \
                    PREMIER_PROCESSEUR                                                                                                  \
                                        /* Numero du premier serveur.                                                                */
#define   NUMERO_DE_SERVEUR__NUMERO_DE_PROCESSEUR(serveur)                                                                              \
                    ((PREMIER_PROCESSEUR + ((serveur) - PREMIER_SERVEUR) * PROCESSEURS) + RIEN)                                         \
                                        /* Fonction de passage d'un numero de serveur a un numero de processeur...                   */
#define   NUMERO_DE_PROCESSEUR__NUMERO_DE_SERVEUR(processeur)                                                                           \
                    (PREMIER_SERVEUR + ((processeur) - PREMIER_PROCESSEUR) / PROCESSEURS)                                               \
                                        /* Et inverse...                                                                             */

#define   PREMIER_CLIENT                                                                                                                \
                    PREMIER_PROCESSEUR                                                                                                  \
                                        /* Numero du premier client.                                                                 */
#define   NUMERO_DE_CLIENT__NUMERO_DE_PROCESSEUR(client)                                                                                \
                    ((PREMIER_PROCESSEUR + ((client) - PREMIER_CLIENT) * PROCESSEURS) + UNITE)                                          \
                                        /* Fonction de passage d'un numero de client a un numero de processeur...                    */
#define   NUMERO_DE_PROCESSEUR__NUMERO_DE_CLIENT(processeur)                                                                            \
                    (PREMIER_CLIENT + ((processeur) - PREMIER_PROCESSEUR) / PROCESSEURS)                                                \
                                        /* Et inverse...                                                                             */

#define   ADRESSE_ABSOLUE__NUMERO_DE_PAGE(adresse)                                                                                      \
                    (PAGE_0 + (((adresse) - ADRESSE_ABSOLUE_0) / taille_de_la_memoire_virtuelle_par_serveur))                           \
                                        /* Fonction donnant le numero d'une page de la memoire virtuelle...                          */
#define   NUMERO_DE_PAGE__ADRESSE_ABSOLUE(page)                                                                                         \
                    (ADRESSE_ABSOLUE_0 + ((page) - PAGE_0) * taille_de_la_memoire_virtuelle_par_serveur)                                \
                                        /* Et inverse...                                                                             */

#define   NUMERO_DE_PAGE__SERVEUR(page)                                                                                                 \
                    (PREMIER_SERVEUR + ((page) - PAGE_0))                                                                               \
                                        /* Fonction donnant le numero d'une page de la memoire virtuelle...                          */
#define   SERVEUR__NUMERO_DE_PAGE(serveur)                                                                                              \
                    (PAGE_0 + ((serveur) - PREMIER_SERVEUR))                                                                            \
                                        /* Et inverse...                                                                             */

#define   ADRESSE_ABSOLUE__PROCESSEUR(adresse)                                                                                          \
                    NUMERO_DE_SERVEUR__NUMERO_DE_PROCESSEUR(NUMERO_DE_PAGE__SERVEUR(ADRESSE_ABSOLUE__NUMERO_DE_PAGE(adresse)))          \
                                        /* Fonction donnant le numero dans [0,N-1] du processeur supportant une adresse absolue      */ \
                                        /* donnee dans la memoire virtuelle.                                                         */
#define   PROCESSEUR__ADRESSE_ABSOLUE(processeur)                                                                                       \
                    NUMERO_DE_PAGE__ADRESSE_ABSOLUE(SERVEUR__NUMERO_DE_PAGE(NUMERO_DE_PROCESSEUR__NUMERO_DE_SERVEUR(processeur)))       \
                                        /* Et inverse...                                                                             */

#define   ADRESSE_ABSOLUE__ADRESSE_RELATIVE(adresse)                                                                                    \
                    (ADRESSE_RELATIVE_0 + (((adresse) - ADRESSE_ABSOLUE_0) % taille_de_la_memoire_virtuelle_par_serveur))               \
                                        /* Fonction donnant l'adresse relative a l'interieur d'un processeur d'adresse absolue       */ \
                                        /* donnee dans la memoire virtuelle.                                                         */

#define   EST_SERVEUR(processeur)                                                                                                       \
                    (NUMERO_DE_SERVEUR__NUMERO_DE_PROCESSEUR(NUMERO_DE_PROCESSEUR__NUMERO_DE_SERVEUR(processeur)) == processeur)        \
                                        /* Test pour savoir si un processeur est un serveur de memoire virtuelle...                  */
#define   EST_CLIENT(processeur)                                                                                                        \
                    (! EST_SERVEUR(processeur))                                                                                         \
                                        /* Test pour savoir si un processeur est un client de memoire virtuelle...                   */

#define   SERVEUR_NATUREL(client)                                                                                                       \
                    NUMERO_DE_SERVEUR__NUMERO_DE_PROCESSEUR(NUMERO_DE_PROCESSEUR__NUMERO_DE_SERVEUR(client))                            \
                                        /* Numero du serveur associe naturellement a un client...                                    */
#define   CLIENT_NATUREL(serveur)                                                                                                       \
                    NUMERO_DE_CLIENT__NUMERO_DE_PROCESSEUR(NUMERO_DE_PROCESSEUR__NUMERO_DE_CLIENT(serveur))                             \
                                        /* Numero du client associe naturellement a un serveur...                                    */

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E   L A   M E M O I R E   V I R T U E L L E   L O C A L E                                          */
/*        A S S O C I E E   N A T U R E L L E M E N T   A   C H A Q U E   C L I E N T  :                                             */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   DEBUT_DE_LA_MEMOIRE_VIRTUELLE_LOCALE                                                                                          \
                    PROCESSEUR__ADRESSE_ABSOLUE(SERVEUR_NATUREL(processeur_local))                                                      \
                                        /* Premier octet de la memoire virtuelle supportee par le serveur associe naturellement      */ \
                                        /* au processeur local.                                                                      */
#define   FIN_DE_LA_MEMOIRE_VIRTUELLE_LOCALE                                                                                            \
                    (DEBUT_DE_LA_MEMOIRE_VIRTUELLE_LOCALE + taille_de_la_memoire_virtuelle_par_serveur - UNITE)                         \
                                        /* Dernier octet de la memoire virtuelle supportee par le serveur associe naturellement      */ \
                                        /* au processeur local.                                                                      */

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   F O N C T I O N S   D E   C O M M U N I C A T I O N  :                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
typedef   struct    fonctions {
                              int       code_fonction;
                              int       adresse_relative;
                              int       longueur;
                              }         fonctions;
                                        /* Bloc descriptif de la fonction demandee a un serveur...                                   */
enum      Liste_des_codes_des_fonctions
          {
           DEBUT=CLEAR
          ,FIN
          ,STORE
          ,LOAD
          ,SWAP
          };
                                        /* Liste des fonctions reconnues...                                                          */
#define   iLONGUEUR_FONCTIONS                                                                                                           \
                    (int)sizeof(fonctions)                                                                                              \
                                        /* Et nombre d'octets necessaires au codage...                                               */

#define   Read(processeur,octets_a_lire,nombre_d_octets_a_lire)                                                                         \
                    {                                                                                                                   \
                    int       itype;                                                                                                    \
                    int       iflag;                                                                                                    \
                    int       longueur;                                                                                                 \
                                                                                                                                        \
                    processeur_emetteur = MAPPING(processeur);                                                                          \
                    processeur_attendu = processeur_emetteur;                                                                           \
                    iflag = iUNDEF;                                                                                                     \
                    itype = iITYPE;                                                                                                     \
                    longueur = nread(octets_a_lire,nombre_d_octets_a_lire,&processeur_attendu,&itype,&iflag);                           \
                                                                                                                                        \
                    if        (    ((processeur_attendu != processeur_emetteur) && (processeur_emetteur != ANY))                        \
                              ||   (longueur != nombre_d_octets_a_lire)                                                                 \
                               )                                                                                                        \
                              {                                                                                                         \
                              fprintf(stderr,"\n erreur de lecture");                                                                   \
                              fprintf(stderr,"\n processeur attendu=%d",processeur_attendu);                                            \
                              fprintf(stderr,"\n processeur emetteur=%d",processeur_emetteur);                                          \
                              fprintf(stderr,"\n nombre d'octets a lire=%d",nombre_d_octets_a_lire);                                    \
                              fprintf(stderr,"\n nombre d'octets recuperes=%d",longueur);                                               \
                              exit();                                                                                                   \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                    processeur_attendu = MAPPING_INVERSE(processeur_attendu);                                                           \
                    }                                                                                                                   \
                                        /* Procedure generale de lecture...                                                          */
#define   Write(processeur,octets_a_ecrire,nombre_d_octets_a_ecrire)                                                                    \
                    {                                                                                                                   \
                    int       itype;                                                                                                    \
                    int       iflag;                                                                                                    \
                    int       longueur;                                                                                                 \
                                                                                                                                        \
                    processeur_recepteur = MAPPING(processeur);                                                                         \
                    itype = iITYPE;                                                                                                     \
                    iflag = iUNDEF;                                                                                                     \
                    longueur = nwrite(octets_a_ecrire,nombre_d_octets_a_ecrire,processeur_recepteur,itype,&iflag);                      \
                    }                                                                                                                   \
                                        /* Procedure generale d'ecriture...                                                          */

static    int       il_faut_entrelacer=OK;
                                        /* Indique s'il faut entrelacer (=OK) ou pas (#OK)...                                        */
#define   ENTRELACAGE(adresse_absolue_octets)                                                                                           \
                    ((il_faut_entrelacer == OK) ? entrelacage(adresse_absolue_octets) : (adresse_absolue_octets))                       \
                                        /* Definition de la fonction d'entrelacage. Pour le supprimer, il suffit de definir :        */ \
                                        /*                                                                                           */ \
                                        /*                  #define   ENTRELACAGE(adresse_absolue_octets)                         \  */ \
                                        /*                                      adresse_absolue_octets                               */ \
                                        /*                                                                                           */

#define   validation_d_une_adresse(adresse_absolue_octets,nombre_d_octets)                                                              \
                    {                                                                                                                   \
                    if        (    ((adresse_absolue_octets) / unite_d_entrelacage)                                                     \
                              !=   (((adresse_absolue_octets) + (nombre_d_octets) - UNITE) / unite_d_entrelacage)                       \
                               )                                                                                                        \
                              {                                                                                                         \
                              fprintf(stderr                                                                                            \
                                     ,"l'intervalle [%08x,%08x] n'est pas dans une unite d'entrelacage %08x\n"                          \
                                     ,(adresse_absolue_octets)                                                                          \
                                     ,(adresse_absolue_octets) + (nombre_d_octets) - UNITE                                              \
                                     ,unite_d_entrelacage                                                                               \
                                      );                                                                                                \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                    }                                                                                                                   \
                                        /* Validation d'une adresse octets par rapport aux parametres d'entrelacage...               */

#define   Interface_load_store(fonction,adresse_absolue_octets,nombre_d_octets)                                                         \
                    int       adresse_entrelacee=UNDEF;                                                                                 \
                    fonctions Fonction;                                                                                                 \
                                                                                                                                        \
                    adresse_entrelacee=ENTRELACAGE(adresse_absolue_octets);                                                             \
                    Fonction.code_fonction = fonction;                                                                                  \
                    Fonction.adresse_relative = ADRESSE_ABSOLUE__ADRESSE_RELATIVE(adresse_entrelacee);                                  \
                    Fonction.longueur = nombre_d_octets;                                                                                \
                                        /* Definition des donnees communes a 'load(...)' et 'store(...)'.                            */

#define   load(adresse_absolue_octets,octets_a_lire,nombre_d_octets_a_lire)                                                             \
                    {                                                                                                                   \
                    Interface_load_store(LOAD,adresse_absolue_octets,nombre_d_octets_a_lire);                                           \
                                                                                                                                        \
                    validation_d_une_adresse(adresse_absolue_octets,nombre_d_octets_a_lire);                                            \
                                                                                                                                        \
                    Write(ADRESSE_ABSOLUE__PROCESSEUR(adresse_entrelacee),&Fonction,iLONGUEUR_FONCTIONS);                               \
                                        /* Transmission d'une demande de "load" de valeur...                                         */ \
                    Read(ADRESSE_ABSOLUE__PROCESSEUR(adresse_entrelacee),octets_a_lire,Fonction.longueur);                              \
                                        /* Recuperation de la valeur...                                                              */ \
                    }                                                                                                                   \
                                        /* Procedure d'acces a la valeur de 'octets_a_lire' dans la memoire virtuelle...             */
#define   store(adresse_absolue_octets,octets_a_ecrire,nombre_d_octets_a_ecrire)                                                        \
                    {                                                                                                                   \
                    Interface_load_store(STORE,adresse_absolue_octets,nombre_d_octets_a_ecrire);                                        \
                                                                                                                                        \
                    validation_d_une_adresse(adresse_absolue_octets,nombre_d_octets_a_ecrire);                                          \
                                                                                                                                        \
                    Write(ADRESSE_ABSOLUE__PROCESSEUR(adresse_entrelacee),&Fonction,iLONGUEUR_FONCTIONS);                               \
                                        /* Transmission d'une demande de "store" de valeur...                                        */ \
                    Write(ADRESSE_ABSOLUE__PROCESSEUR(adresse_entrelacee),octets_a_ecrire,Fonction.longueur);                           \
                                        /* Envoi de la valeur.                                                                       */ \
                    }                                                                                                                   \
                                        /* Procedure de rangement de la valeur de 'octets_a_ecrire' dans la memoire virtuelle...     */

#define   action_de_debut_pour_les_serveurs                                                                                             \
                    {                                                                                                                   \
                    }                                                                                                                   \
                                        /* Procedure indiquant qu'un serveur va debuter son travail...                               */
#define   action_de_fin_pour_les_serveurs                                                                                               \
                    {                                                                                                                   \
                    }                                                                                                                   \
                                        /* Procedure indiquant qu'un serveur a fini son travail...                                   */

#define   action_de_debut_pour_les_clients                                                                                              \
                    {                                                                                                                   \
                    int       processeur;                                                                                               \
                                                                                                                                        \
                    for       (processeur=PREMIER_PROCESSEUR ; processeur<(PREMIER_PROCESSEUR+nombre_total_processeurs) ; processeur++) \
                              {                                                                                                         \
                              if        (EST_SERVEUR(MAPPING(processeur)))                                                              \
                                        {                                                                                               \
                                        Interface_load_store(DEBUT,UNDEF,UNDEF);                                                        \
                                        Write(processeur,&Fonction,iLONGUEUR_FONCTIONS);                                                \
                                        /* Transmission d'une demande de debut...                                                    */ \
                                        Read(processeur,&Fonction,iLONGUEUR_FONCTIONS);                                                 \
                                        /* Et synchronisation sur le serveur en recuperant tout simplement la fonction envoyee ;     */ \
                                        /* ainsi, on ne demarre un client que lorsque tous les serveurs sont prets...                */ \
                                        }                                                                                               \
                              else                                                                                                      \
                                        {                                                                                               \
                                        }                                                                                               \
                              }                                                                                                         \
                    }                                                                                                                   \
                                        /* Procedure indiquant qu'un client va debuter son travail...                                */
#define   action_de_fin_pour_les_clients                                                                                                \
                    {                                                                                                                   \
                    int       processeur;                                                                                               \
                                                                                                                                        \
                    for       (processeur=PREMIER_PROCESSEUR ; processeur<(PREMIER_PROCESSEUR+nombre_total_processeurs) ; processeur++) \
                              {                                                                                                         \
                              if        (EST_SERVEUR(MAPPING(processeur)))                                                              \
                                        {                                                                                               \
                                        Interface_load_store(FIN,UNDEF,UNDEF);                                                          \
                                        Write(processeur,&Fonction,iLONGUEUR_FONCTIONS);                                                \
                                        /* Transmission d'une demande de fin...                                                      */ \
                                        }                                                                                               \
                              else                                                                                                      \
                                        {                                                                                               \
                                        }                                                                                               \
                              }                                                                                                         \
                    }                                                                                                                   \
                                        /* Procedure indiquant qu'un client a fini son travail...                                    */

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   F O N C T I O N S   D E   C O M M U N I C A T I O N  :                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   MStoreC(adresse_absolue,longueur_octets,valeur)                                                                               \
                    {                                                                                                                   \
                    store(((adresse_absolue)*iLONGUEUR_caractere),&valeur,longueur_octets);                                             \
                    }                                                                                                                   \
                                        /* Procedure de rangement d'un caractere.                                                    */
#define   MLoadC(adresse_absolue,longueur_octets,valeur)                                                                                \
                    {                                                                                                                   \
                    load(((adresse_absolue)*iLONGUEUR_caractere),&valeur,longueur_octets);                                              \
                    }                                                                                                                   \
                                        /* Procedure d'acces a un caractere.                                                         */

#define   StoreC(adresse_absolue,valeur)                                                                                                \
                    {                                                                                                                   \
                    MStoreC(adresse_absolue,iLONGUEUR_caractere,valeur);                                                                \
                    }                                                                                                                   \
                                        /* Procedure de rangement d'un caractere.                                                    */
#define   LoadC(adresse_absolue,valeur)                                                                                                 \
                    {                                                                                                                   \
                    MLoadC(adresse_absolue,iLONGUEUR_caractere,valeur);                                                                 \
                    }                                                                                                                   \
                                        /* Procedure d'acces a un caractere.                                                         */

#define   MStoreI(adresse_absolue,longueur_octets,valeur)                                                                               \
                    {                                                                                                                   \
                    store(((adresse_absolue)*iLONGUEUR_entier),&valeur,longueur_octets);                                                \
                    }                                                                                                                   \
                                        /* Procedure de rangement d'un nombre entier.                                                */
#define   MLoadI(adresse_absolue,longueur_octets,valeur)                                                                                \
                    {                                                                                                                   \
                    load(((adresse_absolue)*iLONGUEUR_entier),&valeur,longueur_octets);                                                 \
                    }                                                                                                                   \
                                        /* Procedure d'acces a un nombre entier.                                                     */

#define   StoreI(adresse_absolue,valeur)                                                                                                \
                    {                                                                                                                   \
                    MStoreI(adresse_absolue,iLONGUEUR_entier,valeur);                                                                   \
                    }                                                                                                                   \
                                        /* Procedure de rangement d'un nombre entier.                                                */
#define   LoadI(adresse_absolue,valeur)                                                                                                 \
                    {                                                                                                                   \
                    MLoadI(adresse_absolue,iLONGUEUR_entier,valeur);                                                                    \
                    }                                                                                                                   \
                                        /* Procedure d'acces a un nombre entier.                                                     */

#define   MStoreF(adresse_absolue,longueur_octets,valeur)                                                                               \
                    {                                                                                                                   \
                    store(((adresse_absolue)*iLONGUEUR_flottant),&valeur,longueur_octets);                                              \
                    }                                                                                                                   \
                                        /* Procedure de rangement d'un nombre flottant.                                              */
#define   MLoadF(adresse_absolue,longueur_octets,valeur)                                                                                \
                    {                                                                                                                   \
                    load(((adresse_absolue)*iLONGUEUR_flottant),&valeur,longueur_octets);                                               \
                    }                                                                                                                   \
                                        /* Procedure d'acces a un nombre flottant.                                                   */

#define   StoreF(adresse_absolue,valeur)                                                                                                \
                    {                                                                                                                   \
                    MStoreF(adresse_absolue,iLONGUEUR_flottant,valeur);                                                                 \
                    }                                                                                                                   \
                                        /* Procedure de rangement d'un nombre flottant.                                              */
#define   LoadF(adresse_absolue,valeur)                                                                                                 \
                    {                                                                                                                   \
                    MLoadF(adresse_absolue,iLONGUEUR_flottant,valeur);                                                                  \
                    }                                                                                                                   \
                                        /* Procedure d'acces a un nombre flottant.                                                   */

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   F O N C T I O N S   D E   S Y N C H R O N I S A T I O N  :                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   UNLOCK                                                                                                                        \
                    CLEAR                                                                                                               \
                                        /* Etat d'un verrou libre...                                                                 */
#define   LOCK                                                                                                                          \
                    (UNLOCK + UNITE)                                                                                                    \
                                        /* Etat d'un verrou occupe...                                                                */

#define   TestAndSetI(adresse_absolue,valeur)                                                                                           \
                    {                                                                                                                   \
                    int       valeur_a_forcer=valeur;                                                                                   \
                                        /* Memorisation de la valeur que l'on desire forcer ; elle est rendue necessaire a cause     */ \
                                        /* de l'ordre du 'Read(...)' et du 'Write(...)' portant sur cette valeur...                  */ \
                    int       adresse_absolue_en_octets=(adresse_absolue)*iLONGUEUR_entier;                                             \
                    Interface_load_store(SWAP,adresse_absolue_en_octets,iLONGUEUR_entier);                                              \
                                                                                                                                        \
                    Write(ADRESSE_ABSOLUE__PROCESSEUR(adresse_entrelacee),&Fonction,iLONGUEUR_FONCTIONS);                               \
                                        /* Transmission d'une demande de "swap" de valeur...                                         */ \
                    Read(ADRESSE_ABSOLUE__PROCESSEUR(adresse_entrelacee),&valeur,Fonction.longueur);                                    \
                                        /* Recuperation de la valeur avant,                                                          */ \
                    Write(ADRESSE_ABSOLUE__PROCESSEUR(adresse_entrelacee),&valeur_a_forcer,Fonction.longueur);                          \
                                        /* Puis envoi de la valeur apres...                                                          */ \
                    }                                                                                                                   \
                                        /* Procedure d'echange d'un nombre entier afin de faire des synchronisations...              */

#define   WaitVerrou(verrou_global,verrou_local)                                                                                        \
                    {                                                                                                                   \
                    int        verrou_local=LOCK;                                                                                       \
                                        /* Definition de l'etat local du verrou global de protection d'une phase critique...         */ \
                    while     (verrou_local == LOCK)                                                                                    \
                                        /* La premiere fois le verrou est a 1 afin de forcer le 'TestAndSetI(...)' qui suit. Ensuite */ \
                                        /* tant qu'il reste a 1, cela signifie qu'il etait deja a 1 dans la memoire virtuelle, et    */ \
                                        /* donc qu'un autre processeur le possede deja...                                            */ \
                              {                                                                                                         \
                              TestAndSetI(verrou_global,verrou_local);                                                                  \
                                        /* Tentative d'entree dans une phase critique...                                             */ \
                              }                                                                                                         \
                                        /* ATTENTION, on notera le desequilibre des "{" et des "}" afin que 'WaitVerrou(...)' et     */ \
                                        /* 'ClearVerrou(...)' forment une paire de parentheses...                                    */ \
                                                                                                                                        \
                                        /* Procedure d'attente sur un verrou.                                                        */
#define   ClearVerrou(verrou_global,verrou_local)                                                                                       \
                                        /* ATTENTION, on notera le desequilibre des "{" et des "}" afin que 'WaitVerrou(...)' et     */ \
                                        /* 'ClearVerrou(...)' forment une paire de parentheses...                                    */ \
                    verrou_local = UNLOCK;                                                                                              \
                    StoreI(verrou_global,verrou_local);                                                                                 \
                                        /* Sortie de la phase critique...                                                            */ \
                    }                                                                                                                   \
                                        /* Procedure de liberation d'un verrou...                                                    */

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        M A P P I N G   E N T R E   L E S   P R O C E S S E U R S                                                                  */
/*        L O G I Q U E S   E T   L E S   P R O C E S S E U R S   P H Y S I Q U E S                                                  */
/*        P O U R   L A   M E M O I R E   V I R T U E L L E  :                                                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
static    int       il_faut_mapper=NOK;
                                        /* Indique s'il faut mapper (=OK) ou pas (#OK)...                                            */

#define   MAPPING(processeur)                                                                                                           \
                    ((processeur == ANY) ? processeur : (*(mapping_des_processeurs+(processeur-PREMIER_PROCESSEUR))))                   \
                                        /* Fonction de mapping...                                                                    */
#define   MAPPING_INVERSE(processeur)                                                                                                   \
                    ((processeur == ANY) ? processeur : (*(mapping_inverse_des_processeurs+(processeur-PREMIER_PROCESSEUR))))           \
                                        /* Fonction de mapping inverse...                                                            */

static    int       *mapping_des_processeurs;
static    int       *mapping_inverse_des_processeurs;
                                        /* Table de definition du mapping entre les processeurrs physiques et logiques.              */

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   I M P L A N T A T I O N S                                                                    */
/*        D A N S   L A   M E M O I R E   V I R T U E L L E  :                                                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   UNITE_D_ENTRELACAGE                                                                                                           \
                    iLONGUEUR_flottant
static    int       unite_d_entrelacage=UNITE_D_ENTRELACAGE;
                                        /* Definition de la longueur des blocs qui ne doivent pas etre decoupes lors de l'operation  */
                                        /* d'entrelacage...                                                                          */

#define   FORMAT_DEBUT_DE_LA_MEMOIRE_VIRTUELLE                                                                                          \
                    iLONGUEUR_caractere
#define   LONGUEUR_DEBUT_DE_LA_MEMOIRE_VIRTUELLE                                                                                        \
                    CLEAR
#define   DEBUT_DE_LA_MEMOIRE_VIRTUELLE                                                                                                 \
                    IMPLANTATION_EN_MEMOIRE_VIRTUELLE(ADRESSE_ABSOLUE_0                                                                 \
                                                     ,FORMAT_IMPLICITE_DE_LA_MEMOIRE_VIRTUELLE                                          \
                                                     ,FORMAT_DEBUT_DE_LA_MEMOIRE_VIRTUELLE                                              \
                                                      )
                                        /* Emplacement du debut de la memoire virtuelle.                                             */

#define   FRONTIERE_COMMUNE                                                                                                             \
                    unite_d_entrelacage                                                                                                 \
                                        /* Toutes les implantations en memoire virtuelle se feront sur des frontieres de 'FLOTTANT'. */

#define   FORMAT_IMPLICITE_DE_LA_MEMOIRE_VIRTUELLE                                                                                      \
                    iLONGUEUR_caractere                                                                                                 \
                                        /* Pour definir le premier element implante dans la memoire virtuelle.                       */

#define   MULTIPLE_SUPERIEUR(x,base)                                                                                                    \
                    ((((x) + (base) - UNITE) / (base) ) * (base))                                                                       \
                                        /* Calcul le multiple de 'base' immediatement superieur a 'x'...                             */

#define   IMPLANTATION_EN_MEMOIRE_VIRTUELLE(adresse_precedente_plus_longueur,unite_precedente,unite_courante)                           \
                    (MULTIPLE_SUPERIEUR(((adresse_precedente_plus_longueur)*(unite_precedente)),FRONTIERE_COMMUNE) / (unite_courante))  \
                                        /* Calcul de l'adresse d'implantation en memoire virtuelle de l'element courant en fonction  */ \
                                        /* de l'adresse d'implantation de l'element precedent et de leurs unites respectives. On     */ \
                                        /* notera que l'on se place de plus a une frontiere de 'FLOTTANT'. Enfin, l'adresse de       */ \
                                        /* l'objet courant est defini par rapport a l'objet precedent translate de la longueur de    */ \
                                        /* dernier, cette longueur etant exprimee dans l'unite 'unite_precedente' : ainsi, si par    */ \
                                        /* exemple l'objet precedent 'O1' est en entier, l'adresse de l'objet suivant 'O2' sera      */ \
                                        /* 'O1+1', et ce quel que soit le type de 'O2.'...                                           */
#define   ADRESSAGE_EN_MEMOIRE_VIRTUELLE(adresse_de_l_objet,deplacement)                                                                \
                    ((adresse_de_l_objet) + (deplacement))                                                                              \
                                        /* Acces a un element 'deplacement' d'un objet 'adresse_de_l_objet'...                       */

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D O N N E E S   G L O B A L E S  :                                                                                         */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
static    int       processeur_local;
                                        /* Identite du processeur local.                                                             */

static    int       dimension;
                                        /* Dimension (0,1,2,...) de l'hyper-cube alloue.                                             */
static    int       nproc;
                                        /* Donne dans les deux octets de poids faible la meme information que 'processeur_local',    */
                                        /* et dans les deux octets de poids forts le numero du process courant.                      */
static    int       nhost;
                                        /* Donne un identificateur 'ID' d'un programme host.                                         */
static    int       nombre_total_processeurs;
                                        /* Nombre total de processeurs disponibles.                                                  */
static    int       nombre_total_de_serveurs;
static    int       nombre_total_de_clients;
                                        /* Nombre total de serveurs et de clients.                                                   */
static    int       taille_de_la_memoire_virtuelle;
                                        /* Taille totale de la memoire virtuelle.                                                    */
static    int       taille_de_la_memoire_virtuelle_par_serveur;
                                        /* Taille de la memoire virtuelle supportee par chaque serveur.                              */

static    int       processeur_emetteur;
static    int       processeur_recepteur;
static    int       processeur_attendu;

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F O N C T I O N   D ' E N T R E L A C A G E   D E S   A D R E S S E S  :                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
int       entrelacage(adresse_absolue)
int       adresse_absolue;
          {
          int       adresse_entrelacee=UNDEF;

          int       numero_de_page=ADRESSE_ABSOLUE__NUMERO_DE_PAGE(adresse_absolue);
          int       adresse_relative=ADRESSE_ABSOLUE__ADRESSE_RELATIVE(adresse_absolue);

          int       bits_de_poids_faibles_de_l_adresse_relative=UNDEF;
          int       bits_de_poids_forts_et_moyens_de_l_adresse_relative=UNDEF;
          int       bits_de_poids_moyens_de_l_adresse_relative=UNDEF;
          int       bits_de_poids_forts_de_l_adresse_relative=UNDEF;

          bits_de_poids_faibles_de_l_adresse_relative = (adresse_relative % unite_d_entrelacage);
          bits_de_poids_forts_et_moyens_de_l_adresse_relative = (adresse_relative / unite_d_entrelacage);
          bits_de_poids_moyens_de_l_adresse_relative = (bits_de_poids_forts_et_moyens_de_l_adresse_relative % nombre_total_de_serveurs);
          bits_de_poids_forts_de_l_adresse_relative = (bits_de_poids_forts_et_moyens_de_l_adresse_relative / nombre_total_de_serveurs);

          adresse_entrelacee = NUMERO_DE_PAGE__ADRESSE_ABSOLUE(SERVEUR__NUMERO_DE_PAGE(bits_de_poids_moyens_de_l_adresse_relative))
                               + ((bits_de_poids_forts_de_l_adresse_relative*nombre_total_de_serveurs)
                               + numero_de_page)*unite_d_entrelacage
                               + bits_de_poids_faibles_de_l_adresse_relative;
                                        /* Definition de l'entrelacage :                                                             */
                                        /*                                                                                           */
                                        /*                   -----------------------------------------------------------             */
                                        /*                  |              |              |              |              |            */
                                        /* adresse absolue  |    numero    |    poids     |    poids     |    poids     |            */
                                        /* non  entrelacee  |   de  page   |    forts     |    moyens    |   faibles    |            */
                                        /*                  |              |              |              |              |            */
                                        /*                   -----------------------------------------------------------             */
                                        /*                  .              .              .              .              .            */
                                        /*                  .              .              .              .              .            */
                                        /*                  .    nombre    .              .   nombre     . longueur des .            */
                                        /*                  . de  serveurs .              . de  serveurs .  FLOTTANTs   .            */
                                        /*                  .              .              .              .              .            */
                                        /*                  .              .                                            .            */
                                        /*                  .              . taille de la memoire virtuelle par serveur .            */
                                        /*                  .              .                                            .            */
                                        /*                                                                                           */
                                        /*                         #              =              #              =                    */
                                        /*                            #           =           #                 =                    */
                                        /*                               #        =        #                    =                    */
                                        /*                                  #     =     #                       =                    */
                                        /*                                     #  =  #                          =                    */
                                        /*                                        #                             =                    */
                                        /*                                     #  =  #                          =                    */
                                        /*                                  #     =     #                       =                    */
                                        /*                               #        =        #                    =                    */
                                        /*                            #           =           #                 =                    */
                                        /*                         #              =              #              =                    */
                                        /*                                                                                           */
                                        /*                   -----------------------------------------------------------             */
                                        /*                  |              |              |              |              |            */
                                        /* adresse absolue  |    poids     |    poids     |    numero    |    poids     |            */
                                        /*   entrelacee     |    moyens    |    forts     |   de  page   |   faibles    |            */
                                        /*                  |              |              |              |              |            */
                                        /*                   -----------------------------------------------------------             */
                                        /*                  .              .              .              .              .            */
                                        /*                  .              .              .              .              .            */
                                        /*                  .    nombre    .              .   nombre     . longueur des .            */
                                        /*                  . de  serveurs .              . de  serveurs .  FLOTTANTs   .            */
                                        /*                  .              .              .              .              .            */
                                        /*                  .              .                                            .            */
                                        /*                  .              . taille de la memoire virtuelle par serveur .            */
                                        /*                  .              .                                            .            */
                                        /*                                                                                           */
          return(adresse_entrelacee);
          }

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        C O D E   D E S   S E R V E U R S  :                                                                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
serveur()
          {
          if        (nombre_total_de_clients > RIEN)
                    {
                    if        (    (    (taille_de_la_memoire_virtuelle_par_serveur >= iLONGUEUR_caractere)
                                   &&   (taille_de_la_memoire_virtuelle_par_serveur >= iLONGUEUR_entier)
                                   &&   (taille_de_la_memoire_virtuelle_par_serveur >= iLONGUEUR_flottant)
                                   &&   (taille_de_la_memoire_virtuelle_par_serveur >= unite_d_entrelacage)
                                    )
                              &&   (    ((taille_de_la_memoire_virtuelle_par_serveur % iLONGUEUR_caractere) == RIEN)
                                   &&   ((taille_de_la_memoire_virtuelle_par_serveur % iLONGUEUR_entier) == RIEN)
                                   &&   ((taille_de_la_memoire_virtuelle_par_serveur % iLONGUEUR_flottant) == RIEN)
                                   &&   ((taille_de_la_memoire_virtuelle_par_serveur % unite_d_entrelacage) == RIEN)
                                    )
                               )
                              {
                              int       nombre_de_clients_enregistres=CLEAR;
                                        /* Pour compter les clients qui se sont enregistres...                                       */
                              int       octet_courant;
                              static    CHAR      *memoire_virtuelle;
                              Malloc(memoire_virtuelle,taille_de_la_memoire_virtuelle_par_serveur);
                                        /* Allocation de la memoire virtuelle dans chaque serveur.                                   */

                              for       (octet_courant=(ADRESSE_RELATIVE_0) ;
                                         octet_courant<(ADRESSE_RELATIVE_0+taille_de_la_memoire_virtuelle_par_serveur) ;
                                         octet_courant++
                                         )
                                        {
                                        *(memoire_virtuelle+octet_courant) = CLEAR;
                                        /* Nettoyage initial non optimise (octet par octet) de la memoire virtuelle...               */
                                        }

                              while     (nombre_total_de_clients > RIEN)
                                        {
                                        fonctions  fonction;
                                        Read(ANY,&fonction,iLONGUEUR_FONCTIONS);
                                        /* Recuperation de la fonction demandee par 'processeur_attendu' :                           */

                                        switch((int)fonction.code_fonction)
                                                  {
                                                  case      DEBUT:
                                                            {
                                                            Write(processeur_attendu
                                                                 ,&fonction
                                                                 ,iLONGUEUR_FONCTIONS
                                                                  );
                                        /* Et on renvoie tout simplement la fonction...                                              */
                                                            nombre_de_clients_enregistres++;
                                        /* On compte le nombre de processeurs enregistres. On notera qu'il est impossible de         */
                                        /* verifier simplement que 'nombre_de_clients_enregistres' atteint bien sa valeur maximale   */
                                        /* (c'est-a-dire 'nombre_total_de_clients'), car en effet, les demandes 'DEBUT' d'un certain */
                                        /* client peuvent s'imbriquer avec les 'STORE' et 'LOAD' des autres, auquel cas les tests    */
                                        /* que l'on pourrait faire alors ne seraient pas definitifs, et donneraient donc des         */
                                        /* messages d'erreurs temporaires et non justifies...                                        */
                                                            break;
                                                            }
                                                  case      FIN:
                                                            {
                                                            nombre_total_de_clients--;
                                        /* On decremente le nombre de processeurs potentiels...                                      */
                                                            break;
                                                            }
                                                  case      STORE:
                                                            {
                                                            Read(processeur_attendu
                                                                ,memoire_virtuelle+fonction.adresse_relative
                                                                ,fonction.longueur
                                                                 );
                                        /* Rangement dans la memoire virtuelle de la valeur demandee...                              */
                                                            break;
                                                            }
                                                  case      LOAD:
                                                            {
                                                            Write(processeur_attendu
                                                                 ,memoire_virtuelle+fonction.adresse_relative
                                                                 ,fonction.longueur
                                                                  );
                                        /* Transmission de la valeur demandee...                                                     */
                                                            break;
                                                            }
                                                  case      SWAP:
                                                            {
                                                            Write(processeur_attendu
                                                                 ,memoire_virtuelle+fonction.adresse_relative
                                                                 ,fonction.longueur
                                                                  );
                                                            Read(processeur_attendu
                                                                ,memoire_virtuelle+fonction.adresse_relative
                                                                ,fonction.longueur
                                                                 );
                                        /* Echange de la valeur demandee...                                                          */
                                                            break;
                                                            }
                                                  default:
                                                            {
                                                            fprintf(stderr
                                                                   ,"\n fonction non reconnue (code=%d)"
                                                                   ,(int)fonction.code_fonction
                                                                    );
                                                            break;
                                                            }
                                                  }
                                        }
                                        /* Fin d'activite du serveur...                                                              */

                              free(memoire_virtuelle);
                                        /* Desallocation de la memoire virtuelle dans chaque serveur.                                */
                              }
                    else
                              {
                              fprintf(stderr,"\n la taille de la memoire virtuelle n'est pas adaptee aux structures manipulees");
                              fprintf(stderr,"\n chaque serveur supporte %x octets",taille_de_la_memoire_virtuelle_par_serveur);
                              }
                    }
          else
                    {
                    fprintf(stderr,"\n il faut au moins %d processeurs (1)",PROCESSEURS);
                    fprintf(stderr,"\n ATTENTION, il est impossible de passer par ici");
                                        /* ATTENTION, il est impossible de passer par ici a cause de la validation faite dans        */
                                        /* 'main()' au sujet de 'nombre_total_processeurs'...                                        */
                    }

          return(OK);
          }

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P R O G R A M M E   P R I N C I P A L  :                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
main()
          {

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        R E C U P E R A T I O N   D E   L A   C O N F I G U R A T I O N   D E   " R U N "  :                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
          whoami(&processeur_local,&nproc,&nhost,&dimension);
          nombre_total_processeurs = PUISSANCE2(dimension);
          nombre_total_de_serveurs = nombre_total_processeurs/PROCESSEURS;
          nombre_total_de_clients = nombre_total_processeurs - nombre_total_de_serveurs;
                                        /* Recuperation de la configuration locale allouee.                                          */
          taille_de_la_memoire_virtuelle = TAILLE_DE_LA_MEMOIRE_VIRTUELLE;
                                        /* Taille totale de la memoire virtuelle.                                                    */
          if        (nombre_total_processeurs >= PROCESSEURS)
                    {
                    taille_de_la_memoire_virtuelle_par_serveur = taille_de_la_memoire_virtuelle / nombre_total_de_serveurs;
                                        /* Taille de la memoire virtuelle supportee par chaque serveur.                              */
                    if        ((taille_de_la_memoire_virtuelle % nombre_total_de_serveurs) == RIEN)
                              {
                              int       processeur;
                              Malloc(mapping_des_processeurs,nombre_total_processeurs*iLONGUEUR_entier);
                              Malloc(mapping_inverse_des_processeurs,nombre_total_processeurs*iLONGUEUR_entier);
                                        /* Allocation de la memoire virtuelle dans chaque serveur.                                   */
                              for       (processeur=(PREMIER_PROCESSEUR) ;
                                         processeur<(PREMIER_PROCESSEUR+nombre_total_processeurs) ;
                                         processeur++
                                         )
                                        {
                                        int       processeurL=processeur;
                                        int       processeurP=processeur;
                                        /* A priori, on initialise sur un "mapping" neutre (1 pour 1) pour la memoire virtuelle...   */

                                        if        (il_faut_mapper == OK)
                                                  {
                                                  if        (EST_SERVEUR(processeur))
                                                            {
                                                            processeurP=PREMIER_PROCESSEUR
                                                                       +(nombre_total_processeurs-UNITE)
                                                                       -((processeur-PREMIER_PROCESSEUR)+UNITE);
                                        /* Cette definition inverse l'ordre des serveurs...                                          */
                                                            }
                                                  else
                                                            {
                                                            processeurP=PREMIER_PROCESSEUR
                                                                       +(nombre_total_processeurs-UNITE)
                                                                       -((processeur-PREMIER_PROCESSEUR)-UNITE);
                                        /* Cette definition inverse l'ordre des clients...                                           */
                                                            }
                                                  }
                                        else
                                                  {
                                                  }

                                        *(mapping_des_processeurs+(processeurL-PREMIER_PROCESSEUR)) = processeurP;
                                        *(mapping_inverse_des_processeurs+(processeurP-PREMIER_PROCESSEUR)) = processeurL;
                                        }

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        C O M M U N I C A T I O N  :                                                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
                              if        (EST_SERVEUR(MAPPING(processeur_local)))
                                        {
                                        action_de_debut_pour_les_serveurs;
                                        /* Action de debut...                                                                        */

                                        serveur();
                                        /* Code specifique des serveurs.                                                             */

                                        action_de_fin_pour_les_serveurs;
                                        /* Action de fin...                                                                          */
                                        }
                              else
                                        {
                                        action_de_debut_pour_les_clients;
                                        /* Action de debut...                                                                        */

                                        client();
                                        /* Code specifique des clients.                                                              */

                                        action_de_fin_pour_les_clients;
                                        /* Action de fin...                                                                          */
                                        }

/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F I N   D E S   T R A I T E M E N T S  :                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
                              free(mapping_inverse_des_processeurs);
                              free(mapping_des_processeurs);
                              }
                    else
                              {
                              fprintf(stderr,"\n la taille de la memoire virtuelle est mauvaise");
                              }
                    }
          else
                    {
                    fprintf(stderr,"\n il faut au moins %d processeurs (2)",PROCESSEURS);
                    }
          exit();
          }




Copyright (c) Jean-François Colonna, 1997-2014.
Copyright (c) France Telecom R&D and CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 1997-2014.