peter.babic
/
openmpi-assignments
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

spread_evenly() now accepts multiplier

Browse Source
master
Peter Babič 9 years ago
parent 58eabb28ca
commit e379185843
8 changed files with 94 additions and 58 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 4
      assignment1.c
  2. 4
      assignment2.c
  3. 119
      assignment3.c
  4. 3
      assignment3.in1
  5. 3
      assignment3.in2
  6. 14
      common.c
  7. 4
      common.h
  8. 1
      run

4
assignment1.c
Unescape View File

@ -35,9 +35,9 @@ int main(int argc, char *argv[]) {
fclose(ptrFile);
checkParallelWorth(numProcesses, sizeBufferUsed);
check_parallel_worth(numProcesses, sizeBufferUsed, 2);
spread_evenly(numProcesses, sizeBufferUsed, &arrBlockIndices, &arrBlockSizes);
spread_evenly(numProcesses, sizeBufferUsed, 1, &arrBlockIndices, &arrBlockSizes);
}

4
assignment2.c
Unescape View File

@ -19,11 +19,11 @@ int main(int argc, char *argv[]) {
arrMatrixOriginal = read_matrix_file(INPUTFILE, &numCols, &numCount);
checkParallelWorth(numProcesses, numCount);
check_parallel_worth(numProcesses, numCount, 2);
arrIndicesTransp = my_malloc(numCount * sizeof(int));
spread_evenly(numProcesses, numCount, &arrBlockIndices, &arrBlockSizes);
spread_evenly(numProcesses, numCount, 1, &arrBlockIndices, &arrBlockSizes);

119
assignment3.c
Unescape View File

@ -3,7 +3,13 @@
#define INPUTFILE1 "assignment3.in1"
#define INPUTFILE2 "assignment3.in2"
#define DIM_COUNT1 0
#define DIM_COUNT2 1
#define DIM_COLS1 2
#define DIM_COLS2 3
#define DIM_ROWS1 4
#define DIM_ROWS2 5
#define NUM_DIMS 6
int main(int argc, char *argv[]) {
int numProcesses, numRank;
@ -13,63 +19,84 @@ int main(int argc, char *argv[]) {
MPI_Comm_size(MPI_COMM_WORLD, &numProcesses);
MPI_Comm_rank(MPI_COMM_WORLD, &numRank);
int *arrMatrix1, *arrMatrix2, *arrIndicesTransp, *arrBlockSizes, *arrBlockIndices;
int numCols1, numCount1 = 0, numCols2, numCount2 = 0;
int *arrMatrix1, *arrMatrix2, *arrBlockSizes, *arrBlockIndices;
int arrDimensions[NUM_DIMS] = {0};
if (numRank == 0) {
arrMatrix1 = read_matrix_file(INPUTFILE1, &numCols1, &numCount1);
arrMatrix2 = read_matrix_file(INPUTFILE2, &numCols2, &numCount2);
checkParallelWorth(numProcesses, numCount2);
arrMatrix1 = read_matrix_file(INPUTFILE1, &arrDimensions[DIM_COLS1], &arrDimensions[DIM_COUNT1]);
// Matrix transposition was done in assignment2 so we will assume already transposed matrix
arrMatrix2 = read_matrix_file(INPUTFILE2, &arrDimensions[DIM_COLS2], &arrDimensions[DIM_COUNT2]);
arrIndicesTransp = my_malloc(numCount2 * sizeof(int));
arrDimensions[DIM_ROWS1] = arrDimensions[DIM_COUNT1] / arrDimensions[DIM_COLS1];
arrDimensions[DIM_ROWS2] = arrDimensions[DIM_COUNT2] / arrDimensions[DIM_COLS2];
spread_evenly(numProcesses, numCount2, &arrBlockIndices, &arrBlockSizes);
if (arrDimensions[DIM_ROWS1] != arrDimensions[DIM_ROWS2]) {
printf("Matrices cannot be multiplied! Check dimensions.\n");
exit(EXIT_FAILURE);
}
check_parallel_worth(numProcesses, arrDimensions[DIM_ROWS1], 1);
//arrIndicesTransp = my_malloc(arrDimensions[DIM_COUNT2] * sizeof(int));
}
spread_evenly(numProcesses, arrDimensions[DIM_ROWS1], arrDimensions[DIM_COLS1], &arrBlockIndices, &arrBlockSizes);
MPI_Bcast(&numCount2, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&numCols2, 1, MPI_INT, 0, MPI_COMM_WORLD);
//printf("size %2d, index %2d, buffer %2d, rank %d\n", packet[0], packet[1], packet[CODE_COUNT], numRank);
int arrBlockData[NUM_CODES];
MPI_Recv(arrBlockData, NUM_CODES, MPI_INT, 0, 1, MPI_COMM_WORLD, &status);
//We can calculate numRows2 * numCols2 = numCount2
int numRows2 = numCount2 / numCols2;
int *arrIndicesSub = my_malloc(numCount2 * sizeof(int));
//for (int i = arrBlockData[CODE_INDEX]; i < (arrBlockData[CODE_SIZE] + arrBlockData[CODE_INDEX]); i++) {
for (int i = 0; i < arrBlockData[CODE_SIZE]; i++) {
// Only the indices are transposed in parallel
int index = transpose_index(i + arrBlockData[CODE_INDEX], numRows2, numCols2);
arrIndicesSub[i] = index;
}
//if (numRank == 0)
MPI_Gatherv(arrIndicesSub, arrBlockData[CODE_SIZE], MPI_INT, arrIndicesTransp, arrBlockSizes, arrBlockIndices,
MPI_INT, 0, MPI_COMM_WORLD);
if (numRank == 0 ) {
printf("normal 1st matrix: \n");
for (int i = 0; i < numCount1; i++) {
printf("%d ", arrMatrix1[i]);
if ((i + 1) % numCols1 == 0)
printf("\n");
}
printf("\n");
}
if (numRank == 0) {
printf("transposed 2nd matrix:");
for (int i = 0; i < numCount2; i++) {
if (i % numRows2 == 0)
printf("\n");
printf("%d ", arrMatrix2[arrIndicesTransp[i]]);
}
printf("\n");
}
//MPI_Bcast(arrDimensions, NUM_DIMS, MPI_INT, 0, MPI_COMM_WORLD);
//int *arrSlice1 = my_malloc(arrDimensions[DIM_COUNT1] * sizeof(int));
//MPI_Scatterv(arrMatrix1, arrBlockSizes, arrBlockIndices, MPI_INT, arrSlice1, arrDimensions[DIM_COUNT1], MPI_INT, 0, MPI_COMM_WORLD);
//int *arrSlice2 = my_malloc(arrDimensions[DIM_COUNT2] * sizeof(int));
//MPI_Scatterv(arrMatrix2, arrBlockSizes, arrBlockIndices, MPI_INT, arrSlice2, arrDimensions[DIM_COUNT2], MPI_INT, 0, MPI_COMM_WORLD);
////MPI_Bcast(&arrDimensions[DIM_COUNT2], 1, MPI_INT, 0, MPI_COMM_WORLD);
////MPI_Bcast(&numCols2, 1, MPI_INT, 0, MPI_COMM_WORLD);
//int arrBlockData[NUM_CODES];
//MPI_Recv(arrBlockData, NUM_CODES, MPI_INT, 0, 1, MPI_COMM_WORLD, &status);
////printf("rank %d, size %d, indices %d\n", numRank, arrBlockData[CODE_SIZE], arrBlockData[CODE_INDEX]);
////printf("nc1 %d, nc2 %d\n", arrDimensions[DIM_COUNT1], arrDimensions[DIM_COUNT2]);
//for (int i = 0; i < arrBlockData[CODE_SIZE]; i++) {
//printf("rank %d, slice1[%d] = %d\n", numRank, i, arrSlice1[i]);
//}
////We can calculate arrDimensions[DIM_ROWS2] * numCols2 = numCount2
//int arrDimensions[DIM_ROWS2] = numCount2 / numCols2;
//int *arrIndicesSub = my_malloc(numCount2 * sizeof(int));
////for (int i = arrBlockData[CODE_INDEX]; i < (arrBlockData[CODE_SIZE] + arrBlockData[CODE_INDEX]); i++) {
//for (int i = 0; i < arrBlockData[CODE_SIZE]; i++) {
//// Only the indices are transposed in parallel
//int index = transpose_index(i + arrBlockData[CODE_INDEX], arrDimensions[DIM_ROWS2], numCols2);
//arrIndicesSub[i] = index;
//}
////if (numRank == 0)
//MPI_Gatherv(arrIndicesSub, arrBlockData[CODE_SIZE], MPI_INT, arrIndicesTransp, arrBlockSizes, arrBlockIndices,
//MPI_INT, 0, MPI_COMM_WORLD);
//if (numRank == 0 ) {
//printf("normal 1st matrix: \n");
//for (int i = 0; i < arrDimensions[DIM_COUNT1]; i++) {
//printf("%d ", arrMatrix1[i]);
//if ((i + 1) % numCols1 == 0)
//printf("\n");
//}
//printf("\n");
//}
//if (numRank == 0) {
//printf("transposed 2nd matrix:");
//for (int i = 0; i < arrDimensions[DIM_COUNT2]; i++) {
//if (i % arrDimensions[DIM_ROWS2] == 0)
//printf("\n");
//printf("%d ", arrMatrix2[arrIndicesTransp[i]]);
//}
//printf("\n");
//}
MPI_Finalize();
return 0;

3
assignment3.in1
Unescape View File

@ -1,2 +1,5 @@
1 2 3
4 5 6
7 8 9
10 11 12
13 14 15

3
assignment3.in2
Unescape View File

@ -1,2 +1,5 @@
1 2 3
4 5 6
7 8 9
10 11 12
13 14 15

14
common.c
Unescape View File

@ -47,8 +47,8 @@ void *buffer_grow(void *ptr, int numCount, int *sizeBufferTotal) {
return ptr;
}
bool checkParallelWorth(int numProcesses, int numCount) {
if (numProcesses > numCount / 2) {
bool check_parallel_worth(int numProcesses, int numCount, int limit) {
if (numProcesses > numCount / limit) {
//printf("*********************************************************************************\n");
printf("The number of processes if greater than number of parallel computations required!\n");
//printf("*********************************************************************************\n\n");
@ -57,7 +57,7 @@ bool checkParallelWorth(int numProcesses, int numCount) {
return true;
}
void spread_evenly(int numProcesses, int numCount, int **arrBlockIndices, int **arrBlockSizes) {
void spread_evenly(int numProcesses, int numCount, int multiplier, int **arrBlockIndices, int **arrBlockSizes) {
int numBlockIndex = 0;
int numRemainder = numCount % numProcesses;
@ -66,19 +66,21 @@ void spread_evenly(int numProcesses, int numCount, int **arrBlockIndices, int **
for (int i = 0; i < numProcesses; i++) {
int numBlockSize = numCount / numProcesses;
(*arrBlockSizes)[i] = numBlockSize;
if (numRemainder > 0) {
(*arrBlockSizes)[i] = ++numBlockSize;
numBlockSize++;
numRemainder--;
}
numBlockSize *= multiplier;
(*arrBlockSizes)[i] = numBlockSize;
int arrBlockData[NUM_CODES];
arrBlockData[CODE_SIZE] = numBlockSize;
arrBlockData[CODE_INDEX] = numBlockIndex;
printf("size[%d] = %d\tindex[%d] = %d\n", i, numBlockSize, i, numBlockIndex);
(*arrBlockIndices)[i] = numBlockIndex;
numBlockIndex += numBlockSize;
//printf("size[%d] = %d\tindex[%d] = %d\n", i, numBlockSize, i, numBlockIndex);
// Send every process starting index of 1D represented matrix and number of

4
common.h
Unescape View File

@ -24,8 +24,8 @@ void *my_calloc(size_t nitems, size_t size);
void *my_realloc(void *ptr, size_t size);
FILE *my_fopen(const char *filename, const char *mode);
void *buffer_grow(void *ptr, int sizeBufferUsed, int *sizeBufferTotal);
bool checkParallelWorth(int numProcesses, int sizeBufferUsed);
void spread_evenly(int numProcesses, int sizeBufferUsed, int **arrBlockIndices, int **arrBlockSizes);
bool check_parallel_worth(int numProcesses, int numCount, int limit);
void spread_evenly(int numProcesses, int sizeBufferUsed, int multiplier, int **arrBlockIndices, int **arrBlockSizes);
void *read_matrix_file(const char *filename, int *numCols, int *numCount);
int transpose_index(int index, int rows, int cols);

1
run
Unescape View File

@ -7,5 +7,6 @@ binFile="$binFolder/$1"
mkdir -p "$binFolder/"
#mpicc -Wno-unused-variable -Wno-unused-but-set-variable -Wall -O0 "$1.c" common.c -o "$binFile"
mpicc -Wall -O0 "$1.c" common.c -o "$binFile"
mpirun -v -np "$2" "$binFile"

Write Preview
Loading…
Cancel
Save