[C++]: MPI e spedizione vettori

[Matrix_denny]

Salve a tutti sto creando ilo mio primo porgramma con le matrici ma se spedisco un solo vettore funziona se cerco di spedirne 2 non va piu' qual'e' il problema??

#include<stdio.h>
#include<mpi.h>

int main(int argc,char **argv){

char *x;	//vettore riga di 512 elementi
int *y;		//vettore colonna di 512 elementi
int i,j;	//contatori
int proc;	//contatore di processi	
int rank,size;
MPI_Status status;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);

	for(i=0;i<512;i++){
		x[i]=i+1;
	}
	
	for(j=0;j<512;j++){
		y[j]=j+1;
}
		
	int righe;
	righe=510/(size-1);
	int colonne;
	colonne=510/(size-1);

	if(rank==0){
		for(proc=1;proc<size;proc++){
			MPI_Send(&x[(proc-1)*righe],righe,MPI_CHAR,proc,0,MPI_COMM_WORLD);
			printf("inviati:%d\n",righe);
			MPI_Send(&y[(proc-1)*colonne],colonne,MPI_CHAR,proc,0,MPI_COMM_WORLD);
			printf("inviati:%d\n",colonne);
		}
		printf("\n");
	}
		else{
			int *messx;		
			messx=(int *)calloc(righe,sizeof(int));
			MPI_Recv(messx,righe,MPI_CHAR,0,0,MPI_COMM_WORLD,&status);
			printf("ricevuti:%d\n",righe);
			
			int *messy;		
			messy=(int *)calloc(righe,sizeof(int));
			MPI_Recv(messy,righe,MPI_CHAR,0,0,MPI_COMM_WORLD,&status);
			printf("ricevuti:%d\n",righe);
		}//printf("In totale ho ricevuto %d elementi",righe+colonne);
	

MPI_Finalize();
return 0;
}

Se non riempi il vettore j e non faccio la send e la riceive di questo vettore funziona ma cosi' no!!!!

[fastcoder]

Scusa...ma non li inizializzi x e y ? Non ho mai usato le MPI ma se definisci x e y come
due puntatori e poi fai

for(i=0;i<512;i++){
		x[i]=i+1;
	}
	
	for(j=0;j<512;j++){
		y[j]=j+1;
}

credo che si debba sciantare. Prima di queste due righe prova a fare

  x = malloc(512);
  y = malloc(512);

se le chiamate a MPI_Init etc non allocano memoria per x e y dubito che possa mai
funzionare (in qualsiasi caso se non per c..o).
Quello che intendo è che:

char *x;	//vettore riga di 512 elementi

non è un vettore di 512 elementi...ma un puntatore a char...da qualche parte devi allocare i 512 dodici elementi. Spero che sia questo il problema

[Matrix_denny]

Non ho ben capito la soluzione cmq se commento

for(j=0;j<512;j++){
                y[j]=j+1;
}

la send

MPI_Send(&y[(proc-1)*colonne],colonne,MPI_CHAR,proc,0,MPI_COMM_WORLD);
                        printf("inviati:%d\n",colonne);

e quindi anche la receive

int *messy;             
                        messy=(int *)calloc(righe,sizeof(int));
                        MPI_Recv(messy,righe,MPI_CHAR,0,0,MPI_COMM_WORLD,&status);
                        printf("ricevuti:%d\n",righe);

Il tutto funziona alla perfezione!!!!!

Il problema e' che a me serve anche y in quanto ho a che fare con delle matrici!!!!!!

[fastcoder]

Non entro nel merito di cosa fa il programma, ma hai provato il codice seguente ?

int main(int argc,char **argv){

char *x;	//vettore riga di 512 elementi
int *y;		//vettore colonna di 512 elementi
int i,j;	//contatori
int proc;	//contatore di processi	
int rank,size;
MPI_Status status;

        MPI_Init(&argc, &argv);
        MPI_Comm_rank(MPI_COMM_WORLD, &rank);
        MPI_Comm_size(MPI_COMM_WORLD, &size);

        
        x = malloc(sizeof(char) * 512);
        y = malloc(sizeof(int) * 512);
        
	for(i=0;i<512;i++){
		x[i]=i+1;
	}
	
	for(j=0;j<512;j++){
		y[j]=j+1;
        }
		
	int righe;
	righe=510/(size-1);
	int colonne;
	colonne=510/(size-1);

	if(rank==0){
		for(proc=1;proc<size;proc++){
			MPI_Send(&x[(proc-1)*righe],righe,MPI_CHAR,proc,0,MPI_COMM_WORLD);
			printf("inviati:%d\n",righe);
			MPI_Send(&y[(proc-1)*colonne],colonne,MPI_CHAR,proc,0,MPI_COMM_WORLD);
			printf("inviati:%d\n",colonne);
		}
		printf("\n");
	}
		else{
			int *messx;		
			messx=(int *)calloc(righe,sizeof(int));
			MPI_Recv(messx,righe,MPI_CHAR,0,0,MPI_COMM_WORLD,&status);
			printf("ricevuti:%d\n",righe);
			
			int *messy;		
			messy=(int *)calloc(righe,sizeof(int));
			MPI_Recv(messy,righe,MPI_CHAR,0,0,MPI_COMM_WORLD,&status);
			printf("ricevuti:%d\n",righe);
		}//printf("In totale ho ricevuto %d elementi",righe+colonne);
	

       MPI_Finalize();
       free(x);
       free(y);
       return 0;
}

Se va poi cerco di rispiegarmi meglio.

[Matrix_denny]

E' vero funziona anche se non riesco davvero a capire il perche'!!!!!

Come mai con un solo vettore funzionava e con due non va piu'????

Ma ho notato che calloc e' diversa dall'malloc!!!!!

Ora la domanda che nasce spontanea e' a cosa serve la malloc?????

[fastcoder]

La malloc(n) alloca n bytes nell'heap, la calloc(n, s) alloca n*s bytes nell'heap e li inizializza a zero. E' una sola questione di abitudine...io sono abituato alla malloc ma in effetti la calloc può essere più semplice. Nel mio caso ho fatto malloc(n*sizeof(int)) che sarebbe identica a calloc(n, sizeof(int)). Nota che sono identiche solo perchè poi inizializzi la memoria con il for, altrimenti la malloc lascerebbe della rumenta nella memoria mentre la calloc ci metterebbe degli zeri; siccome però inizializzi con il for in effetti l'azzeramento della memoria è ridondante.
Il fatto che con un solo vettore funzionava...puro culo non avrebbe dovuto funzionare neanche così.
Il problema è l'allocazione della memoria: se vuoi definire un'array di 512 int dovresti scrivere int x[512]. Siccome un array in C non è altro che un puntatore al primo elemento, in effetti puoi anche scrivere int *x e il compilatore non ti da errore. Però con la prima definizione oltre a definire un puntatore...il compilatore alloca la memoria per contenere i 512 int e assegna il puntatore a questa memoria a x; con la seconda definizione tu definisci solo il puntatore che però non punta a nulla (o meglio punta a caso nella memoria heap)...se provi ad scrivere nella memoria puntata da questo puntatore non fai altro che scrivere in giro per la memoria a caso...se punti da qualche parte in cui non c'è nulla di utile il programma va..altrimenti ti si schianta.
Molti compilatori moderni inizializzano comunque i puntatori non inizializzati a un puntatore particolare (es 0xcacacaca) che se acceduto da un SEGFAULT e non c'è modo quindi che per culo il programma vada...altri compilatori non lo fanno.
Se leggi le PILLOLE del forum c'è un bel documento proprio sui puntatori del C

[Matrix_denny]

Ti ringrazio sei stato davvero un ottima guida,come avrai potuto notare sono nuovo di questi due linguaggi di programmazione(C,MPI)e sto cercando di digerirli il piu' in fretta possibile.
Cmq come ti avevo gia' detto ho fatto un bel po' di programmi senza mai inizializzare nulla ed ha sempre funzionato(mistero della fede).
I programmiche ho fatto gli ho pubblicati nel mio sito magari se ne hai ancora voglia dai uno sguardo e cerca di capire come mai funzionano tutti!!!!!!
http://zurico.daniele.googlepages.com/

[fastcoder]

Gli darò un'occhiata
Gli ho dato un'occhiata ma mi sembra che i puntatori li inizializzi sempre....ecco perchè vanno