PDA

Visualizza la versione completa : [C++] MPI e Opengl


matyB87
03-07-2010, 01:34
Salve a tutti...
Sto facendo un programma che si occupa di ordinare attraverso l'algoritmo di ordinamento Odd-even una sequenza di numeri...
siccome mi è stato richiesto di implementare anche una parte grafica ho pensato di usare opengl....

il tutto sotto Windows e con il programma NetBeans per programmare....

Dopo vari tentativi sono riuscita a far compilare e mandare in esecuzione il programma da NetBeans, e il tutto funziona....

purtroppo devo farlo mandare in esecuzione tramite linea di comando con Cygwin perchè devo poter specificare il numero di processi(cosa che non è possibile fare da netbeans) ma purtroppo quando lo mando in esecuzione con il seguente comando:

mpiexec -n 4 nomeProgramma

si ferma e non fa nulla....
qualcuno sa aiutarmi?...

p.s.se nel codice tolgo la parte riguardante opengl il tutto funziona anche da linea di comando....vi metto cmq anche il codice del mio programma...






#include <stdio.h>
#include <ctime>
#include <cstdlib>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <mpi.h>
#include <windows.h>
#include <stdlib.h>

#include <assert.h>
#include <GL/gl.h>
#include <GL/glext.h>

#include <GL/glu.h>
#include <GL/glut.h>

#include <stdio.h>
#include <stdarg.h>
#include <ctime>
#include <set>
#include <cstdlib>
#include <time.h>
#include <algorithm>
#include <math.h>
#include <glut.h>

using namespace std;
const int RMAX = 10;
int globalSize=5;
int punti[5];
int iteratore=0;
int my_rankGlobale, sizeGlobale;
MPI_Comm comm;



void Distr_list(int local_A[], int local_n, int size,int rank,int global_B[],int d)
{
int c=0;
int f=local_n;
if(rank==(size-1))
{
c=(size-1)*local_n;
f=f+d;

}
else
c=rank*local_n;

int j=0;
for(int i=c;i<(f+c);i++)
{
local_A[j]=global_B[i];
j++;
}


}



static GLint wh=250,ww=250;

static GLfloat size = 3.0;
static GLfloat spin = 0.0;
HWND hwnd;


void drawLine(int p[])
{

printf("\n\n l'array ha valori:");
for(int i=0;i<globalSize;i++)
{
printf(" %d",p[i]);
}
printf("\n\n");
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//glClearColor(1.0,1.0,1.0,1.0);
//glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
//glLoadIdentity();
int y=-125;
for(int i=0;i<globalSize;i++)
{


glPushMatrix();


y+=5;
glColor3f(1.0, 1.0, 1.0);
glLineWidth(15.0f);
glBegin(GL_LINES);
glColor3f(1.0,3.0,1.0);
glVertex3f(-168.0,y,0.0f);
glColor3f(2.0,3.0,2.0);
glVertex3f( p[i],y,0.0f);

glEnd();



// glLoadIdentity();
glPopMatrix();


//glFlush();
}

glutSwapBuffers();
}



void Print_listPoint(int local_A[], int local_n, int rank) {
int i;
printf("\n%d: ", rank);
for (i = 0; i < local_n; i++)
printf("%d ", local_A[i]);
printf("\n");
}

void OrdinaY(int array[],int size)
{
int c=40;
for(int i=0;i<size;i++)
{
array[i]=600-array[i];
c+=10;
}
}



void Print_global_list(int local_A[], int local_n, int my_rank, int p,
MPI_Comm comm)
{
int* A;
int i, n;

if (my_rank == 0) {
n = p*local_n;
A = (int*) malloc(n*sizeof(int));
MPI_Gather(local_A, local_n, MPI_INT, A, local_n, MPI_INT, 0,
comm);
printf("Global list:\n");
for (i = 0; i < n; i++)
printf("%d ", A[i]);
printf("\n\n");

//free(A);
} else {
MPI_Gather(local_A, local_n, MPI_INT, A, local_n, MPI_INT, 0,
comm);
}
}

int Compare(const void* a_p, const void* b_p) {
int a = *((int*)a_p);

int b = *((int*)b_p);
if (a < b)
return -1;
else if (a == b)
return 0;
else /* a > b */
return 1;

}


void Merge_split_low(int local_A[], int temp_B[], int temp_C[],
int local_n) {
int ai, bi, ci;

ai = 0;
bi = 0;
ci = 0;
while (ci < local_n) {
if (local_A[ai] <= temp_B[bi]) {
temp_C[ci] = local_A[ai];
ci++; ai++;
} else {
temp_C[ci] = temp_B[bi];
ci++; bi++;
}
}


memcpy(local_A, temp_C, local_n*sizeof(POINT));


}

void Merge_split_high(int local_A[], int temp_B[], int temp_C[],
int local_n) {
int ai, bi, ci;

ai = local_n-1;
bi = local_n-1;
ci = local_n-1;
while (ci >= 0) {
if (local_A[ai] >= temp_B[bi]) {
temp_C[ci] = local_A[ai];
ci--; ai--;
} else {
temp_C[ci] = temp_B[bi];
ci--; bi--;
}
}


memcpy(local_A, temp_C, local_n*sizeof(POINT));

}

void Odd_even_iter(int local_A[], int temp_B[], int temp_C[],
int local_n, int phase, int even_partner, int odd_partner,
int my_rank, int p, MPI_Comm comm) {
//
// printf("\n oven inizio \n");
// Print_global_list(local_A,local_n,my_rank,p,comm);
MPI_Status status;

if (phase % 2 == 0) {
if (even_partner >= 0)
{
MPI_Sendrecv(local_A, local_n, MPI_INT, even_partner, 0,
temp_B, local_n, MPI_INT, even_partner, 0, comm,
&status);

if (my_rank % 2 != 0)
{
Merge_split_high(local_A, temp_B, temp_C, local_n);
Print_global_list(local_A, local_n, my_rankGlobale, sizeGlobale, comm);

}
else
{
Merge_split_low(local_A, temp_B, temp_C, local_n);
Print_global_list(local_A, local_n, my_rankGlobale, sizeGlobale, comm);

}
}
} else { /* odd phase */
if (odd_partner >= 0) {

MPI_Sendrecv(local_A, local_n, MPI_INT, odd_partner, 0,
temp_B, local_n, MPI_INT, odd_partner, 0, comm,
&status);

if (my_rank % 2 != 0)
{
Merge_split_low(local_A, temp_B, temp_C, local_n);
Print_global_list(local_A, local_n, my_rankGlobale, sizeGlobale, comm);

}
else
{
Merge_split_high(local_A, temp_B, temp_C, local_n);
Print_global_list(local_A, local_n, my_rankGlobale, sizeGlobale, comm);

}
}
}


}


void Sort(int local_A[], int local_n, int my_rank,int p, MPI_Comm comm)
{

int phase;
int *temp_B, *temp_C;
int even_partner; /* phase is even or left-looking */
int odd_partner; /* phase is odd or right-looking */

/* Temporary storage used in merge-split */
temp_B = (int*) malloc((local_n)*sizeof(int));
temp_C = (int*) malloc((local_n)*sizeof(int));

/* Find partners: negative rank => do nothing during phase */
if (my_rank % 2 != 0) {
even_partner = my_rank - 1;
odd_partner = my_rank + 1;
if (odd_partner == p) odd_partner = -1; // Idle during odd phase
} else {
even_partner = my_rank + 1;
if (even_partner == p) even_partner = -1; // Idle during even phase
odd_partner = my_rank-1;
}

/* Sort local list using built-in quick sort */
qsort(local_A, local_n, sizeof(int), Compare);
printf("\n lista speriamo ordinaata bene\n");
Print_listPoint(local_A,local_n,my_rank);


for (phase = 0; phase < p; phase++)
{
Odd_even_iter(local_A, temp_B, temp_C, local_n, phase,
even_partner, odd_partner, my_rank, p, comm);

}
free(temp_B);
free(temp_C);
}








void f(int i)
{

int local_n;
int c=0;
int f=0;
int somma=0;
local_n=(globalSize)/sizeGlobale;
somma=local_n*sizeGlobale;

if(somma==(globalSize))
{
}
else
{
c=(globalSize)-somma;
if(c>sizeGlobale)
{
local_n+=1;
c=c-sizeGlobale;
}
if(my_rankGlobale==sizeGlobale-1)
f=c;
}

int local_A[local_n+f];
Print_listPoint(punti,globalSize,my_rankGlobale);

Distr_list(local_A,local_n,sizeGlobale,my_rankGlob ale,punti,c);

Print_listPoint(local_A,local_n+f,my_rankGlobale);

Sort(local_A, local_n+f, my_rankGlobale, sizeGlobale, comm);
Print_global_list(local_A, local_n, my_rankGlobale, sizeGlobale, comm);
printf("\ndopo la global list\n");
for(int i=0;i<globalSize;i++)
printf("%d",local_A[i]);
printf("\n\n");
memcpy(punti, local_A, local_n*sizeof(int));
// OrdinaY(punti,globalSize);


drawLine(punti);
free(local_A);

}



void display(void)
{
int h;
for(int j=0;j<globalSize;j++)
{
h=(rand()%340)-120;
punti[j]=h;
}
drawLine(punti);

int q=glutCreateMenu(f);

glutAddMenuEntry("ordina i punti",1);
glutAttachMenu(GLUT_RIGHT_BUTTON);
}



void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
// glShadeModel (GL_FLAT);
}

void reshape(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

GLfloat fAspect;
fAspect = (GLfloat)w / (GLfloat)h;
gluPerspective(35.0f, fAspect, 1.0f, 1000.0f);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -400.0f);

}

void cleanup()
{

}



void handleKeypress(unsigned char key, int x, int y) {
switch (key) {
case 27: //Escape key
cleanup();
exit(0);

}
}





/*-------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
MPI_Init(&argc, &argv);
printf("ci sono");


comm = MPI_COMM_WORLD;

MPI_Comm_size(comm, &sizeGlobale);
MPI_Comm_rank(comm, &my_rankGlobale);
if(my_rankGlobale==0)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (600, 600);
glutInitWindowPosition (0, 0);
glutCreateWindow ("Marina");
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
printf("dovrei stampare la finestra");

glutKeyboardFunc(handleKeypress);

glutMainLoop();

}
free(punti);
MPI_Finalize();



return 0;
} /* main */

Loading