void levelSet3Dfast(MATRIXD im, MATRIX init_mask, int max_its, double E, double T, double alpha,
MATRIX *seg0, MATRIX *tmap, MATRIXD *phi, long **ls_vols, int offset){
long dx = im.dx, dy = im.dy, dz = im.dz;
int *px, *py, *pz, *qx, *qy, *qz, k, tmap_it = 1;
MATRIX intTmp;
MATRIX intTmp2 = allocateMatrix(dx,dy,dz); // add a new temporary matrix
MATRIXD dblTmp = allocateMatrixD(dx,dy,dz);
MATRIXD gradPhi = allocateMatrixD(dx,dy,dz);
int minx, maxx, miny, maxy, minz, maxz;
*phi = allocateMatrixD(dx,dy,dz);
*seg0 = allocateMatrix(dx,dy,dz);
*tmap = allocateMatrix(dx,dy,dz);
*ls_vols = (long *)calloc(max_its,sizeof(long)); // initialized with 0
initializeMatrix(tmap,0);
initializeMatrix(seg0,0); // initialized with 0
initializeMatrix(&intTmp2,0); // initialized with 0
initializeGlobals4bwdist(dx,dy,dz,&px,&py,&pz,&qx,&qy,&qz,&intTmp);
createSignedDistanceMap(init_mask,phi,px,py,pz,qx,qy,qz,intTmp,dblTmp); // temps: intTmp, dblTmp
findLimits(init_mask,offset,&minx,&maxx,&miny,&maxy,&minz,&maxz);
for (k = 1; k <= max_its; k++){
calculateCurvature(*phi,&dblTmp,minx,maxx,miny,maxy,minz,maxz); // dblTmp keeps the curvatures
calculateF(im,dblTmp,&dblTmp,E,T,alpha,minx,maxx,miny,maxy,minz,maxz); // first dblTmp (input): curvatures, second dblTmp (output): F values
calculateGradPhi(*phi,dblTmp,&gradPhi,minx,maxx,miny,maxy,minz,maxz);
evolveCurve(phi,dblTmp,gradPhi,minx,maxx,miny,maxy,minz,maxz);
if (k % 50 == 0)
reinitializeDistanceFunction(phi,init_mask,px,py,pz,qx,qy,qz,intTmp,dblTmp); // temps: init_mask, intTmp, dblTmp
(*ls_vols)[k-1] = selectNonpositive(*phi,&intTmp2,minx,maxx,miny,maxy,minz,maxz); // use the second temporarymatrix
if (k == 1){
selectNonpositive(*phi,seg0,minx,maxx,miny,maxy,minz,maxz);
copyMatrixWithLimits(tmap,*seg0,minx,maxx,miny,maxy,minz,maxz);
findLimits(*tmap,offset,&minx,&maxx,&miny,&maxy,&minz,&maxz);
}
else if (k % 10 == 0){
selectNonpositive(*phi,&intTmp2,minx,maxx,miny,maxy,minz,maxz); // use the second temporarymatrix
updateMaps(tmap,intTmp2,*seg0,tmap_it,minx,maxx,miny,maxy,minz,maxz); // use the second temporarymatrix
copyMatrixWithLimits(seg0,intTmp2,minx,maxx,miny,maxy,minz,maxz); // use the second temporarymatrix
tmap_it++;
findLimits(*tmap,offset,&minx,&maxx,&miny,&maxy,&minz,&maxz);
}
}
selectNonpositive(*phi,seg0,0,dx-1,0,dy-1,0,dz-1);
//selectNonpositive(*phi,seg0,minx,maxx,miny,maxy,minz,maxz); ???? (consider this modification if there are more problems)
freeMatrixD(gradPhi);
freeMatrixD(dblTmp);
freeMatrix(intTmp2);
freeGlobals4bwdist(px,py,pz,qx,qy,qz,intTmp);
}
/**
Initializes the Matrix.
@param width - the width of the matrix.
@param height - the height of the matrix.
@param value - the value to initialize every cell in the matrix.
*/
Matrix::Matrix(int width, int height, int value) {
_matrix = vector<int>();
setWidth(width);
setHeight(height);
if (value != -1)
initializeMatrix(value);
}
int main(int argc, char **argv) {
readConsoleValues(argc, argv);
//NUM_THREADS = 6;
//MATRIX_SIZE = 4;
matrixA.size = MATRIX_SIZE;
matrixResult.size = MATRIX_SIZE;
constructSquareMatrix(&matrixA);
constructSquareMatrix(&matrixResult);
initializeMatrix(&matrixA, -1);
initializeMatrix(&matrixResult, 0);
#pragma omp parallel shared(nextRowToCalc) num_threads(NUM_THREADS)
run();
//printMatrix(matrixA);
//printMatrix(matrixResult);
destroyMatrix(matrixA);
destroyMatrix(matrixResult);
printf("Main process [%i] finished\n", getpid());
exit(0);
}
void levelSet3D(MATRIXD im, MATRIX init_mask, int max_its, double E, double T, double alpha,
MATRIX *seg0, MATRIX *tmap, MATRIXD *phi, long **ls_vols){
// some of these variables will be used as the local variables for other functions
// they are defined outside (like global variables) because we want to decrease the overhead
// corresponding to allocation and deallocation (since we have multiple calls for the same function
long dx = im.dx, dy = im.dy, dz = im.dz;
int *px, *py, *pz, *qx, *qy, *qz, k, tmap_it = 1;
MATRIX intTmp;
MATRIXD dblTmp = allocateMatrixD(dx,dy,dz);
MATRIXD gradPhi = allocateMatrixD(dx,dy,dz);
*phi = allocateMatrixD(dx,dy,dz);
*seg0 = allocateMatrix(dx,dy,dz);
*tmap = allocateMatrix(dx,dy,dz);
*ls_vols = (long *)calloc(max_its,sizeof(long)); // initialized with 0
initializeMatrix(tmap,0);
initializeGlobals4bwdist(dx,dy,dz,&px,&py,&pz,&qx,&qy,&qz,&intTmp);
createSignedDistanceMap(init_mask,phi,px,py,pz,qx,qy,qz,intTmp,dblTmp); // temps: intTmp, dblTmp
for (k = 1; k <= max_its; k++){
calculateCurvature(*phi,&dblTmp,0,dx-1,0,dy-1,0,dz-1); // dblTmp keeps the curvatures
calculateF(im,dblTmp,&dblTmp,E,T,alpha,0,dx-1,0,dy-1,0,dz-1); // first dblTmp (input): curvatures, second dblTmp (output): F values
calculateGradPhi(*phi,dblTmp,&gradPhi,0,dx-1,0,dy-1,0,dz-1);
evolveCurve(phi,dblTmp,gradPhi,0,dx-1,0,dy-1,0,dz-1);
if (k % 50 == 0)
reinitializeDistanceFunction(phi,init_mask,px,py,pz,qx,qy,qz,intTmp,dblTmp); // temps: init_mask, intTmp, dblTmp
(*ls_vols)[k-1] = selectNonpositive(*phi,&intTmp,0,dx-1,0,dy-1,0,dz-1);
if (k == 1){
selectNonpositive(*phi,seg0,0,dx-1,0,dy-1,0,dz-1);
copyMatrix(tmap,*seg0);
}
else if (k % 10 == 0){
selectNonpositive(*phi,&intTmp,0,dx-1,0,dy-1,0,dz-1);
updateMaps(tmap,intTmp,*seg0,tmap_it,0,dx-1,0,dy-1,0,dz-1);
copyMatrix(seg0,intTmp);
tmap_it++;
}
}
selectNonpositive(*phi,seg0,0,dx-1,0,dy-1,0,dz-1);
freeMatrixD(gradPhi);
freeMatrixD(dblTmp);
freeGlobals4bwdist(px,py,pz,qx,qy,qz,intTmp);
}
void Matrix::allocate(const unsigned int rows, const unsigned int cols, const ValueType valueType)
{
if(m_data)
{
delete [] m_data;
m_data = 0;
}
unsigned int valueSize = Matrix::valueSize(valueType);
unsigned int bufferSize = rows * cols * valueSize;
m_data = new uint8_t[bufferSize];
setBuffer(m_data, bufferSize);
initializeMatrix(rows, cols, cols * valueSize, m_data, valueType);
}
static int PositionWeightMatrix_init( PositionWeightMatrix* self, PyObject* args, PyObject* kwds )
{
PyObject* listObj;
static char *kwlist[] = { "matrix", NULL };
if( !PyArg_ParseTupleAndKeywords( args, kwds, "O!", kwlist, &PyList_Type, &listObj ) )
return -1;
if( listObj )
{
return initializeMatrix( self, listObj );
}
//arg is not list, so error
return -1;
}
void solveProblem1(int numberOfAlterations, int initializationValue)
{
long long message[3];
if (procRank == 0)
{
long long matrix[8][8];
initializeMatrix(matrix);
while (!matrixIsComplete(matrix))
{
// Receive matrix coordinates along with value
MPI_Recv(message, 3, MPI_LONG_LONG, MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
matrix[message[0]][message[1]] = message[2];
}
printMatrix(matrix);
}
else
{
int i, j;
for (i = procRank - 1; i <= 64; i += procCount - 1)
{
long long value = initializationValue;
int x = i / 8;
int y = i % 8;
for (j = 1; j <= numberOfAlterations; j++)
{
usleep(1000);
value += (x + y) * j;
}
message[0] = x;
message[1] = y;
message[2] = value;
MPI_Send(message, 3, MPI_LONG_LONG, 0, 0, MPI_COMM_WORLD);
}
}
}
void reallocateMatrix(MATRIX *M, long row, long column){
int i, j, minrow, mincol;
MATRIX tmp = allocateMatrix(M->row,M->column);
copyMatrix(&tmp,*M);
freeMatrix(*M);
*M = allocateMatrix(row,column);
initializeMatrix(M,0);
if (tmp.row > row) minrow = row;
else minrow = tmp.row;
if (tmp.column > column) mincol = column;
else mincol = tmp.column;
for (i = 0; i < minrow; i++)
for (j = 0; j < mincol; j++)
M->data[i][j] = tmp.data[i][j];
freeMatrix(tmp);
}
int main() {
int** grid = initializeMatrix();
int score, force_exit, actualSelection = -1;
st = GetStdHandle(STD_OUTPUT_HANDLE);
restore_colorProfile(0);
allocateTail(&(Snake.tail), NULL, 0);
while (actualSelection != 0) {
mainMenuGraphics();
actualSelection = mainMenu(1);
if (actualSelection == 1) {
actualSelection = 0;
graphics_SelectGameMode();
while ((actualSelection != 1) && (actualSelection != 2)) {
actualSelection = mainMenu(2);
}
int gameMode = graphics_levelSelect();
initializeNewGame(grid, &score, &force_exit);
insertTitle();
drawInGameBorder();
displayPauseInstructions();
drawSnake(0, grid);
updateScore(score);
assignSnake2Matrix(grid, 1);
addFood(grid);
newGame(grid, &score, &force_exit, actualSelection - 1, gameMode);
if (!force_exit) {
_getch();
}
clear_screen();
restoreSnakeLength();
}
else if (actualSelection == 2) {
instructions();
}
}
return 0;
}
void master() {
double *a;
double *rhs;
int ntasks,pid;
double *buffer;
double *workbuf;
int i,j,k;
MPI_Status status;
time_t t0,t1;
int ct;
/* get the number of the processes in application. */
MPI_Comm_size(MPI_COMM_WORLD,&ntasks);
/* allocate matrix, rhs vector */
a = (double *) malloc( matrix_size*matrix_size*sizeof(double) ) ;
rhs = (double *) malloc( matrix_size*sizeof(double) ) ;
/* initialize the matrix */
/* Do we need to allocate a matrix a or ony a row
* * and initilize each row and then send to corresponding process? */
initializeMatrix( matrix_size, a, rhs );
/* Send each row to the corresponding process. */
for (i=block_size;i<matrix_size;i+=block_size) {
/* send i row to i+block_size-1 row to process
* * (i mod block_size)%ntasks. */
pid=(i/block_size)%ntasks;
if (pid!=0)
MPI_Send(&a[i*matrix_size],matrix_size*block_size,MPI_DOUBLE,
pid,i,MPI_COMM_WORLD);
}
MPI_Barrier(MPI_COMM_WORLD);
/* allocate buffer space, it should be big enough
* * to contaion a whole row of block. */
buffer=(double *)malloc(matrix_size*block_size*sizeof(double));
time(&t0);
/* Do the computation work of process 0 */
for (i=0;i<matrix_size;i+=block_size) {
/* compute the id of the processor that own the row i
* * to row i+block_size-1 */
pid=(i/block_size)%ntasks;
if (pid==0) { /* matser process. Me! */
/* factor diagonal */
lu0(&a[i+i*matrix_size],block_size,matrix_size);
/* modify "column" by diagonal */
for (j=i+block_size;j<matrix_size;j+=block_size)
bdiv(&a[j+i*matrix_size],&a[i+i*matrix_size],
block_size,matrix_size);
/* send this row to other processes, only need to send
* * the column after diagonal? */
for (j=1;j<ntasks;j++) {
MPI_Send(&a[i*matrix_size],block_size*matrix_size,MPI_DOUBLE,
j,i,MPI_COMM_WORLD);
}
workbuf=&a[i*matrix_size];
}
else { /* other process */
/* receive row i to row i+block_size-1 from process pid */
MPI_Recv(&buffer,block_size*matrix_size,MPI_DOUBLE,pid,i,
MPI_COMM_WORLD,&status);
workbuf=buffer;
}
/* modify the "row" using diagonal */
for (j=i+(ntasks-pid)*block_size;j<matrix_size;j+=block_size*ntasks)
bmodd(&a[i+j*matrix_size],&workbuf[i],
block_size,matrix_size);
/* modify the internal rows and columns */
for (j=i+(ntasks-pid)*block_size;j<matrix_size;j+=block_size*ntasks)
for (k=i+block_size;k<matrix_size;k+=block_size)
bmod(&a[k+j*matrix_size],&workbuf[k],&a[i+j*matrix_size],
block_size,matrix_size);
}
MPI_Barrier(MPI_COMM_WORLD);
time(&t1);
ct=t1-t0;
printf("LU decomposition took %d millisecs\n", ct);
/* Receive the modified matrix from all other processes. */
for (i=0;i<matrix_size;i+=block_size) {
/* compute the id of the processor that own the row i
* * to row i+block_size-1 */
pid=(i/block_size)%ntasks;
if (pid!=0)
MPI_Recv(&a[i*matrix_size],block_size*matrix_size,MPI_DOUBLE,pid,i,MPI_COMM_WORLD,&status);
}
/* test the resulting decoposition */
checkResult(matrix_size,a,rhs);
}
int main() {
for(int n=5; n<=200; n+=5) {
printf("\n%d iterations\n", n);
printf("---------------------------------\n");
int t = 0;
matrix A = initializeMatrix(n,n);
Triangles* workers = new Triangles[n];
Stopwatch timer;
timer.start();
for(int x = 0; x<n; x++) {
workers[x].setParameters(x, n, A);
if(!workers[x].StartInternalThread()) {
printf("Err pthread_create for thread %d \n", x+1);
}
}
for(int x=0; x<n; x++) {
workers[x].WaitForInternalThreadToExit();
t += workers[x].getResult();
}
t /= 3;
timer.stop();
float averageTime = [](Triangles* w, int n)->float {
float sum = 0;
for(int x = 0; x<n; x++) {
sum += w[x].getTime();
}
return sum/n;
}(workers, n);
float maxTime = [](Triangles* w, int n)->float {
float max = 0;
for(int x = 0; x<n; x++) {
if(w[x].getTime() > max) {
max = w[x].getTime();
}
}
return max;
}(workers, n);
float minTime = [](Triangles* w, int n)->float {
float min = w[0].getTime();
for(int x = 1; x<n; x++) {
if(w[x].getTime() < min) {
min = w[x].getTime();
}
}
return min;
}(workers, n);
float linearTime = [](Triangles* w, int n)->float {
float sum = 0;
for(int x = 0; x<n; x++) {
sum += w[x].getTime();
}
return sum;
}(workers, n);
float overallTime = timer.getTime();
printf("All tasks ended succesfully\n");
printf("Found %d triangles \n", t);
printf("Average search time:\t %.0f \n", averageTime);
printf("Max search time:\t %.0f \n", maxTime);
printf("Min search time:\t %.0f \n", minTime);
printf("Linear approximate time: %.0f \n", linearTime);
printf("Overall search time:\t %.0f\n", overallTime);
printf("---------------------------------\n");
}
getchar();
return 0;
}
//Parallel matrix constructor
ParallelBooleanMatrix::ParallelBooleanMatrix(int rows, int columns) : BooleanMatrix(rows, columns) {
initializeMatrix();
}
//Serial matrix constructor
SerialBooleanMatrix::SerialBooleanMatrix(int rows, int columns) : BooleanMatrix(rows, columns) {
initializeMatrix();
}
void solveProblem2(int numberOfAlterations, int initializationValue)
{
long long message[9];
if (procRank == 0)
{
long long matrix[8][8];
initializeMatrix(matrix);
while (!matrixIsComplete(matrix))
{
// Receive row number and all values for that row
MPI_Recv(message, 9, MPI_LONG_LONG, MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
int i;
for (i = 0; i < 8; i++)
{
matrix[message[0]][i] = message[i+1];
}
}
printMatrix(matrix);
}
else if (procRank <= 16)
{
long long row[8];
long long previousRow[numberOfAlterations + 1];
int rowNum = (procRank - 1) / 2;
int i, j;
for (i = 0; i < 8; i++)
row[i] = initializationValue;
for (i = 0; i <= numberOfAlterations; i++)
previousRow[i] = initializationValue;
if (procRank % 2 == 1)
{
for (j = 0; j < 8; j++)
{
for (i = 1; i <= numberOfAlterations / 2; i++)
{
usleep(1000);
if (j == 0)
row[0] += rowNum * i;
else
row[j] += previousRow[i] * i;
previousRow[i] = row[j];
}
message[0] = row[j];
MPI_Send(message, 1, MPI_LONG_LONG, procRank + 1, 0, MPI_COMM_WORLD);
}
}
else
{
for (j = 0; j < 8; j++)
{
MPI_Recv(message, 1, MPI_LONG_LONG, procRank - 1, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
row[j] = message[0];
for (i = numberOfAlterations / 2 + 1; i <= numberOfAlterations; i++)
{
usleep(1000);
if (j == 0)
row[0] += rowNum * i;
else
row[j] += previousRow[i] * i;
previousRow[i] = row[j];
}
}
message[0] = rowNum;
for (i = 0; i < 8; i++)
message[i+1] = row[i];
MPI_Send(message, 9, MPI_LONG_LONG, 0, 0, MPI_COMM_WORLD);
}
}
}
int main(int argc, char** argv){
int opt;
int* s;//listes des tailles
int* e;//liste des etapes
int* t = NULL;//liste des nombres de threads
// Declaration des options
int i = 0;
int m = 0, M = 0, a = 0;
int nbProblems = 0;
int nbEtapes = 0;
int nbDifferentThreads = 0;
// Recuperer les options du programme
while ((opt = getopt(argc,argv,"s:mMai:e:t:")) != -1){
switch(opt){
// [0-9] : taille du probleme a executer, 2**(s+4) cases sur une ligne
case 's':
// Verifier si l'option contient des valeurs non autorisees
if (atoi(optarg) == 0) {
optarg = "0";
}
// Recuperer le nombre de problemes a traiter et leur taille, puis initialiser le tableau
nbProblems = strlen(optarg);
if( (s = malloc(sizeof(int) * nbProblems)) == NULL){
fprintf(stderr,"Allocation impossible \n");
exit(EXIT_FAILURE);
}
int j = 0;
for(j = 0; j < nbProblems; j++) {
s[j] = optarg[j] - '0';
}
break;
// mesure et affichage du temps d'execution (consommation du CPU),
// suppression de toute trace d'execution
case 'm':
// on executera 10 fois chaque scenario puis on eliminera les deux
// extremes pour faire la moyenne des 8 executions restantes
m = 1;
if (a) {
a = 0;
}
break;
// mesure et affichage du temps d'execution (temps de reponse utilisateur),
// suppression de tout trace d'executuion
case 'M':
// on executera 10 fois chaque scenario puis on eliminera les deux
// extremes pour faire la moyenne des 8 executions restantes
M = 1;
if (a) {
a = 0;
}
break;
// affichage de la temperature initiale et de la temperature finale pour les indices
// correspondant au quart superieur gauche du tableau, pour les indices modulo 2**s
case 'a':
// par defaut : on n'affiche rien
if (!(m || M)) {
a = 1;
}
break;
// number : nombre d'iteration a executer
case 'i':
// par defaut 10 000 iterations
i = atoi(optarg);
if (i == 0) {
i = 10000;
}
break;
// [0-5] : etape du programme a executer
case 'e':
// 0 : iteratif
// 1 : thread avec barriere Posix
// 2 : thread avec barriere implementee avec variable condition
// 3 : thread avec barriere implementee avec semaphore
// 4 : programme OpenCL calcul sur CPU
// 5 : programme OpenCL calcul sur GPU
// Verifier si l'option contient des valeurs non autorisees
if (atoi(optarg) == 0) {
optarg = "0";
}
// Recupere les etapes du programme a executer
nbEtapes = strlen(optarg);
if( (e = malloc(sizeof(int) * nbEtapes)) == NULL){
fprintf(stderr,"Allocation impossible \n");
exit(EXIT_FAILURE);
}
int k = 0;
for(k = 0; k < nbEtapes; k++) {
e[k] = optarg[k] - '0';
}
break;
// [0-5] : nombre de thread a creer
case 't':
// 4**t thread a creer, t varie entre 0 (iteratif) et 5 (1024 threads)
// concerne bien evidemment les etapes 1 a 5, sans effet sur etape 0
nbDifferentThreads = strlen(optarg);
if( (t = malloc(sizeof(int) * nbDifferentThreads)) == NULL){
fprintf(stderr,"Allocation impossible \n");
exit(EXIT_FAILURE);
}
int l;
for(l=0;l<nbDifferentThreads;l++){
t[l] = optarg[l] - '0';
}
break;
}
}
int j, k, l;
int size = 0;
float** mat1 = NULL;
float** mat2;
int iteration = 0;
int n = 0;
time_t debutTemp, finTemp;
clock_t start_t, end_t;
//iteration sur le nombre d'etapes a executer (option -e)
for(l = 0 ; l<nbEtapes ; l++){
etapeEnCours=e[l];//sauvegarde de l'etape en cours.
// Iteration sur le nombre de problemes a lancer (option -s)
for (j = 0; j < nbProblems; j++) {
int indexThread;
int numberOfThreads=0;
int endAllThreads=nbDifferentThreads;
int ThreadOk = 1;
if(t==NULL || e[l]==0){endAllThreads=1;ThreadOk=0;}//pour passer une fois dans la boucle for.
for(indexThread=0;indexThread<endAllThreads;indexThread++){
n = s[j] + 4;
size = (1 << n) + 2;
// Allocation memoire des matrices a utiliser
if( (mat1 = malloc(sizeof(float*) * size)) == NULL){
fprintf(stderr,"Allocation impossible \n");
exit(EXIT_FAILURE);
}
for (k = 0; k < size; k++) {
if( (mat1[k] = malloc(sizeof(float) * size)) == NULL){
fprintf(stderr,"Allocation impossible \n");
exit(EXIT_FAILURE);
}
}
if( (mat2 = malloc(sizeof(float*) * size)) == NULL){
fprintf(stderr,"Allocation impossible \n");
exit(EXIT_FAILURE);
}
for (k = 0; k < size; k++) {
if( (mat2[k] = malloc(sizeof(float) * size)) == NULL){
fprintf(stderr,"Allocation impossible \n");
exit(EXIT_FAILURE);
}
}
// Initialisation des matrices
defineConstants(size, n);
initializeMatrix(*mat1, size);
initializeMatrix(*mat2, size);
int counter = 1;
float* times;
float* clocks;
// Si l'option m ou M a ete entree, le compteur est mis a 10 pour calculer la moyenne de temps
if (m) {
counter = 10;
if( (clocks = malloc(sizeof(float) * counter)) == NULL){
fprintf(stderr,"Allocation impossible \n");
exit(EXIT_FAILURE);
}
}
if (M) {
counter = 10;
if( (times = malloc(sizeof(float) * counter)) == NULL){
fprintf(stderr,"Allocation impossible \n");
exit(EXIT_FAILURE);
}
}
if(ThreadOk){
numberOfThreads = (1 << (2*t[indexThread]));//pow(4,t[indexThread]);
}
for (k = 0; k < counter; k++) {
if (m) {
start_t = clock();
}
if (M) {
debutTemp = time(NULL);
}
switch(e[l]){
case 0:
//printf("Execution de l'etape 0 ...[size matrix : %d]\n",size-2);
if (a) {
printf("VALEUR INITIAL\n");
printMatrix(*mat1,size);
}
for (iteration = 0; iteration < i; iteration++) {
nextStep(*mat1, *mat2, size);
}
if(a){
printf("VALEUR FINALE\n");
printMatrix(*mat1,size);
}
break;
case 1:
//printf("Execution de l'etape 1 ...[size matrix : %d, nb Threads : %d]\n",size-2,numberOfThreads);
if(a){
printf("AVANT\n");
printMatrix(*mat1,size);
}
tab = decoupageMatrice(numberOfThreads,size-2);
for (iteration = 0; iteration < i; iteration++) {
nextStepBarrier(*mat1, *mat2, size, numberOfThreads);
}
if(a){
printf("APRES\n");
printMatrix(*mat1,size);
}
break;
case 2:
//printf("Execution de l'etape 2 ...[size matrix : %d, nb Threads : %d]\n",size-2,numberOfThreads);
if(a){
printf("AVANT\n");
printMatrix(*mat1,size);
}
tab = decoupageMatrice(numberOfThreads,size-2);
for (iteration = 0; iteration < i; iteration++) {
nextStepBarrier(*mat1, *mat2, size, numberOfThreads);
}
if(a){
printf("APRES\n");
printMatrix(*mat1,size);
}
break;
case 3:
//printf("Execution de l'etape 3 ...[size matrix : %d, nb Threads : %d]\n",size-2,numberOfThreads);
if(a){
printf("AVANT\n");
printMatrix(*mat1,size);
}
tab = decoupageMatrice(numberOfThreads,size-2);
for (iteration = 0; iteration < i; iteration++) {
nextStepBarrier(*mat1, *mat2, size, numberOfThreads);
}
if(a){
printf("APRES\n");
printMatrix(*mat1,size);
}
break;
case 4:
//printf("Execution de l'etape 4 ...\n");
break;
case 5:
//printf("Execution de l'etape 5 ...\n");
break;
default:
//ne rien faire
printf("Veuillez entrer une valeur correcte pour l'option -e\n");
break;
}
if (m) {
end_t = clock();
clocks[k] = (float)(end_t - start_t) / CLOCKS_PER_SEC;
}
if (M) {
finTemp = time(NULL);
times[k] = (float)(finTemp - debutTemp);
}
}
if (m) {
if(ThreadOk){
printf("Average clock for s = %d e = %d t = %d : %f\n", s[j], e[l], t[indexThread], getAverageClockWithoutExtremes(clocks, counter));
}
else{
printf("Average clock for s = %d e = %d : %f\n", s[j], e[l], getAverageClockWithoutExtremes(clocks, counter));
}
free(clocks);
}
if (M) {
if(ThreadOk){
printf("Average time for s = %d e = %d t = %d : %f\n", s[j], e[l], t[indexThread], getAverageClockWithoutExtremes(times, counter));
}
else{
printf("Average time for s = %d e = %d : %f\n", s[j], e[l], getAverageClockWithoutExtremes(times, counter));
}
free(times);
}
}
}
}
return 0;
}
int main(int argc, char* argv[]) {
int myrank;
int nodes;
double *a;
int nbDims = 2;
int dims[2];
int i, j, k, noTest;
Arguments arguments;
arguments.matrix_size = -1;
arguments.matrice = arguments.solution = NULL;
arguments.imprimer = 0;
arguments.pivot = 0;
arguments.write = NULL;
MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD,&myrank);
MPI_Comm_size(MPI_COMM_WORLD, &nodes);
for(i = 1; i < argc; i++) {
if(argv[i][0] == '-') {
switch(argv[i][1]) {
case 'm': if(i+1 < argc) {
arguments.matrix_size = atoi(argv[++i]);
}
break;
case 'f': if(i+1 < argc) {
arguments.matrice = argv[++i];
}
break;
case 's': if(i+1 < argc) {
arguments.solution = argv[++i];
}
break;
case 'p': arguments.pivot = 1;
break;
case 'i': arguments.imprimer = 1;
break;
case 'x': if(i+1 < argc) {
dims[0] = atoi(argv[++i]);
}
break;
case 'y': if(i+1 < argc) {
dims[1] = atoi(argv[++i]);
}
break;
case 'w': if(i+1 < argc) {
arguments.write = argv[++i];
}
break;
default: fprintf(stderr, "Usage: %s -m <tailleMatrice> "\
"-x <lignes> -y <colonnes> [-w nomFichier]" \
"[-f nomFichier] [-s solution]\n", argv[0]);
exit(EXIT_FAILURE);
}
}
}
if(arguments.matrix_size < 0) {
fprintf(stderr,"Erreur: vous devez fournir une taille de matrice.\n");
exit(EXIT_FAILURE);
}
if((arguments.matrix_size % nodes != 0) || (nodes % dims[0] !=0)
|| (nodes % dims[1] !=0)) {
fprintf(stderr, "Erreur: le nombre de noeuds doit diviser la"\
"et les colonnes et lignes doivent diviser le nombre de noeuds .\n");
exit(EXIT_FAILURE);
}
//On part la minuterie
double tempsEcoule = -MPI_Wtime();
//On crée la topologie
int period[] = {1,0};
int reorder = 1;
int coord[2]; //Pour ma position
MPI_Comm comm;
MPI_Cart_create(MPI_COMM_WORLD, nbDims, dims, period, reorder, &comm);
//On imprime
MPI_Cart_coords(comm, myrank, nbDims, coord);
//Maintenant on crée les matrices
int nbLinesParBloc = arguments.matrix_size / dims[0];
int nbColsParBloc = arguments.matrix_size / dims[1];
if(arguments.matrice) {
a = readMatrixCart(arguments.matrice, arguments.matrix_size,
nbColsParBloc, nbLinesParBloc, coord);
} else {
a = (double*)malloc(nbLinesParBloc*nbColsParBloc*sizeof(double));
initializeMatrix(nbColsParBloc, nbLinesParBloc,a);
}
//On crée les communicateurs pour les colonnes et les lignes
MPI_Comm lignes;
MPI_Comm colonnes;
int cols[2] = {1,0};
int lines[2] = {0,1};
MPI_Cart_sub(comm, lines, &lignes);
MPI_Cart_sub(comm, cols, &colonnes);
factoriserLU(a, arguments.matrix_size, nbLinesParBloc, nbColsParBloc,
lignes, colonnes, coord);
//On fait la décomposition
double tempsMax;
tempsEcoule += MPI_Wtime();
MPI_Reduce( &tempsEcoule, &tempsMax, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD );
if(arguments.solution) {
//on vérifie le résultat
double *resultat = readMatrixCart(arguments.solution, arguments.matrix_size,
nbColsParBloc, nbLinesParBloc, coord);
checkResult(resultat, a, nbColsParBloc, nbLinesParBloc, MPI_COMM_WORLD);
if(myrank==0) {
printf("Resultat de la factorisation lu correcte.\n");
}
if(resultat) free(resultat);
}
if (myrank == 0) {
printf( "Factorisation LU sans pivot effectuee en %.3f msecs\n",
1000*tempsEcoule);
}
if(arguments.imprimer || arguments.write) {
//Si mon rang est 0 pour mon communicateur Lignes
double *lines;
if(coord[1] == 0) {
lines = (double *)malloc(nbLinesParBloc*arguments.matrix_size*sizeof(double));
}
//On rebatit les lignes
for(i = 0; i < nbLinesParBloc; i++) {
MPI_Gather(&a[i*nbColsParBloc], nbColsParBloc, MPI_DOUBLE,
&lines[i*arguments.matrix_size], nbColsParBloc, MPI_DOUBLE, 0, lignes);
}
double *matriceComplete;
if(myrank ==0) { //Je suis la racine, rank ==0 aussi
matriceComplete = (double *)malloc(arguments.matrix_size*
arguments.matrix_size*sizeof(double));
}
//On fait la communication
if(coord[1] ==0){ //Je suis dans la colonne 0 -- à vérifier
MPI_Gather(lines, arguments.matrix_size*nbLinesParBloc,
MPI_DOUBLE, matriceComplete, arguments.matrix_size*
nbLinesParBloc, MPI_DOUBLE, 0, colonnes);
free(lines);
}
if(myrank == 0) {
if(arguments.imprimer) {
printMatrix(arguments.matrix_size, arguments.matrix_size,
matriceComplete);
}
if(arguments.write) {
writeMatrix(arguments.matrix_size, arguments.matrix_size,
matriceComplete, arguments.write);
}
free(matriceComplete);
}
}
MPI_Finalize();
if(a) free(a);
return 0;
}
int main(int argc, char* argv[]) {
int myrank;
int nodes;
double *a;
int i, j, k, noTest;
Arguments arguments;
arguments.matrix_size = -1;
arguments.matrice = arguments.solution = NULL;
arguments.imprimer = 0;
arguments.pivot = 0;
arguments.write = NULL;
MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD,&myrank);
MPI_Comm_size(MPI_COMM_WORLD, &nodes);
for(i = 1; i < argc; i++) {
if(argv[i][0] == '-') {
switch(argv[i][1]) {
case 'm': if(i+1 < argc) {
arguments.matrix_size = atoi(argv[++i]);
}
break;
case 'f': if(i+1 < argc) {
arguments.matrice = argv[++i];
}
break;
case 's': if(i+1 < argc) {
arguments.solution = argv[++i];
}
break;
case 'p': arguments.pivot = 1;
break;
case 'i': arguments.imprimer = 1;
break;
case 'w': if(i+1 < argc) {
arguments.write = argv[++i];
}
break;
default: fprintf(stderr, "Usage: %s -m <tailleMatrice> "\
"[-f nomFichier] [-s solution]\n", argv[0]);
exit(EXIT_FAILURE);
}
}
}
if(arguments.matrix_size < 0) {
fprintf(stderr,"Erreur: vous devez fournir une taille de matrice.\n");
exit(EXIT_FAILURE);
}
if(arguments.matrix_size % nodes != 0) {
fprintf(stderr, "Erreur: le nombre de noeuds doit diviser la"\
"taille de la matrice.\n");
exit(EXIT_FAILURE);
}
MPI_Barrier( MPI_COMM_WORLD );
int nbLines = arguments.matrix_size / nodes;
if(arguments.matrice) {
a = readMatrixCyclic(arguments.matrice, arguments.matrix_size,
nbLines, myrank, nodes);
} else {
a = (double *) malloc( nbLines*arguments.matrix_size*sizeof(double) );
initializeMatrix( arguments.matrix_size, nbLines, a);
}
double tempsEcoule;
MPI_Barrier( MPI_COMM_WORLD );
tempsEcoule = -MPI_Wtime();
factoriserLU(a, arguments.matrix_size, nbLines, MPI_COMM_WORLD, myrank,
arguments.pivot, nodes);
double tempsMax;
tempsEcoule += MPI_Wtime();
//On ramene le temps max au processeur 0
MPI_Reduce(&tempsEcoule, &tempsMax, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);
if(arguments.solution) {
//on vérifie le résultat
double *resultat = readMatrixCyclic(arguments.solution,
arguments.matrix_size, nbLines, myrank, nodes);
checkResult(resultat, a, arguments.matrix_size, nbLines, MPI_COMM_WORLD);
if(myrank == 0) {
printf("Resultat de la factorisation lu correcte.\n");
}
if(resultat) free(resultat);
}
if (myrank == 0) {
printf( "Factorisation LU %s pivot effectuee en %.3f msecs\n",
(arguments.pivot?"avec":"sans"), 1000*tempsEcoule);
}
if(arguments.imprimer || arguments.write) {
//On test pour récupérer la matrice
double *matriceComplete;
if(myrank == 0) {
matriceComplete = (double *) malloc(arguments.matrix_size*
arguments.matrix_size*sizeof(double));
}
for( i = 0; i < nbLines; i++) {
MPI_Gather(&a[i*arguments.matrix_size], arguments.matrix_size, MPI_DOUBLE,
&matriceComplete[i*nodes*arguments.matrix_size],
arguments.matrix_size, MPI_DOUBLE, 0, MPI_COMM_WORLD);
}
if( myrank == 0) {
if(arguments.imprimer) {
printMatrix(arguments.matrix_size, arguments.matrix_size,
matriceComplete);
}
if(arguments.write) {
writeMatrix(arguments.matrix_size, arguments.matrix_size,
matriceComplete, arguments.write);
}
if(matriceComplete) free(matriceComplete);
}
}
#ifndef NDEBUG
printf("rank G:%i\n",myrank);
#endif
if(a)free(a);
MPI_Finalize();
return 0;
}
Map CreateMap(ConfigurationManager config)
{
std::vector<unsigned char> image;
unsigned width, height;
unsigned int x, y;
const char* path = config.getMapPath();
unsigned error = lodepng::decode(image, width, height, path);
if (error)
{
std::cout << "decoder error " << error << ": "
<< lodepng_error_text(error) << std::endl;
}
// Get parameters
double gridResoultion = config.getGridResolutionCM();
double mapResoultion = config.getMapResolutionCM();
int divider = ceil(gridResoultion/mapResoultion); // Numbers of pixels for 1 cell in matrix
// Create map as png pixels
char** map = initializeMatrix(height + (divider - 1) * 2,width + (divider - 1) * 2, FREE_CELL);
unsigned char color;
for (y = 0; y < height; y++)
{
for (x = 0; x < width; x++)
{
if (image[y * width * 4 + x * 4 + 0]
|| image[y * width * 4 + x * 4 + 1]
|| image[y * width * 4 + x * 4 + 2])
{
// There is an obstacle in the map
color = FREE_CELL;
}
else
{
// There is no obstacle
color = BLOCK_CELL;
}
map[y + divider - 1][x + divider - 1] = color;
}
}
// Create map as config cm size
int newMapHieght = height/divider;
int newMapWidth = width/divider;
char** mapBlow = initializeMatrix(newMapHieght, newMapWidth, FREE_CELL);
unsigned i,j;
int mapBlowY = 0, mapBlowX = 0;
bool hasObstacle = false;
for (y = divider - 1; y < height; y += divider)
{
for (x = divider - 1; x < width; x += divider)
{
for (i = 0; i < divider && !hasObstacle; i++)
{
for (j = 0; j < divider && !hasObstacle; j++)
{
if (map[y + i][x + j] == BLOCK_CELL)
{
hasObstacle = true;
}
}
}
if (hasObstacle)
{
mapBlow[mapBlowY][mapBlowX] = BLOCK_CELL;
}
hasObstacle = false;
mapBlowX++;
}
mapBlowX = 0;
mapBlowY++;
}
// ReSize obstacle
double* robotSize = config.getRobotSize();
int sizeH = ceil(((robotSize[0] / gridResoultion)- 1) / 2);
int sizeW = ceil(((robotSize[1] / gridResoultion)- 1) / 2);
char** newMap = initializeMatrix(newMapHieght + sizeH*2, newMapWidth + sizeW*2, FREE_CELL);
for (int i = 0; i < newMapHieght; i++)
{
for (int j = 0; j < newMapWidth; j++)
{
if (mapBlow[i][j] == BLOCK_CELL)
{
for (int iNewMap = i; iNewMap <= i + sizeH + 1; iNewMap++)
{
for (int jNewMap = j; jNewMap <= j + sizeW + 1; jNewMap++)
{
newMap[iNewMap][jNewMap] = BLOCK_CELL;
}
}
}
}
}
// Initialize final map with wall block of size 1.
char** finalMap = initializeMatrix(newMapHieght + 2, newMapWidth + 2, BLOCK_CELL);
for (int i=1; i < newMapHieght + 1; i++)
{
for (int j=1; j< newMapWidth + 1; j++)
{
finalMap[i][j] = newMap[sizeH + i - 1][sizeW + j -1];
}
}
printMap(map, height + 6, width + 6);
printMap(mapBlow, newMapHieght, newMapWidth);
printMap(newMap, newMapHieght + sizeH, newMapWidth + sizeW);
printMap(finalMap, newMapHieght + 2, newMapWidth + 2);
return Map(finalMap, newMapHieght + 2, newMapWidth + 2, gridResoultion / 100);
}
//Parallel matrix constructor
ParallelMatrix::ParallelMatrix(int rows, int columns, bool initialize) : Matrix(rows, columns) {
if (initialize) {
initializeMatrix();
}
}
void Simulation::initialize()
{
initializePores(pores, matrix, options);
initializeMatrix(pores, matrix, options);
}
