Probleme d'execution d'un programme

je vai vous donner mon code source et apres vous pouver voire exactement mon probleme,j'utilise le mecanisme de communication one sided avec mpi-2(copie memoire à memoire) svp vous essayer de l'executer et vous pouver voire où est le probleme.voila mon programme:
#include <mpi.h>
#include <math.h>
#include <stdio.h>
#include<sys/timeb.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <iostream.h>
#include <fstream.h>
#define pi 3.14159

int N, M, Q;
void ReadImage(char fname[15],int& , int& , int& );
void imaginfo(void);
void gabor(int Minf, int Msup,int Ninf,int Nsup);

MPI_File ime;

char fname2[15],fname3[15];char *fname;
unsigned char **tab;float **tab2;
double repsi,impsi;
int i,j,t,s,k,l,d,z,m,n,lob,orienta,pro;
float v[7][7],w,a,teta,segmax,segmay,ut=0.05,uh=0.4,x,y,debut_mpi,fin_mpi;

double e[6][4],g[6][4],img[6][4],reg[6][4],segmaloc[6][4],segma[6][4],segma1[6][4],segma2[6][4],segma3[6][4];
double segma4[6][4],segma5[6][4],segma6[6][4],segma7[6][4],segma8[6][4],segma9[6][4],segma10[6][4],segma11[6][4];
double u[6][4],u1[6][4],u2[6][4],u3[6][4],u4[6][4],u5[6][4],u6[6][4],u7[6][4],u8[6][4],u9[6][4],u10[6][4],u11[6][4];
struct timeb debut,fin; //structure pre-definie dans sys/timeb.h
float milisectot=0,milisec1=0,milisec2=0,milisec3=0,temp_id0=0,temp_id1=0,temp_id2=0,temp_id3=0,temp_id=0,temp_id4=0,temp_id5=0,temp_id6=0,temp_id7=0;
int myid,iproc,caro=4,larg,id,p; double moy[6][4];
time_t dateheure;

main(int argc, char **argv)
{
if(argc<6) {printf("\n ## ERREUR !: nombre d'arguments insufisant, préciser respectivement : \n le nom de l'image.pgm;le nbr d'echelle; l'orientation et la fenetre 't*s')\n\v");exit(-1);}

fname=argv[1];
lob=atoi(argv[2]);
orienta=atoi(argv[3]);
t=atoi(argv[4]);
s=atoi(argv[5]);

MPI_File imaE;
MPI_Info info;
MPI_Status status;

char oui,sup[10]="rm ",view[30]="gwenview ";


//system("clear");

MPI_Init(&argc,&argv); /* starts MPI */
MPI_Comm_rank(MPI_COMM_WORLD, &myid); /* get current process id */
MPI_Comm_size(MPI_COMM_WORLD, &p); /* get number of processes */

pro=p;
ReadImage(fname,M,N,Q );

//debut_mpi=MPI_Wtime();
if(myid==0)
{
cout<<"\n\t\t *### Lancement du traitement parallel ###* \n\t\t *****************************************\n\v";
cout<<"\n\t\t *******( "<<p<<" processus lancés )*********\n\v ";


//MPI_Ssend(tab2,(M*N), MPI_FLOAT, 1, 6, MPI_COMM_WORLD);
imaginfo();

ftime(&debut);
}


switch(pro)

{
case 1:

if(myid==0)
{
gabor(0,6,0,4);
}
break;

case 2:

if(myid==0)
{
gabor(0,3,0,4);
}

if(myid==1)
{
gabor(3,6,0,4);
}

break;

case 3:
if(myid==0)
{
gabor(0,2,0,4);
}

if(myid==1)
{
gabor(2,4,0,4);
}

if(myid==2)
{
gabor(4,6,0,4);

}
break;

case 4:
if(myid==0)
{
gabor(0,6,0,1);
}

if(myid==1)
{
gabor(0,6,1,2);
}
if(myid==2)
{
gabor(0,6,2,3);
}

if(myid==3)
{
gabor(0,6,3,4);
}
break;

case 5:

if(myid==0)
{
gabor(0,5,0,1);
}

if(myid==1)
{
gabor(0,5,1,2);
}
if(myid==2)
{
gabor(0,5,2,3);
}

if(myid==3)
{
gabor(0,5,3,4);
}

if(myid==4)
{
gabor(5,6,0,4);
}
break;

case 6:

if(myid==0)
{
gabor(0,1,0,4);
}

if(myid==1)
{
gabor(1,2,0,4);
}
if(myid==2)
{
gabor(2,3,0,4);
}

if(myid==3)
{
gabor(3,4,0,4);
}

if(myid==4)
{
gabor(4,5,0,4);
}
if(myid==5)
{
gabor(5,6,0,4);
}

break;

case 7:

if(myid==0)
{
gabor(0,1,0,3);
}

if(myid==1)
{
gabor(1,2,0,3);
}
if(myid==2)
{
gabor(2,3,0,3);
}

if(myid==3)
{
gabor(3,4,0,3);
}

if(myid==4)
{
gabor(4,5,0,4);
}
if(myid==5)
{
gabor(5,6,0,4);
}
if(myid==6)
{
gabor(0,4,3,4);
}

break;

case 8:

if(myid==0)
{
gabor(0,3,0,1);
}

if(myid==1)
{
gabor(0,3,1,2);
}
if(myid==2)
{
gabor(0,3,2,3);
}

if(myid==3)
{
gabor(0,3,3,4);
}

if(myid==4)
{
gabor(3,6,0,1);
}
if(myid==5)
{
gabor(3,6,1,2);
}
if(myid==6)
{
gabor(3,6,2,3);
}
if(myid==7)
{
gabor(3,6,3,4);
}

break;

case 9:
if(myid==0)
{
gabor(0,3,0,1);
}

if(myid==1)
{
gabor(0,3,1,2);
}
if(myid==2)
{
gabor(0,3,2,3);
}

if(myid==3)
{
gabor(0,3,3,4);
}

if(myid==4)
{
gabor(3,6,0,1);
}
if(myid==5)
{
gabor(3,6,1,2);
}
if(myid==6)
{
gabor(0,2,3,4);
}
if(myid==7)
{
gabor(2,4,3,4);
}
if(myid==8)
{
gabor(4,6,3,4);
}

break;

case 10:

if(myid==0)
{
gabor(0,3,0,1);
}

if(myid==1)
{
gabor(3,6,0,1);
}
if(myid==2)
{
gabor(0,3,1,2);
}

if(myid==3)
{
gabor(3,6,1,2);
}

if(myid==4)
{
gabor(0,2,2,3);
}
if(myid==5)
{
gabor(2,4,2,3);
}
if(myid==6)
{
gabor(4,6,2,3);
}
if(myid==7)
{
gabor(0,2,3,4);
}
if(myid==8)
{
gabor(2,4,3,4);
}
if(myid==9)
{
gabor(4,6,3,4);
}

break;

case 11:

if(myid==0)
{
gabor(0,3,0,1);
}

if(myid==1)
{
gabor(3,6,0,1);
}
if(myid==2)
{
gabor(0,2,1,2);
}

if(myid==3)
{
gabor(2,4,1,2);
}

if(myid==4)
{
gabor(4,6,1,2);
}
if(myid==5)
{
gabor(0,2,2,3);
}
if(myid==6)
{
gabor(2,4,2,3);
}
if(myid==7)
{
gabor(4,6,2,3);
}
if(myid==8)
{
gabor(0,2,3,4);
}
if(myid==9)
{
gabor(2,4,3,4);
}
if(myid==10)
{
gabor(4,6,3,4);
}

break;

case 12:

if(myid==0)
{
gabor(0,1,0,2);
}

if(myid==1)
{
gabor(1,2,0,2);
}
if(myid==2)
{
gabor(2,3,0,2);
}

if(myid==3)
{
gabor(3,4,0,2);
}

if(myid==4)
{
gabor(4,5,0,2);
}
if(myid==5)
{
gabor(5,6,0,2);
}
if(myid==6)
{
gabor(0,1,2,4);
}
if(myid==7)
{
gabor(1,2,2,4);
}
if(myid==8)
{
gabor(2,3,2,4);
}
if(myid==9)
{
gabor(3,4,2,4);
}
if(myid==10)
{
gabor(4,5,2,4);
}

if(myid==11)
{
gabor(5,6,2,4);
}
break;

}

int deplacement=24;
MPI_Win win1, win2;
int index_to_put=8,index_to_get=8;

if(myid==0)
{
MPI_Win_create(&u, sizeof(int), deplacement,MPI_INFO_NULL ,MPI_COMM_WORLD , &win1);//win est un objet windows creer pour chaque processus
MPI_Win_create(&segma, sizeof(int), deplacement,MPI_INFO_NULL ,MPI_COMM_WORLD , &win2);
}
else {
MPI_Win_create(&u, 1000, deplacement,MPI_INFO_NULL ,MPI_COMM_WORLD , &win1);
MPI_Win_create(&segma, 1000, deplacement,MPI_INFO_NULL ,MPI_COMM_WORLD , &win2);
}

MPI_Win_fence( MPI_MODE_NOPRECEDE, win1);
if(myid!=0)
{
MPI_Put(&u,(6*4), MPI_DOUBLE, 0, index_to_put, (6*4), MPI_DOUBLE, win1);
// MPI_put(&milisec2,1, MPI_FLOAT, myid, 8, (6,4),MPI_COMM_WORLD,win);
}
MPI_Win_fence(MPI_MODE_NOPUT, win1);

MPI_Win_fence( MPI_MODE_NOPRECEDE, win2);
if(myid!=0)
{
MPI_Put(&segma,(6*4), MPI_DOUBLE, 0, index_to_put, (6*4), MPI_DOUBLE, win2);
}
MPI_Win_fence(MPI_MODE_NOPUT, win2);

MPI_Win_fence(0, win1);
if(myid==0)
{
switch (pro)
{
case 2:
{

MPI_Get(&u1,12, MPI_DOUBLE,1, index_to_get, 12, MPI_DOUBLE, win1);
//MPI_get(&temp_id1,1, MPI_FLOAT,1,index_to get ,(6*4), MPI_COMM_WORLD, win);
break;
}
case 3:
{
MPI_Get(&u1,8, MPI_DOUBLE,1, index_to_get, 8, MPI_DOUBLE, win1);
MPI_Get(&u2,8, MPI_DOUBLE,2, index_to_get, 8, MPI_DOUBLE, win1);
//MPI_get(&temp_id2,1, MPI_FLOAT,2, index_to_get,(*,4), MPI_COMM_WORLD, win);
break;
}
case 4:
{
MPI_Get(&u1,6, MPI_DOUBLE,1, index_to_get,6, MPI_DOUBLE, win1);
MPI_Get(&u2,6, MPI_DOUBLE,2, index_to_get, 6, MPI_DOUBLE, win1);
MPI_Get(&u3,6, MPI_DOUBLE,3, index_to_get, 6, MPI_DOUBLE, win1);
//MPI_get(&temp_id2,1, MPI_FLOAT,3, index_to_get,(6*4), MPI_COMM_WORLD, win);

break;
}
case 5:
{
MPI_Get(&u1,5, MPI_DOUBLE,1, index_to_get, 5, MPI_DOUBLE, win1);
MPI_Get(&u2,4, MPI_DOUBLE,2, index_to_get,4, MPI_DOUBLE, win1);
MPI_Get(&u3,4, MPI_DOUBLE,3, index_to_get, 4, MPI_DOUBLE, win1);
MPI_Get(&u4,4, MPI_DOUBLE,4, index_to_get,4, MPI_DOUBLE, win1);
//MPI_get(&temp_id2,1, MPI_FLOAT,4, index_to get, (6*4),MPI_COMM_WORLD, win);


break;
}
case 6:
{
MPI_Get(&u1,4, MPI_DOUBLE,1, index_to_get, 4, MPI_DOUBLE, win1);
MPI_Get(&u2,4, MPI_DOUBLE,2, index_to_get,4, MPI_DOUBLE, win1);
MPI_Get(&u3,4, MPI_DOUBLE,3, index_to_get, 4, MPI_DOUBLE, win1);
MPI_Get(&u4,4, MPI_DOUBLE,4, index_to_get,4, MPI_DOUBLE, win1);
MPI_Get(&u5,4, MPI_DOUBLE,5, index_to_get, 4, MPI_DOUBLE, win1);
//MPI_get(&temp_id2,1, MPI_FLOAT,5,index_to_get , (6*4),MPI_COMM_WORLD, win);


break;
}
case 7:
{
MPI_Get(&u1,3, MPI_DOUBLE,1, index_to_get, 3, MPI_DOUBLE, win1);
MPI_Get(&u2,3, MPI_DOUBLE,2, index_to_get,3, MPI_DOUBLE, win1);
MPI_Get(&u3,3, MPI_DOUBLE,3, index_to_get, 3, MPI_DOUBLE, win1);
MPI_Get(&u4,4, MPI_DOUBLE,4, index_to_get,4, MPI_DOUBLE, win1);
MPI_Get(&u5,4, MPI_DOUBLE,5, index_to_get, 4, MPI_DOUBLE, win1);
MPI_Get(&u6,4, MPI_DOUBLE,6, index_to_get, 4, MPI_DOUBLE, win1);
//MPI_get(&temp_id2,1, MPI_FLOAT,6, index_to_get,(6*4), MPI_COMM_WORLD,win);

break;
}
case 8:
{
MPI_Get(&u1,3, MPI_DOUBLE,1, index_to_get, 3, MPI_DOUBLE, win1);
MPI_Get(&u2,3, MPI_DOUBLE,2, index_to_get,3, MPI_DOUBLE, win1);
MPI_Get(&u3,3, MPI_DOUBLE,3, index_to_get, 3, MPI_DOUBLE, win1);
MPI_Get(&u4,3, MPI_DOUBLE,4, index_to_get,3, MPI_DOUBLE, win1);
MPI_Get(&u5,3, MPI_DOUBLE,5, index_to_get, 3, MPI_DOUBLE, win1);
MPI_Get(&u6,3, MPI_DOUBLE,6, index_to_get, 3, MPI_DOUBLE, win1);
MPI_Get(&u7,3, MPI_DOUBLE,7, index_to_get, 3, MPI_DOUBLE, win1);
//MPI_get(&temp_id2,1, MPI_FLOAT,7, index_to_get, (6*4),MPI_COMM_WORLD, win);


break;
}
case 9:
{
MPI_Get(&u1,3, MPI_DOUBLE,1, index_to_get, 3, MPI_DOUBLE, win1);
MPI_Get(&u2,3, MPI_DOUBLE,2, index_to_get,3, MPI_DOUBLE, win1);
MPI_Get(&u3,3, MPI_DOUBLE,3, index_to_get, 3, MPI_DOUBLE, win1);
MPI_Get(&u4,3, MPI_DOUBLE,4, index_to_get,3, MPI_DOUBLE, win1);
MPI_Get(&u5,3, MPI_DOUBLE,5, index_to_get, 3, MPI_DOUBLE, win1);
MPI_Get(&u6,2, MPI_DOUBLE,6, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u7,2, MPI_DOUBLE,7, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u8,2, MPI_DOUBLE,8, index_to_get, 2, MPI_DOUBLE, win1);
//MPI_get(&temp_id2,1, MPI_FLOAT,8, index_to_get,(6*4), MPI_COMM_WORLD, win);

break;
}

case 10:
{
MPI_Get(&u1,3, MPI_DOUBLE,1, index_to_get, 3, MPI_DOUBLE, win1);
MPI_Get(&u2,3, MPI_DOUBLE,2, index_to_get,3, MPI_DOUBLE, win1);

MPI_Get(&u3,3, MPI_DOUBLE,3, index_to_get, 3, MPI_DOUBLE, win1);
MPI_Get(&u4,2, MPI_DOUBLE,4, index_to_get,2, MPI_DOUBLE, win1);

MPI_Get(&u5,2, MPI_DOUBLE,5, index_to_get, 2, MPI_DOUBLE, win1);

MPI_Get(&u6,2, MPI_DOUBLE,6, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u7,2, MPI_DOUBLE,7, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u8,2, MPI_DOUBLE,8, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u9,2, MPI_DOUBLE,9, index_to_get, 2, MPI_DOUBLE, win1);
//MPI_get(&temp_id2,1, MPI_FLOAT,9, index_to_get,(6*4), MPI_COMM_WORLD,win );

break;
}
case 11:
{
MPI_Get(&u1,3, MPI_DOUBLE,1, index_to_get, 3, MPI_DOUBLE, win1);
MPI_Get(&u2,3, MPI_DOUBLE,2, index_to_get,3, MPI_DOUBLE, win1);
MPI_Get(&u3,2, MPI_DOUBLE,3, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u4,2, MPI_DOUBLE,4, index_to_get,2, MPI_DOUBLE, win1);
MPI_Get(&u5,2, MPI_DOUBLE,5, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u6,2, MPI_DOUBLE,6, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u7,2, MPI_DOUBLE,7, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u8,2, MPI_DOUBLE,8, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u9,2, MPI_DOUBLE,9, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u10,2, MPI_DOUBLE,10, index_to_get, 2, MPI_DOUBLE, win1);
//MPI_get(&temp_id2,1, MPI_FLOAT,10, index_to_get, (6*4),MPI_COMM_WORLD, win);

break;
}

case 12:
{
MPI_Get(&u1,2, MPI_DOUBLE,1, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u2,2, MPI_DOUBLE,2, index_to_get,2, MPI_DOUBLE, win1);
MPI_Get(&u3,2, MPI_DOUBLE,3, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u4,2, MPI_DOUBLE,4, index_to_get,2, MPI_DOUBLE, win1);
MPI_Get(&u5,2, MPI_DOUBLE,5, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u6,2, MPI_DOUBLE,6, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u7,2, MPI_DOUBLE,7, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u8,2, MPI_DOUBLE,8, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u9,2, MPI_DOUBLE,9, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u10,2, MPI_DOUBLE,10, index_to_get, 2, MPI_DOUBLE, win1);
MPI_Get(&u11,2, MPI_DOUBLE,11, index_to_get, 2, MPI_DOUBLE, win1);
//MPI_get(&temp_id2,1, MPI_FLOAT,11, index_to_get,(6*4), MPI_COMM_WORLD, win);

break;
}
}
}
MPI_Win_fence(0, win1);

MPI_Win_fence(0, win2);
if(myid==0)
{
switch (pro)
{
case 2:
{
MPI_Get(&segma1,12, MPI_DOUBLE,1, index_to_get, 12, MPI_DOUBLE, win2);
break;
}
case 3:
{
MPI_Get(&segma1,8, MPI_DOUBLE,1, index_to_get, 8, MPI_DOUBLE, win2);
MPI_Get(&segma2,8, MPI_DOUBLE,2, index_to_get, 8, MPI_DOUBLE, win2);

break;
}
case 4:
{
MPI_Get(&segma1,6, MPI_DOUBLE,1, index_to_get, 6, MPI_DOUBLE, win2);
MPI_Get(&segma2,6, MPI_DOUBLE,2, index_to_get, 6, MPI_DOUBLE, win2);
MPI_Get(&segma3,6, MPI_DOUBLE,3, index_to_get, 6, MPI_DOUBLE, win2);

break;
}
case 5:
{
MPI_Get(&segma1,5, MPI_DOUBLE,1, index_to_get, 5, MPI_DOUBLE, win2);
MPI_Get(&segma2,5, MPI_DOUBLE,2, index_to_get, 5, MPI_DOUBLE, win2);
MPI_Get(&segma3,5, MPI_DOUBLE,3, index_to_get, 5, MPI_DOUBLE, win2);
MPI_Get(&segma4,4, MPI_DOUBLE,4, index_to_get, 4, MPI_DOUBLE, win2);

break;
}
case 6:
{
MPI_Get(&segma1,4, MPI_DOUBLE,1, index_to_get, 4, MPI_DOUBLE, win2);
MPI_Get(&segma2,4, MPI_DOUBLE,2, index_to_get, 4, MPI_DOUBLE, win2);
MPI_Get(&segma3,4, MPI_DOUBLE,3, index_to_get, 4, MPI_DOUBLE, win2);

MPI_Get(&segma4,4, MPI_DOUBLE,4, index_to_get, 4, MPI_DOUBLE, win2);
MPI_Get(&segma5,4, MPI_DOUBLE,5, index_to_get, 4, MPI_DOUBLE, win2);

break;
}
case 7:
{
MPI_Get(&segma1,3, MPI_DOUBLE,1, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma2,3, MPI_DOUBLE,2, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma3,3, MPI_DOUBLE,3, index_to_get, 3, MPI_DOUBLE, win2);

MPI_Get(&segma4,4, MPI_DOUBLE,4, index_to_get, 4, MPI_DOUBLE, win2);
MPI_Get(&segma5,4, MPI_DOUBLE,5, index_to_get, 4, MPI_DOUBLE, win2);
MPI_Get(&segma6,4, MPI_DOUBLE,6, index_to_get, 4, MPI_DOUBLE, win2);

break;
}
case 8:
{
MPI_Get(&segma1,3, MPI_DOUBLE,1, index_to_get,3, MPI_DOUBLE, win2);
MPI_Get(&segma2,3, MPI_DOUBLE,2, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma3,3, MPI_DOUBLE,3, index_to_get, 3, MPI_DOUBLE, win2);

MPI_Get(&segma4,3, MPI_DOUBLE,4, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma5,3, MPI_DOUBLE,5, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma6,3, MPI_DOUBLE,6, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma7,3, MPI_DOUBLE,7, index_to_get, 3, MPI_DOUBLE, win2);


break;
}
case 9:
{
MPI_Get(&segma1,3, MPI_DOUBLE,1, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma2,3, MPI_DOUBLE,2, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma3,3, MPI_DOUBLE,3, index_to_get, 3, MPI_DOUBLE, win2);

MPI_Get(&segma4,3, MPI_DOUBLE,4, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma5,3, MPI_DOUBLE,5, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma6,2, MPI_DOUBLE,6, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma7,2, MPI_DOUBLE,7, index_to_get,2, MPI_DOUBLE, win2);
MPI_Get(&segma8,2, MPI_DOUBLE,8, index_to_get, 2, MPI_DOUBLE, win2);

break;
}
case 10:
{
MPI_Get(&segma1,3, MPI_DOUBLE,1, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma2,3, MPI_DOUBLE,2, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma3,3, MPI_DOUBLE,3, index_to_get, 3, MPI_DOUBLE, win2);

MPI_Get(&segma4,2, MPI_DOUBLE,4, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma5,2, MPI_DOUBLE,5, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma6,2, MPI_DOUBLE,6, index_to_get,2, MPI_DOUBLE, win2);
MPI_Get(&segma7,2, MPI_DOUBLE,7, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma8,2, MPI_DOUBLE,8, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma9,2, MPI_DOUBLE,9, index_to_get, 2, MPI_DOUBLE, win2);

break;
}case 11:
{
MPI_Get(&segma1,3, MPI_DOUBLE,1, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma2,3, MPI_DOUBLE,2, index_to_get, 3, MPI_DOUBLE, win2);
MPI_Get(&segma3,2, MPI_DOUBLE,3, index_to_get, 2, MPI_DOUBLE, win2);

MPI_Get(&segma4,2, MPI_DOUBLE,4, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma5,2, MPI_DOUBLE,5, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma6,2, MPI_DOUBLE,6, index_to_get,2, MPI_DOUBLE, win2);
MPI_Get(&segma7,2, MPI_DOUBLE,7, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma8,2, MPI_DOUBLE,8, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma9,2, MPI_DOUBLE,9, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma10,2, MPI_DOUBLE,10, index_to_get, 2, MPI_DOUBLE, win2);
break;
}
case 12:
{

MPI_Get(&segma1,2, MPI_DOUBLE,1, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma2,2, MPI_DOUBLE,2, index_to_get,2, MPI_DOUBLE, win2);
MPI_Get(&segma3,2, MPI_DOUBLE,3, index_to_get, 2, MPI_DOUBLE, win2);

MPI_Get(&segma4,2, MPI_DOUBLE,4, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma5,2, MPI_DOUBLE,5, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma6,2, MPI_DOUBLE,6, index_to_get,2, MPI_DOUBLE, win2);
MPI_Get(&segma7,2, MPI_DOUBLE,7, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma8,2, MPI_DOUBLE,8, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma9,2, MPI_DOUBLE,9, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma10,2, MPI_DOUBLE,10, index_to_get, 2, MPI_DOUBLE, win2);
MPI_Get(&segma11,2, MPI_DOUBLE,11, index_to_get, 2, MPI_DOUBLE, win2);
break;
}
}
}
MPI_Win_fence(0, win2);
MPI_Win_free(&win1);
MPI_Win_free(&win2);

if(myid==0)
{
ftime(&fin);
milisec2=(fin.time-debut.time)*1000L +(fin.millitm-debut.millitm);

cout<<"\n\v\t\t\t\tLe Vecteur resultant est :\n";
for(m=0;m<lob; m++)
for(n=0;n<orienta; n++)
{
u[m][n]=u[m][n]+u1[m][n]+u2[m][n]+u3[m][n]+u4[m][n]+u5[m][n]+u6[m][n]+u7[m][n]+u8[m][n]+u9[m][n]+u10[m][n]+u11[m][n];
segma[m][n]=segma[m][n]+segma1[m][n]+segma2[m][n]+segma3[m][n]+segma4[m][n]+segma5[m][n]+segma6[m][n]+segma7[m][n]+segma8[m][n]+segma9[m][n]+segma10[m][n]+segma11[m][n];

cout<<"\n\tla moyenne ["<<m<<"]["<<n<<"] est: "<<(u[m][n])<<" ######## l'ecart type ["<<m<<"]["<<n<<"] est: "<<segma[m][n]<<endl;
}

//MPI_Reduce (&temp_id, &milisec2,1,MPI_FLOAT, MPI_SUM,0, MPI_COMM_WORLD);

//milisec2=milisec2+temp_id1+temp_id2+temp_id3+temp_id4+temp_id5+temp_id6+temp_id7;

cout<<"\n\v\t fin d'execution parallel"<<endl;

//milisectot=milisec1+milisec2+milisec3;
cout<<"\n\t ===================================================================";
cout<<"\n\t *** *** Le temps du Traitement parallel est: "<<(float)milisec2/(1000)<<" sec *** *** \n";
cout<<"\t ===================================================================\n\v";
}

MPI_Finalize();

delete []tab[0];
delete []tab;
}

void ReadImage(char fname[],int& M, int& N, int& Q)
{

//struct timeb debut,fin; //structure pre-definie dans sys/timeb.h
ftime(&debut);
int i, j;
char header [100], *ptr;
ifstream ifp;
//system("cd /home/user/lastcodes");
ifp.open(fname, ios::in);
if (!ifp) {
cout << "l'image '"<< fname <<"' introuvable !, veuillez verifier l'orthographe..."<< endl;
exit(1);
}
// read header
ifp.getline(header,100,'\n');
if ( (header[0]!=80) || // 'P'
(header[1]!=53) ) //'5'
{
cout << "\nImage '" << fname << "'n'est pas du format PGM !! (ou peut etre du format PGM type 'P2')\n" << endl;
exit(1);
}

ifp.getline(header,100,'\n');
while(header[0]=='#')
ifp.getline(header,100,'\n');
M=strtol(header,&ptr,0);
N=atoi(ptr);
ifp.getline(header,100,'\n');
Q=strtol(header,&ptr,0);

//imaginfo(); // informations sur l'image (largeur,hauteur et niveau de gris)

//cout << "\n Chargement de l'image en memoire ...";
// Allocation memoire pour l'mage d'entr�
tab = new unsigned char*[N];
tab[0] = new unsigned char[M*N];
for( j=1; j<N; j++ )
tab[j] = tab[j-1]+M;

ifp.read( reinterpret_cast< char *>(tab[0]), (M*N)*sizeof(unsigned char));

if (ifp.fail()) {
cout << "Image " << fname << " has wrong size" << endl;
exit(1);
}

// Allocation memoire pour la convertion
tab2 = new float*[N];
tab2[0] = new float[M*N];
for( j=1; j<N; j++ )
tab2[j] = tab2[j-1]+M;
// convertion unsigned char vers float
for(j=0; j<N; j++)
{for(i=0; i<M; i++)
tab2[j][i]=(float)tab[j][i];}

ifp.close();
//system("clear");
ftime(&fin);
milisec1=(fin.time-debut.time)*1000L +(fin.millitm-debut.millitm);
time_t dateheure;
time(&dateheure);
//cout<<"... OK! : "<<ctime(&dateheure)<<"\n\v";
}


void imaginfo(void)
{

cout<<"\n\t *** caracteristiques initialles de l'image d'entrée : *** \n";
cout<<"\t\t\t Nom de l'image:'"<<fname<<"'\n";
cout<<"\t\t\t *********************\n";
cout<<"\t\t\t * PGM type 'P5'"<<" "<<"*\n";
cout<<"\t\t\t * largeur (M): "<<M<<" *\n";
cout<<"\t\t\t * hauteur (N): "<<N<<" *\n";
cout<<"\t\t\t * couleur (Q): "<<(Q+1)<<" *\n";
cout<<"\t\t\t *********************\n";
}


void gabor(int Minf, int Msup,int Ninf,int Nsup)
{
cout<<"\n\t\t Process :"<<myid<<" Debut du traitement ";

a=pow((float)uh/ut,(float)1/(lob-1));

//affichage de la date et l'heure.
milisec2=0;
//ftime(&debut);
for( m=Minf; m<Msup; m++ )
{
w=pow((float)a,m)*ut;segmax=((a+1)*sqrt(2*log(2))/(2*pi*pow((float)a,m)*(a-1)*ut));
segmay=1/(2*pi*tan(pi/orienta)*sqrt((pow((float)uh,2)/2*log(2))-pow((float)1/(2*pi*segmax),2)));

for( n=Ninf; n<Nsup; n++ )
{
teta=n*pi/orienta;//reg[m][n]=0;img[m][n]=0;
y=pow((float)a,-m)*(k*cos(teta)+l*sin(teta));
x=pow((float)a,-m)*(-k*sin(teta)+l*cos(teta));

repsi=pow((float)a,-m)*(1/(2*pi*segmax*segmay))*exp((-1/2)*((pow((float)y,2)/pow((float)segmay,2))+(pow((float)x,2)/pow((float)segmax,2))))*cos(2*pi*w*y);
impsi=-pow((float)a,-m)*(1/(2*pi*segmax*segmay))*exp((-1/2)*((pow((float)y,2)/pow((float)segmay,2))+(pow((float)x,2)/pow((float)segmax,2))))*sin(2*pi*w*y);

for(j=(t-1)/2;j<M-(t-1)/2;j++)
for(i=(s-1)/2;i<N-(s-1)/2; i++)
{
reg[m][n]=0;img[m][n]=0;

for( k=-(t-1)/2;k<(t-1)/2; k++ )
for( l=-(s-1)/2;l<(s-1)/2; l++ )
{
reg[m][n]+=repsi*tab2[j+k][i+l];
img[m][n]+=impsi*tab2[j+k][j+l];
}
g[m][n]=sqrt(pow((float)reg[m][n],2)+pow((float)img[m][n],2));
e[m][n]+= g[m][n];

}
u[m][n]=e[m][n]/(M*N);

for(j=(t-1)/2;j<M-(t-1)/2;j++)
for(i=(s-1)/2;i<N-(s-1)/2; i++)
{
reg[m][n]=0;img[m][n]=0;

for( k=-(t-1)/2;k<(t-1)/2; k++ )
for( l=-(s-1)/2;l<(s-1)/2; l++ )
{
reg[m][n]+=repsi*tab2[j+k][i+l];
img[m][n]+=impsi*tab2[j+k][j+l];
}
g[m][n]=sqrt(pow((float)reg[m][n],2)+pow((float)img[m][n],2));
segmaloc[m][n]+=pow((float)g[m][n]-u[m][n],2);
}
segma[m][n]=(sqrt(segmaloc[m][n]))/(M*N);
}
}
cout<<"\n\v\t\t Process :"<<myid<<" Fin du traitement "<<endl;

for(m=Minf;m<Msup; m++)
for(n=Ninf;n<Nsup; n++)
{
cout<<" la moyenne ["<<m<<"]["<<n<<"] est: "<<(u[m][n])<<" ######## la variance ["<<m<<"]["<<n<<"] est: "<<segma[m][n]<<endl;
}

// ftime(&fin);
// milisec2=(fin.time-debut.time)*1000L +(fin.millitm-debut.millitm);
}


et j'espere qu j'aurai la reponse le plus vite possible,et s'il ya d'autres questions je serai là