Skip to content

Commit 84983ab

Browse files
elixir-codeelixir-code
committed
Add Exercise-3 codes and update README
- Add codes for mean filtering for various kernel sizes - Update README to include links to code, report
1 parent 77293dc commit 84983ab

File tree

10 files changed

+561
-9
lines changed

10 files changed

+561
-9
lines changed

‎OpenMP/Exercise-1/codes/matrixaddition.c

+1-1
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,7 @@ int main(){
3434
for(l=0; l<N_ITERATIONS; ++l)
3535
{
3636
start_time = omp_get_wtime();
37-
#pragma omp parallel for default(none) private(i,j) shared(A,B,C) num_threads(n_threads[k])
37+
#pragma omp parallel for default(none) private(i,j) shared(A,B,C) num_threads(n_threads[k]) collapse(2)
3838
for(i=0; i<M; ++i)
3939
for(j=0; j<N; ++j)
4040
C[i][j] = A[i][j]+B[i][j];

‎OpenMP/Exercise-3/codes/with-sections/meanfilter.c renamed to ‎OpenMP/Exercise-3/codes/with-sections/meanfilter3x3.c

+6-5
Original file line numberDiff line numberDiff line change
@@ -47,30 +47,31 @@ int main(void)
4747

4848
// perform mean filtering on the matrices
4949
#pragma omp parallel sections
50-
{
50+
{
5151
#pragma omp section
5252
{
5353
#pragma omp parallel for default(none) shared(redmeanfilteredmatrix, redmatrix) private(i, j) num_threads(NUM_THREADS[num_threads_index]) collapse(2)
5454
for(i=0; i<(M-2); ++i)
5555
for(j=0; j<(N-2); ++j)
56-
*(*(redmeanfilteredmatrix + i) + j) = ( *(*(redmatrix+i)+j) + *(*(redmatrix+i)+j+1) + *(*(redmatrix+i)+j+2) + *(*(redmatrix+i+1)+j) + *(*(redmatrix+i+1)+j+1) + *(*(redmatrix+i+1)+j+2) + *(*(redmatrix+i+2)+j) + *(*(redmatrix+i+2)+j+1) + *(*(redmatrix+i+2)+j+2) )/9;
56+
*(*(redmeanfilteredmatrix + i) + j) = 0.111111 * *(*(redmatrix+i)+j) + 0.111111 * *(*(redmatrix+i)+j+1) + 0.111111 * *(*(redmatrix+i)+j+2) + 0.111111 * *(*(redmatrix+i+1)+j) + 0.111111 * *(*(redmatrix+i+1)+j+1) + 0.111111 * *(*(redmatrix+i+1)+j+2) + 0.111111 * *(*(redmatrix+i+2)+j) + 0.111111 * *(*(redmatrix+i+2)+j+1) + 0.111111 * *(*(redmatrix+i+2)+j+2);
5757
}
5858

5959
#pragma omp section
6060
{
6161
#pragma omp parallel for default(none) shared(greenmeanfilteredmatrix, greenmatrix) private(i, j) num_threads(NUM_THREADS[num_threads_index]) collapse(2)
6262
for(i=0; i<(M-2); ++i)
6363
for(j=0; j<(N-2); ++j)
64-
*(*(greenmeanfilteredmatrix + i) + j) = ( *(*(greenmatrix+i)+j) + *(*(greenmatrix+i)+j+1) + *(*(greenmatrix+i)+j+2) + *(*(greenmatrix+i+1)+j) + *(*(greenmatrix+i+1)+j+1) + *(*(greenmatrix+i+1)+j+2) + *(*(greenmatrix+i+2)+j) + *(*(greenmatrix+i+2)+j+1) + *(*(greenmatrix+i+2)+j+2) )/9;
64+
*(*(greenmeanfilteredmatrix + i) + j) = 0.111111 * *(*(greenmatrix+i)+j) + 0.111111 * *(*(greenmatrix+i)+j+1) + 0.111111 * *(*(greenmatrix+i)+j+2) + 0.111111 * *(*(greenmatrix+i+1)+j) + 0.111111 * *(*(greenmatrix+i+1)+j+1) + 0.111111 * *(*(greenmatrix+i+1)+j+2) + 0.111111 * *(*(greenmatrix+i+2)+j) + 0.111111 * *(*(greenmatrix+i+2)+j+1) + 0.111111 * *(*(greenmatrix+i+2)+j+2);
65+
6566
}
6667

6768
#pragma omp section
6869
{
6970
#pragma omp parallel for default(none) shared(bluemeanfilteredmatrix, bluematrix) private(i, j) num_threads(NUM_THREADS[num_threads_index]) collapse(2)
7071
for(i=0; i<(M-2); ++i)
7172
for(j=0; j<(N-2); ++j)
72-
*(*(bluemeanfilteredmatrix + i) + j) = ( *(*(bluematrix+i)+j) + *(*(bluematrix+i)+j+1) + *(*(bluematrix+i)+j+2) + *(*(bluematrix+i+1)+j) + *(*(bluematrix+i+1)+j+1) + *(*(bluematrix+i+1)+j+2) + *(*(bluematrix+i+2)+j) + *(*(bluematrix+i+2)+j+1) + *(*(bluematrix+i+2)+j+2) )/9;
73-
}
73+
*(*(bluemeanfilteredmatrix + i) + j) = 0.111111 * *(*(bluematrix+i)+j) + 0.111111 * *(*(bluematrix+i)+j+1) + 0.111111 * *(*(bluematrix+i)+j+2) + 0.111111 * *(*(bluematrix+i+1)+j) + 0.111111 * *(*(bluematrix+i+1)+j+1) + 0.111111 * *(*(bluematrix+i+1)+j+2) + 0.111111 * *(*(bluematrix+i+2)+j) + 0.111111 * *(*(bluematrix+i+2)+j+1) + 0.111111 * *(*(bluematrix+i+2)+j+2);
74+
}
7475
}
7576

7677

‎OpenMP/Exercise-3/codes/with-sections/meanfilter5x5.c

+118
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,118 @@
1+
#include <stdio.h>
2+
#include <stdlib.h>
3+
#include <string.h>
4+
5+
#include <omp.h>
6+
7+
// define the dimensions of the matrix
8+
#define M 384
9+
#define N 512
10+
11+
/* Read the numbers in the file as an m x n matrix
12+
Note: If the file has fewer elements than in matrix, the rest is filled with zeroes. */
13+
int **readMatrix(const char *filename, int m, int n);
14+
15+
const int const NUM_THREADS[] = {1, 2, 4, 6, 8, 12, 16, 20, 24, 28, 32};
16+
17+
int main(void)
18+
{
19+
int i, j;
20+
21+
// read random image matrices from file 'red.txt', 'green.txt', 'blue.txt'
22+
int **redmatrix = readMatrix("../../data/red.txt", M, N);
23+
int **greenmatrix = readMatrix("../../data/green.txt", M, N);
24+
int **bluematrix = readMatrix("../../data/blue.txt", M, N);
25+
26+
// create matrices to store mean filtering result for red, green, blue matrices
27+
int **redmeanfilteredmatrix, **greenmeanfilteredmatrix, **bluemeanfilteredmatrix;
28+
29+
redmeanfilteredmatrix = (int **)malloc(sizeof(int *)*(M-4));
30+
greenmeanfilteredmatrix = (int **)malloc(sizeof(int *)*(M-4));
31+
bluemeanfilteredmatrix = (int **)malloc(sizeof(int *)*(M-4));
32+
33+
for(i=0; i<(M-4); ++i)
34+
{
35+
*(redmeanfilteredmatrix+i) = (int *)malloc(sizeof(int)*(N-4));
36+
*(greenmeanfilteredmatrix+i) = (int *)malloc(sizeof(int)*(N-4));
37+
*(bluemeanfilteredmatrix+i) = (int *)malloc(sizeof(int)*(N-4));
38+
}
39+
40+
41+
int num_threads_index;
42+
double start_time, end_time;
43+
44+
for(num_threads_index=0; num_threads_index<sizeof(NUM_THREADS)/sizeof(int); ++num_threads_index)
45+
{
46+
start_time = omp_get_wtime();
47+
48+
// perform mean filtering on the matrices
49+
#pragma omp parallel sections
50+
{
51+
#pragma omp section
52+
{
53+
#pragma omp parallel for default(none) shared(redmeanfilteredmatrix, redmatrix) private(i, j) num_threads(NUM_THREADS[num_threads_index]) collapse(2)
54+
for(i=0; i<(M-4); ++i)
55+
for(j=0; j<(N-4); ++j)
56+
*(*(redmeanfilteredmatrix + i) + j) = 0.04 * *(*(redmatrix+i)+j) + 0.04 * *(*(redmatrix+i)+j+1) + 0.04 * *(*(redmatrix+i)+j+2) + 0.04 * *(*(redmatrix+i)+j+3) + 0.04 * *(*(redmatrix+i)+j+4) + 0.04 * *(*(redmatrix+i+1)+j) + 0.04 * *(*(redmatrix+i+1)+j+1) + 0.04 * *(*(redmatrix+i+1)+j+2) + 0.04 * *(*(redmatrix+i+1)+j+3) + 0.04 * *(*(redmatrix+i+1)+j+4) + 0.04 * *(*(redmatrix+i+2)+j) + 0.04 * *(*(redmatrix+i+2)+j+1) + 0.04 * *(*(redmatrix+i+2)+j+2) + 0.04 * *(*(redmatrix+i+2)+j+3) + 0.04 * *(*(redmatrix+i+2)+j+4) + 0.04 * *(*(redmatrix+i+3)+j) + 0.04 * *(*(redmatrix+i+3)+j+1) + 0.04 * *(*(redmatrix+i+3)+j+2) + 0.04 * *(*(redmatrix+i+3)+j+3) + 0.04 * *(*(redmatrix+i+3)+j+4) + 0.04 * *(*(redmatrix+i+4)+j) + 0.04 * *(*(redmatrix+i+4)+j+1) + 0.04 * *(*(redmatrix+i+4)+j+2) + 0.04 * *(*(redmatrix+i+4)+j+3) + 0.04 * *(*(redmatrix+i+4)+j+4);
57+
}
58+
59+
#pragma omp section
60+
{
61+
#pragma omp parallel for default(none) shared(greenmeanfilteredmatrix, greenmatrix) private(i, j) num_threads(NUM_THREADS[num_threads_index]) collapse(2)
62+
for(i=0; i<(M-4); ++i)
63+
for(j=0; j<(N-4); ++j)
64+
*(*(greenmeanfilteredmatrix + i) + j) = 0.04 * *(*(greenmatrix+i)+j) + 0.04 * *(*(greenmatrix+i)+j+1) + 0.04 * *(*(greenmatrix+i)+j+2) + 0.04 * *(*(greenmatrix+i)+j+3) + 0.04 * *(*(greenmatrix+i)+j+4) + 0.04 * *(*(greenmatrix+i+1)+j) + 0.04 * *(*(greenmatrix+i+1)+j+1) + 0.04 * *(*(greenmatrix+i+1)+j+2) + 0.04 * *(*(greenmatrix+i+1)+j+3) + 0.04 * *(*(greenmatrix+i+1)+j+4) + 0.04 * *(*(greenmatrix+i+2)+j) + 0.04 * *(*(greenmatrix+i+2)+j+1) + 0.04 * *(*(greenmatrix+i+2)+j+2) + 0.04 * *(*(greenmatrix+i+2)+j+3) + 0.04 * *(*(greenmatrix+i+2)+j+4) + 0.04 * *(*(greenmatrix+i+3)+j) + 0.04 * *(*(greenmatrix+i+3)+j+1) + 0.04 * *(*(greenmatrix+i+3)+j+2) + 0.04 * *(*(greenmatrix+i+3)+j+3) + 0.04 * *(*(greenmatrix+i+3)+j+4) + 0.04 * *(*(greenmatrix+i+4)+j) + 0.04 * *(*(greenmatrix+i+4)+j+1) + 0.04 * *(*(greenmatrix+i+4)+j+2) + 0.04 * *(*(greenmatrix+i+4)+j+3) + 0.04 * *(*(greenmatrix+i+4)+j+4);
65+
}
66+
67+
#pragma omp section
68+
{
69+
#pragma omp parallel for default(none) shared(bluemeanfilteredmatrix, bluematrix) private(i, j) num_threads(NUM_THREADS[num_threads_index]) collapse(2)
70+
for(i=0; i<(M-4); ++i)
71+
for(j=0; j<(N-4); ++j)
72+
*(*(bluemeanfilteredmatrix + i) + j) = 0.04 * *(*(bluematrix+i)+j) + 0.04 * *(*(bluematrix+i)+j+1) + 0.04 * *(*(bluematrix+i)+j+2) + 0.04 * *(*(bluematrix+i)+j+3) + 0.04 * *(*(bluematrix+i)+j+4) + 0.04 * *(*(bluematrix+i+1)+j) + 0.04 * *(*(bluematrix+i+1)+j+1) + 0.04 * *(*(bluematrix+i+1)+j+2) + 0.04 * *(*(bluematrix+i+1)+j+3) + 0.04 * *(*(bluematrix+i+1)+j+4) + 0.04 * *(*(bluematrix+i+2)+j) + 0.04 * *(*(bluematrix+i+2)+j+1) + 0.04 * *(*(bluematrix+i+2)+j+2) + 0.04 * *(*(bluematrix+i+2)+j+3) + 0.04 * *(*(bluematrix+i+2)+j+4) + 0.04 * *(*(bluematrix+i+3)+j) + 0.04 * *(*(bluematrix+i+3)+j+1) + 0.04 * *(*(bluematrix+i+3)+j+2) + 0.04 * *(*(bluematrix+i+3)+j+3) + 0.04 * *(*(bluematrix+i+3)+j+4) + 0.04 * *(*(bluematrix+i+4)+j) + 0.04 * *(*(bluematrix+i+4)+j+1) + 0.04 * *(*(bluematrix+i+4)+j+2) + 0.04 * *(*(bluematrix+i+4)+j+3) + 0.04 * *(*(bluematrix+i+4)+j+4);
73+
}
74+
}
75+
76+
77+
end_time = omp_get_wtime();
78+
printf("No. of Threads = %d, time taken = %lf\n", NUM_THREADS[num_threads_index], (end_time - start_time));
79+
}
80+
81+
return 0;
82+
}
83+
84+
int **readMatrix(const char *filename, int m, int n)
85+
{
86+
int **matrix;
87+
88+
// open the matrix file for reading
89+
FILE *fptr = fopen(filename, "r");
90+
91+
if(fptr == NULL)
92+
{
93+
matrix = NULL;
94+
95+
char *errormsg = (char *)malloc( sizeof(char)*(30 + strlen(filename) + 1) );
96+
sprintf(errormsg, "Failed to read and parse file %s", filename);
97+
perror(errormsg);
98+
}
99+
100+
else
101+
{
102+
// create and read the matrix
103+
matrix = (int **)malloc(sizeof(int *)*m);
104+
105+
int i, j;
106+
for(i=0; i<m; ++i)
107+
{
108+
*(matrix + i) = (int *)malloc(sizeof(int)*n);
109+
for(j=0; j<n; ++j)
110+
fscanf(fptr, "%d", *(matrix+i)+j);
111+
}
112+
113+
fclose(fptr);
114+
}
115+
116+
return matrix;
117+
118+
}

‎OpenMP/Exercise-3/codes/with-sections/meanfilter7x7.c

+117
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,117 @@
1+
#include <stdio.h>
2+
#include <stdlib.h>
3+
#include <string.h>
4+
5+
#include <omp.h>
6+
7+
// define the dimensions of the matrix
8+
#define M 384
9+
#define N 512
10+
11+
/* Read the numbers in the file as an m x n matrix
12+
Note: If the file has fewer elements than in matrix, the rest is filled with zeroes. */
13+
int **readMatrix(const char *filename, int m, int n);
14+
15+
const int const NUM_THREADS[] = {1, 2, 4, 6, 8, 12, 16, 20, 24, 28, 32};
16+
17+
int main(void)
18+
{
19+
int i, j;
20+
21+
// read random image matrices from file 'red.txt', 'green.txt', 'blue.txt'
22+
int **redmatrix = readMatrix("../../data/red.txt", M, N);
23+
int **greenmatrix = readMatrix("../../data/green.txt", M, N);
24+
int **bluematrix = readMatrix("../../data/blue.txt", M, N);
25+
26+
// create matrices to store mean filtering result for red, green, blue matrices
27+
int **redmeanfilteredmatrix, **greenmeanfilteredmatrix, **bluemeanfilteredmatrix;
28+
29+
redmeanfilteredmatrix = (int **)malloc(sizeof(int *)*(M-6));
30+
greenmeanfilteredmatrix = (int **)malloc(sizeof(int *)*(M-6));
31+
bluemeanfilteredmatrix = (int **)malloc(sizeof(int *)*(M-6));
32+
33+
for(i=0; i<(M-6); ++i)
34+
{
35+
*(redmeanfilteredmatrix+i) = (int *)malloc(sizeof(int)*(N-6));
36+
*(greenmeanfilteredmatrix+i) = (int *)malloc(sizeof(int)*(N-6));
37+
*(bluemeanfilteredmatrix+i) = (int *)malloc(sizeof(int)*(N-6));
38+
}
39+
40+
41+
int num_threads_index;
42+
double start_time, end_time;
43+
44+
for(num_threads_index=0; num_threads_index<sizeof(NUM_THREADS)/sizeof(int); ++num_threads_index)
45+
{
46+
start_time = omp_get_wtime();
47+
48+
// perform mean filtering on the matrices
49+
#pragma omp parallel sections
50+
{
51+
#pragma omp section
52+
{
53+
#pragma omp parallel for default(none) shared(redmeanfilteredmatrix, redmatrix) private(i, j) num_threads(NUM_THREADS[num_threads_index]) collapse(2)
54+
for(i=0; i<(M-6); ++i)
55+
for(j=0; j<(N-6); ++j)
56+
*(*(redmeanfilteredmatrix + i) + j) = 0.020408 * *(*(redmatrix+i)+j) + 0.020408 * *(*(redmatrix+i)+j+1) + 0.020408 * *(*(redmatrix+i)+j+2) + 0.020408 * *(*(redmatrix+i)+j+3) + 0.020408 * *(*(redmatrix+i)+j+4) + 0.020408 * *(*(redmatrix+i)+j+5) + 0.020408 * *(*(redmatrix+i)+j+6) + 0.020408 * *(*(redmatrix+i+1)+j) + 0.020408 * *(*(redmatrix+i+1)+j+1) + 0.020408 * *(*(redmatrix+i+1)+j+2) + 0.020408 * *(*(redmatrix+i+1)+j+3) + 0.020408 * *(*(redmatrix+i+1)+j+4) + 0.020408 * *(*(redmatrix+i+1)+j+5) + 0.020408 * *(*(redmatrix+i+1)+j+6) + 0.020408 * *(*(redmatrix+i+2)+j) + 0.020408 * *(*(redmatrix+i+2)+j+1) + 0.020408 * *(*(redmatrix+i+2)+j+2) + 0.020408 * *(*(redmatrix+i+2)+j+3) + 0.020408 * *(*(redmatrix+i+2)+j+4) + 0.020408 * *(*(redmatrix+i+2)+j+5) + 0.020408 * *(*(redmatrix+i+2)+j+6) + 0.020408 * *(*(redmatrix+i+3)+j) + 0.020408 * *(*(redmatrix+i+3)+j+1) + 0.020408 * *(*(redmatrix+i+3)+j+2) + 0.020408 * *(*(redmatrix+i+3)+j+3) + 0.020408 * *(*(redmatrix+i+3)+j+4) + 0.020408 * *(*(redmatrix+i+3)+j+5) + 0.020408 * *(*(redmatrix+i+3)+j+6) + 0.020408 * *(*(redmatrix+i+4)+j) + 0.020408 * *(*(redmatrix+i+4)+j+1) + 0.020408 * *(*(redmatrix+i+4)+j+2) + 0.020408 * *(*(redmatrix+i+4)+j+3) + 0.020408 * *(*(redmatrix+i+4)+j+4) + 0.020408 * *(*(redmatrix+i+4)+j+5) + 0.020408 * *(*(redmatrix+i+4)+j+6) + 0.020408 * *(*(redmatrix+i+5)+j) + 0.020408 * *(*(redmatrix+i+5)+j+1) + 0.020408 * *(*(redmatrix+i+5)+j+2) + 0.020408 * *(*(redmatrix+i+5)+j+3) + 0.020408 * *(*(redmatrix+i+5)+j+4) + 0.020408 * *(*(redmatrix+i+5)+j+5) + 0.020408 * *(*(redmatrix+i+5)+j+6) + 0.020408 * *(*(redmatrix+i+6)+j) + 0.020408 * *(*(redmatrix+i+6)+j+1) + 0.020408 * *(*(redmatrix+i+6)+j+2) + 0.020408 * *(*(redmatrix+i+6)+j+3) + 0.020408 * *(*(redmatrix+i+6)+j+4) + 0.020408 * *(*(redmatrix+i+6)+j+5) + 0.020408 * *(*(redmatrix+i+6)+j+6);
57+
}
58+
59+
#pragma omp section
60+
{
61+
#pragma omp parallel for default(none) shared(greenmeanfilteredmatrix, greenmatrix) private(i, j) num_threads(NUM_THREADS[num_threads_index]) collapse(2)
62+
for(i=0; i<(M-6); ++i)
63+
for(j=0; j<(N-6); ++j)
64+
*(*(greenmeanfilteredmatrix + i) + j) = 0.020408 * *(*(greenmatrix+i)+j) + 0.020408 * *(*(greenmatrix+i)+j+1) + 0.020408 * *(*(greenmatrix+i)+j+2) + 0.020408 * *(*(greenmatrix+i)+j+3) + 0.020408 * *(*(greenmatrix+i)+j+4) + 0.020408 * *(*(greenmatrix+i)+j+5) + 0.020408 * *(*(greenmatrix+i)+j+6) + 0.020408 * *(*(greenmatrix+i+1)+j) + 0.020408 * *(*(greenmatrix+i+1)+j+1) + 0.020408 * *(*(greenmatrix+i+1)+j+2) + 0.020408 * *(*(greenmatrix+i+1)+j+3) + 0.020408 * *(*(greenmatrix+i+1)+j+4) + 0.020408 * *(*(greenmatrix+i+1)+j+5) + 0.020408 * *(*(greenmatrix+i+1)+j+6) + 0.020408 * *(*(greenmatrix+i+2)+j) + 0.020408 * *(*(greenmatrix+i+2)+j+1) + 0.020408 * *(*(greenmatrix+i+2)+j+2) + 0.020408 * *(*(greenmatrix+i+2)+j+3) + 0.020408 * *(*(greenmatrix+i+2)+j+4) + 0.020408 * *(*(greenmatrix+i+2)+j+5) + 0.020408 * *(*(greenmatrix+i+2)+j+6) + 0.020408 * *(*(greenmatrix+i+3)+j) + 0.020408 * *(*(greenmatrix+i+3)+j+1) + 0.020408 * *(*(greenmatrix+i+3)+j+2) + 0.020408 * *(*(greenmatrix+i+3)+j+3) + 0.020408 * *(*(greenmatrix+i+3)+j+4) + 0.020408 * *(*(greenmatrix+i+3)+j+5) + 0.020408 * *(*(greenmatrix+i+3)+j+6) + 0.020408 * *(*(greenmatrix+i+4)+j) + 0.020408 * *(*(greenmatrix+i+4)+j+1) + 0.020408 * *(*(greenmatrix+i+4)+j+2) + 0.020408 * *(*(greenmatrix+i+4)+j+3) + 0.020408 * *(*(greenmatrix+i+4)+j+4) + 0.020408 * *(*(greenmatrix+i+4)+j+5) + 0.020408 * *(*(greenmatrix+i+4)+j+6) + 0.020408 * *(*(greenmatrix+i+5)+j) + 0.020408 * *(*(greenmatrix+i+5)+j+1) + 0.020408 * *(*(greenmatrix+i+5)+j+2) + 0.020408 * *(*(greenmatrix+i+5)+j+3) + 0.020408 * *(*(greenmatrix+i+5)+j+4) + 0.020408 * *(*(greenmatrix+i+5)+j+5) + 0.020408 * *(*(greenmatrix+i+5)+j+6) + 0.020408 * *(*(greenmatrix+i+6)+j) + 0.020408 * *(*(greenmatrix+i+6)+j+1) + 0.020408 * *(*(greenmatrix+i+6)+j+2) + 0.020408 * *(*(greenmatrix+i+6)+j+3) + 0.020408 * *(*(greenmatrix+i+6)+j+4) + 0.020408 * *(*(greenmatrix+i+6)+j+5) + 0.020408 * *(*(greenmatrix+i+6)+j+6);
65+
}
66+
67+
#pragma omp section
68+
{
69+
#pragma omp parallel for default(none) shared(bluemeanfilteredmatrix, bluematrix) private(i, j) num_threads(NUM_THREADS[num_threads_index]) collapse(2)
70+
for(i=0; i<(M-6); ++i)
71+
for(j=0; j<(N-6); ++j)
72+
*(*(bluemeanfilteredmatrix + i) + j) = 0.020408 * *(*(bluematrix+i)+j) + 0.020408 * *(*(bluematrix+i)+j+1) + 0.020408 * *(*(bluematrix+i)+j+2) + 0.020408 * *(*(bluematrix+i)+j+3) + 0.020408 * *(*(bluematrix+i)+j+4) + 0.020408 * *(*(bluematrix+i)+j+5) + 0.020408 * *(*(bluematrix+i)+j+6) + 0.020408 * *(*(bluematrix+i+1)+j) + 0.020408 * *(*(bluematrix+i+1)+j+1) + 0.020408 * *(*(bluematrix+i+1)+j+2) + 0.020408 * *(*(bluematrix+i+1)+j+3) + 0.020408 * *(*(bluematrix+i+1)+j+4) + 0.020408 * *(*(bluematrix+i+1)+j+5) + 0.020408 * *(*(bluematrix+i+1)+j+6) + 0.020408 * *(*(bluematrix+i+2)+j) + 0.020408 * *(*(bluematrix+i+2)+j+1) + 0.020408 * *(*(bluematrix+i+2)+j+2) + 0.020408 * *(*(bluematrix+i+2)+j+3) + 0.020408 * *(*(bluematrix+i+2)+j+4) + 0.020408 * *(*(bluematrix+i+2)+j+5) + 0.020408 * *(*(bluematrix+i+2)+j+6) + 0.020408 * *(*(bluematrix+i+3)+j) + 0.020408 * *(*(bluematrix+i+3)+j+1) + 0.020408 * *(*(bluematrix+i+3)+j+2) + 0.020408 * *(*(bluematrix+i+3)+j+3) + 0.020408 * *(*(bluematrix+i+3)+j+4) + 0.020408 * *(*(bluematrix+i+3)+j+5) + 0.020408 * *(*(bluematrix+i+3)+j+6) + 0.020408 * *(*(bluematrix+i+4)+j) + 0.020408 * *(*(bluematrix+i+4)+j+1) + 0.020408 * *(*(bluematrix+i+4)+j+2) + 0.020408 * *(*(bluematrix+i+4)+j+3) + 0.020408 * *(*(bluematrix+i+4)+j+4) + 0.020408 * *(*(bluematrix+i+4)+j+5) + 0.020408 * *(*(bluematrix+i+4)+j+6) + 0.020408 * *(*(bluematrix+i+5)+j) + 0.020408 * *(*(bluematrix+i+5)+j+1) + 0.020408 * *(*(bluematrix+i+5)+j+2) + 0.020408 * *(*(bluematrix+i+5)+j+3) + 0.020408 * *(*(bluematrix+i+5)+j+4) + 0.020408 * *(*(bluematrix+i+5)+j+5) + 0.020408 * *(*(bluematrix+i+5)+j+6) + 0.020408 * *(*(bluematrix+i+6)+j) + 0.020408 * *(*(bluematrix+i+6)+j+1) + 0.020408 * *(*(bluematrix+i+6)+j+2) + 0.020408 * *(*(bluematrix+i+6)+j+3) + 0.020408 * *(*(bluematrix+i+6)+j+4) + 0.020408 * *(*(bluematrix+i+6)+j+5) + 0.020408 * *(*(bluematrix+i+6)+j+6);
73+
}
74+
}
75+
76+
end_time = omp_get_wtime();
77+
printf("No. of Threads = %d, time taken = %lf\n", NUM_THREADS[num_threads_index], (end_time - start_time));
78+
}
79+
80+
return 0;
81+
}
82+
83+
int **readMatrix(const char *filename, int m, int n)
84+
{
85+
int **matrix;
86+
87+
// open the matrix file for reading
88+
FILE *fptr = fopen(filename, "r");
89+
90+
if(fptr == NULL)
91+
{
92+
matrix = NULL;
93+
94+
char *errormsg = (char *)malloc( sizeof(char)*(30 + strlen(filename) + 1) );
95+
sprintf(errormsg, "Failed to read and parse file %s", filename);
96+
perror(errormsg);
97+
}
98+
99+
else
100+
{
101+
// create and read the matrix
102+
matrix = (int **)malloc(sizeof(int *)*m);
103+
104+
int i, j;
105+
for(i=0; i<m; ++i)
106+
{
107+
*(matrix + i) = (int *)malloc(sizeof(int)*n);
108+
for(j=0; j<n; ++j)
109+
fscanf(fptr, "%d", *(matrix+i)+j);
110+
}
111+
112+
fclose(fptr);
113+
}
114+
115+
return matrix;
116+
117+
}

0 commit comments

Comments
 (0)