Newsgroup: it.comp.lang.c
Titolo: problema con librerie mpi

Salve a tutti,
dovrei far funzionare un programma parallelo che mi cerchi se ci sono delle 
sottostringhe 's' in una stringa più grande di tipo GEN, cioè quelle formate 
solo da lettere dell'alfabeto (A,C,T,G)..., e mi mandi in output le 
posizioni iniziali di queste sottostringhe.
Vi posto il codice di quello che ho fatto, ma non va:
#include <stdio.h>
#include <string.h>
#include <mpi.h>
//char stringa[4]; //Dichiarazione della sottostringa 's'//
//void strinput(void);
/* Una sequenza genomica è una stringa sull'alfabeto queternario [A,C,G,T]. 
Uno dei problemi di Bioinformatica
consiste nella ricerca della presenza si una sottostringa 's' in una 
sequenza genomica GEN */
/* Questo programma parallelo legge una sequenza GEN da file e una stringa 
's' da tastiera, la risposta del
programma sarà le prime posizioni in cui troviamo 's' in GEN.
Se 's' non è presente come sottostringa la riposta sarà nulla */
int main( int argc, char **argv) //Inizio funzione principale 'main' //
{
int myid; //Intero myid utile per l'identificazione del processore//
int err; //Intero per le chiamate MPI//
int nproc; //Numero di processori//
int root = 0; //Inizializzo a 0 root, tornerà utile per l'identificazione 
del processore principale//
err = MPI_Init ( &argc, &argv ); //Inizializza il supporto//
err = MPI_Comm_size ( MPI_COMM_WORLD, &nproc ); //Numero processori//
err = MPI_Comm_rank ( MPI_COMM_WORLD, &myid ); //Identificativo del 
processore//
/* In questa parte dichiaro le variabili che mi serviranno per la lettura 
del file */
int elementi; //n.elementi presenti nel file//
char buf[1000]; //buffer utilizzato per memorizzare il contenuto del file 
letto, quindi la nostra stringa GEN//
FILE *fp; //puntatore a file da leggere//
int nc; //misura della lunghezza della stringa GEN letta nel file o 
contattore caratteri//
int n;  //utilizzato per misurare la lunghezza della stringa GEN letta nel 
file o numero caratteri letti con fread()//
elementi = 1000; //numero elementi vettore//
int dimensione = 1; //rappresenta la dimensione in byte di un elemento del 
vettore//
int fine_file = 0; //indica la fine della lettura del file//
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
char stringa[4]="tgag";
int i,y,q;
int j=0; //contatore lunghezza sottostringa 's'//
char prima_lettera; //Dichiarazione prima lettera di 's'//
int p = 0; //contatore delle posizioni
int posizioni[90]; //Vettore posizioni utilizzato per memorizzare le 
posizioni di prima_lettera in buf[1000]//
int x,z,h;
char verifica[200]; //Vettore verifica utilizzato per memorizzare le 
stringhe formate da prima_lettera + le lettere successive ad essa in 
buf[1000]//
int pos_stringhe[10]; //Vettore dove vengono posizionate le prime posizioni 
di 's' che si trova in buf[1000], ovvero l'output che ci interessa//
int ncv[1]; //vettore unitario dove viene memorizzato il valore di nc//
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Controllo che l'id del processore sia quello di root, e se è così il 
processore principale esegue la lettura del file e la ricerca
di tutte le prime_lettere di 's' che trova in buf[1000]
1. Lettura file 'GEN' e memorizzazione contenuto in buf[1000]
2. Stampa della lunghezza della stringa GEN e della stringa GEN stessa
3. Raccolta della prima_lettera della sottostringa 's' e confronto con tutti 
gli elementi di buf[1000]
4. Apenna la prima_lettera di 's' corrisponde con qualche elemento di 
buf[1000] memorizza la posizione in un buffer (posizioni[])
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
if (myid==root) {
        fp = fopen ("GEN", "r"); //Apre il file GEN in sola lettura//
        if ( fp == NULL )   //Se il file non è presente nella directory 
corrente lo segnala con un messaggio di errore//
        printf("Errore, il file 'GEN' non esiste! Inserire il file 'GEN' 
nella stessa directory dell'eseguibile avviato.\n");
        else {
                nc = 0L; //Inizializza il contatore 'nc' all'inizio del 
file//
        do {
                n = fread ( buf, dimensione, elementi, fp ); //ciclo di 
lettura file e memorizzazione degli elementi in buf[1000]//
                if ( n == 0 )
               fine_file = 1;
                nc += n;
        }
                while ( fine_file==0 );
        fclose(fp); //chiusura file//
        printf("Il file GEN contiene una stringa di lunghezza %ld\n", nc ); 
//Stampa la lunghezza della stringa GEN//
                }
        printf("La stringa GEN letta nel file:\n\n");
        for ( i = 0; i < nc; i++ ) { //Stampa tramire cliclo for il 
contenuto del buf[1000], ovvero la stringa GEN letta nel file//
                printf("%c",buf[i]);
        } //fine cliclo for//
        printf("\n\n");
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* Qui viene letta la stringa 's' e raccolta la sua prima lettera e la sua 
lunghezza */
        //strinput();
        while (stringa[j]!='\0') { //lettura stringa 's'//
        j++;
        }//fine ciclo while/
        prima_lettera = stringa[0]; //memorizzazione della prima lettera di 
's' in prima_lettera//
        printf("Prima lettera della sottostringa s: %c\n",prima_lettera); 
//stampa prima_lettera di 's'//
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* Vengono memorizzate le posizioni di buf[1000] in cui troviamo tutti i 
caratteri corrispondenti alla prima_lettera di 's'*/
        for (y=0; y<nc; y++ ) {
                if (prima_lettera==buf[y]) {
                posizioni[p]=y; //memorizzazione della posizione nel vettore 
posizioni//
                printf("Posizione numero: %d\n",posizioni[p]);
                p++;
                printf("p=%d\n",p);
        }//fine condizione if//
    }
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
ncv[0]=nc; //memorizzo in ncv il valore della lunghezza della stringa GEN, 
mi servirà per il trasporto broadcast in tutte le CPU coinvolte//
//memorizzo in jv il valore della lunghezza della stringa s, mi servirà per 
il trasporto broadcast in tutte le CPU coinvolte//
} //fine istruzioni root//
/*ISTRUZIONI MPI PER LA DISTRIBUZIONE DEI DATI ALLE VARIE CPU*/
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
err = MPI_Bcast(ncv,1,MPI_INT,root,MPI_COMM_WORLD); //Invia a tutte le cpu 
il vettore unitario ncv//
err = MPI_Bcast(buf,1000,MPI_CHAR,root,MPI_COMM_WORLD); //Invia a tutte le 
cpu il vettore buf//
err = MPI_Bcast(stringa,4,MPI_CHAR,root,MPI_COMM_WORLD); //Invia a tutte le 
cpu la stringa 's'//
err = 
MPI_Scatter(posizioni,9,MPI_INT,posizioni,9,MPI_INT,root,MPI_COMM_WORLD); 
//Invia 9 parti di posizioni[] ad ogni cpu coinvolta//
err = 
MPI_Scatter(pos_stringhe,9,MPI_INT,pos_stringhe,9,MPI_INT,root,MPI_COMM_WORLD); 
//Invia 9 parti di pos_stringhe[] ad ogni cpu coinvolta//
err = 
MPI_Scatter(verifica,4,MPI_CHAR,verifica,4,MPI_CHAR,root,MPI_COMM_WORLD); 
//Invia 4 parti di verifica[] ad ogni cpu coinvolta//
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* ZONA DI CONTROLLO 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if (myid==1) {
printf("SONO P1\n");
for ( x = 0; x<4; x++ ) {
printf("posizioni: %d\n",posizioni[x]);
printf(" stringa: %c",stringa[x]);
printf(" buffer: %c",buf[x]);
printf("jv: %d\n",jv[0]);
printf("ncv: %d\n",ncv[0]);
printf("\n");
}
}
else if (myid==2) {
printf("SONO P2\n");
for ( x = 0; x<9; x++ ) {
printf("posizioni: %d\n",posizioni[x]);
printf("stringa: %c\n",stringa[x]);
printf("buffer: %c",buf[x]);
printf("\n");
}
}
else if (myid==3) {
printf("SONO P3\n");
for ( x = 0; x<9; x++ ) {
printf("posizioni: %d\n",posizioni[x]);
printf("stringa: %c\n",stringa[x]);
printf("buffer: %c",buf[x]);
printf("\n");
}
}
else {
printf("MYID: %d\n",myid);
for ( x = 0; x<9; x++ ) {
printf("posizioni: %d\n",posizioni[x]);
printf("stringa: %c\n",stringa[x]);
printf("buffer: %c",buf[x]);
printf("\n");
}
}
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/*Le seguenti istruzioni sono quelle eseguite da ogni cpu coinvolta 
nell'esecuzione*/
/*
1. Costruisce la stringa verifica partendo dal carattere presente nelle 
posizioni[] nel buf[1000] + 3 lettere presenti nelle 3 posizioni successive
2. Se la verifica[] == stringa 's'[] allora memorizza in pos_stringhe[] il 
valore della posizione[x] esaminata
3. Infine tramire MPI_GATHER raccogli i risultati di pos_stringhe[] di ogni 
cpu e memorizzali sempre nel vettore pos_stringhe[]
*/
for ( x=0; x<9; x++ ) { //per 9 volte//
        for ( z=0; z<4; z++ ) { /*Costruisce la stringa verifica[z] partendo 
dalla lettera in posizione[x] nel buf[1000] + le 3 lettere presenti nelle 3 
pos$
                                successive e sequenziali sempre in 
buf[1000]*/
                verifica[z] = buf[posizioni[x]+z];
                printf("%c", verifica[z]);
        } //fine ciclo for costruzione verifica[]//
        printf ("\n");
        if ( strcmp(verifica,stringa) == 0 ) { //se la stringa 
verifica[]==stringa 's' memorizza la posizione corretta nel vettore 
pos_stringhe[]//
                pos_stringhe[x] = posizioni[x];
                printf("Posizione trovata n. %d: %d\n",x,posizioni[x]);
        } //fine condizione
        } //fine ciclo for principale
err = 
MPI_Gather(pos_stringhe,9,MPI_INT,pos_stringhe,9,MPI_INT,root,MPI_COMM_WORLD);
        //raccogli i risultati di pos_stringhe[] di ogni cpu e memorizzali 
sempre nel vettore pos_stringhe[]//
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
if ( myid == root ) { //Se sono root eseguo le seguenti istruzioni 
successive//
//err = 
MPI_Gather(pos_stringhe,9,MPI_INT,pos_stringhe,9,MPI_INT,root,MPI_COMM_WORLD);
printf("La sottostringa e' stata trovata nelle seguenti posizioni \n"); 
//Stampa le posizioni in cui è stata trovata la sottostringa 's'//
        for ( h = 0; h < 100; h++ ) { //Legge il vettore pos_stringhe per 
prendere le prima posizioni in cui troviamo 's' in GEN//
        printf("Posizione trovata n. %d\n",pos_stringhe[h]);
} //fine ciclo for//
} //fine istruzioni root//
err = MPI_Finalize(); //Termina il supporto MPI//
printf("\n");
} //fine funzione main//
/*void strinput(void) {
    printf("Inserisci la stringa s ( massimo 4 caratteri ): ");
    scanf("%s", stringa);
}
*/
Il problema sta alla fine credo, non riesce a distinguere se la stringa 
verifica == stringa, e quindi anche se c'è una sottostringa non me la 
stampa.
Spero che qualcuno possa darmi una mano, magari qualche esperto di MPI
Ciao e grazie

 char stringa[4]="tgag";
saltano immediatamente agli occhi.
Hai allocato un array di 4 caratteri,
mentre per memorizzare la stringa "tgag" ci vogliono chiaramente 5
caratteri.
(Se poi per te non e' *chiaro* allora devi urgentemente rileggerti
il manuale alla voce terminatore di stringa).
ciao,
g.

 Dubito che qualcuno possa leggersi tutta la pappardella.
Appena l'ho visto, ho richiuso subito.
Troppo lungo.

 ha scritto nel messaggio 
news:hj_Ch.2280$J11....@twister1.libero.it...


 va buoh scusate! eh che non sapevo come spiegare
E' che non ho molto tempo a disposizione, solo per questo.
L'ho visto lungo, lanciando un'occhiata non mi sembrava una cosa che si
analizzava in 1-2 minuti e ho lasciato stare.
Magari se riesci a condensare un po' senza togliere info indispensabili
lasciando solo le parti che non funzionano...
non so se è possibile perchè ripeto non l'ho guardato.

 ha scritto nel 
messaggio 
news:Jt%Ch.2379$J11....@twister1.libero.it
...


 output le posizioni iniziali di queste sottostringhe.
Se lo fai fare ad un solo processore funziona?
E.

 ha scritto nel messaggio 
news:Qp3Dh.20175$aF5....@tornado.fastwebnet.it...
