IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C Discussion :

Generation distribué d'espace d'etat : correction de code


Sujet :

C

  1. #1
    Membre éclairé Avatar de menoulette
    Inscrit en
    Août 2009
    Messages
    320
    Détails du profil
    Informations forums :
    Inscription : Août 2009
    Messages : 320
    Par défaut Generation distribué d'espace d'etat : correction de code
    Bonjour,

    l'explication de mon programme:

    On considère un ensemble de N machines : W0, W1, W2,………. Wn-1 et un système représente par un modèle M. Soit s0 son état initial et Succ une fonction de succession permettant de calculer, pour un état quelconque s : l'ensemble de ses états successeurs.
    L'idée de l'algorithme de génération est relativement simple. Il s'agit de distribuer la charge de calcul des états successeurs entre les différentes machines. Chaque machine Wi explore un ensemble d'états Si.
    L'ensemble Si est calculé à partir d'une fonction d'attribution d'états aux machines :
    h : S mode [0, N - 1] (S est l'ensemble de tous les états du système et N est l’ensemble des processus).
    La fonction d'attribution d'états ou la fonction de hachage est utilisée pour partitionner les états sur les processeurs. Elle est simple à implémenter et présente de bons résultats en cout de calcul et de mémoire. La fonction de hachage fournie par l’utilisateur a l’avantage, si elle est bien définie, d’équilibrer la partition de charge de travail par processeur, et d’obtenir également de bons temps d’exécution:
    bon le code en c suivant représente ce que je viens de dire :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    #include <stdio.h>
     
    #include "mpi.h"
     
    #include <stdlib.h>
     
    /* declaration d'une liste */
     
    typedef struct Liste {
    int s;
    struct Liste * Suivant;
     
    };
     
    struct Liste *Nouveau;
     
    struct Liste *Tete;
    tete =null;
    Nouveau = (Liste*)malloc(sizeof( Liste));
    Nouveau->Suivant = Tete;
     
    Tete = NULL;
     
    void affichage(Liste *tete)
    {
    Liste* courant = NULL;
    courant = tete;
     
    while (courant!=NULL)
    {
    printf("%d",(courant->s));
    courant = courant->suivant;
    }
     
     
    }
     
     
    /* la fonction hasard() pour calculer le nombre de successeur */
     
    int hasard(int min, int max);
     
     
     
     
    int hasard(int min, int max){
    return (int) (min + ((float) rand() / RAND_MAX * (max - min + 1)));
    }
     
    /*la fonction hachage pour distribué le etats sur les machine */
     
    /* s:l'ensemble de tous les états du système.p:l’ensemble des processus*/
    int hachage (int s,int p);
    int hachage (int s,int p){
    return (int)(s % p);
    }
    void succ(int s,Liste *succ1)
     
     
    {
     
    int nbsucc=hasard(0,10);
     
    printf("%d",nbsucc);
     
    printf("\n");
     
     
    int alea;
    int i;
     
    Liste*p=succ1;
    succ1->tete=nbsucc;
     
    int min=0;
     
    int max=100;
     
    for(i=0; i<nbsucc;i++)
    {
    alea = hasard(min, max);
    if(i && succ1)
    p->suivant=alea;
     
     
    //printf("%d:successeur %d=%d\n",s,i,alea);
     
    }
     
     
    }
     
    /* programme principal */
     
     
    int main( int argc, char *argv[] )
     
    {
     
    int rank;
     
    int size;
     
     
    MPI_Init( 0, 0 );
     
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     
    MPI_Comm_size(MPI_COMM_WORLD, &size);
     
    // printf( "Hello world from process %d of %d\n", rank, size );
     
     
    int alea;
    int min = 1;
    int max = 60;
     
    int i;
     
    int s0=0,s1=2,s2=3;
    const n=11;
     
    succ(s0,Liste*succ2);
     
    Liste*tete;
     
    for (i=1;i<tete;i++)
     
    {
     
    printf("%d:successeur %d=%d\n",s0,i-1,succ2);
     
    }
     
    s1=tete->suivant;
     
    succ(s1,liste*succ2);
     
     
    for (i=1;i<tete;i++)
     
    {
     
    printf("%d:successeur %d=%d\n",s1,i-1,succ2);
     
    }
    int s=24;
    int p=7;
    int h=s % p;
    printf("%u\n",hachage (s,p));
    return (int)(h) ;
     
    void fusion( Liste*L1, Liste*L2,Liste*succ1,Liste*succ2)
    {
    int a=0, b=0;int h;
     
    Liste* V = L1;
    Liste* E = L2;
    Liste*p=succ1;
    Liste*p1=succ2
    while (V==NULL){
    if (h==rank){
    Succ=succ(s0);
    while( p!=NULL)
    {
    V->a = p->a;
    V = V->suivant;
    p = p->suivant;
    }
    while (E==NULL && p1!=NULL)
    {
    E->a = p1->a;
    E = E->suivant;
    p1 = p1->suivant;
    }
    }
     
    else
    MPI_Send((void*) "etat ", SIZE*sizeof(char), MPI_CHAR, s, h, MPI_COMM_WORLD) ;
    fprintf(stderr,"%d envoie %s\n",myid,"etat") ;
     
     
    }
    MPI_Recv(buff, SIZE*sizeof(char), MPI_CHAR, 0, MPI_ANY_TAG, MPI_COMM_WORLD, &status) ;
    fprintf(stderr,"%d recoit %s\n",myid,buff) ;
     
     
    MPI_Finalize();
     
    return 0;
     
    }
    Mon problème c'est que mon code ne fonctionne pas comme je veux, je ne sais pas est ce qu'il suit le principe que je viens de dire ou je me trompe sur un point,

    je vous demande si quelqu'un peut me dire le problème de mon code que je vois pas ?

    Merci
    Amicalement

  2. #2
    Membre confirmé Avatar de sopsag
    Profil pro
    Inscrit en
    Octobre 2008
    Messages
    224
    Détails du profil
    Informations personnelles :
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Octobre 2008
    Messages : 224
    Par défaut
    heu...
    je ne comprends à peu près rien à ton problème...
    Première chose : ton code ne compile absolument pas !

    Écris un code qui compile avec plein de traces (genre printf("ici j'ajoute un elem a la liste machin")) et poste le, qu'on puisse le lancer et essayer de comprendre ce que tu as voulu faire...

  3. #3
    Membre éclairé Avatar de menoulette
    Inscrit en
    Août 2009
    Messages
    320
    Détails du profil
    Informations forums :
    Inscription : Août 2009
    Messages : 320
    Par défaut
    la compilation et l'execution se fait sous linux

Discussions similaires

  1. Réponses: 6
    Dernier message: 20/06/2007, 17h25
  2. [Etat] Trier depuis code Vb
    Par mariemor64 dans le forum IHM
    Réponses: 4
    Dernier message: 28/02/2007, 16h36
  3. Correction du code
    Par punisher999 dans le forum Langage
    Réponses: 8
    Dernier message: 28/01/2007, 21h26

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo