The document provides a code sample to count the frequency of a target number in a dataset using MPI for parallelization. The master process reads the input data, divides it evenly among the slave processes, and each slave counts the frequency in its portion. The slaves send their local counts to the master which sums them and prints the total count.

1. I have come code already but I cant quite get the output right if it helps here is my code:
#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
// frequency function
int freq(int *data, int size, int number)
{
// declare count variable
int count;
// iterate through data file
int i =0;
for (; i < size; i++)
{
// if data target number count it
if (data[i] == number)
{
count++;
}
}
return count;
}
int main(int argc, char **argv)
{
// declare data variables
int *data = NULL;
int *localData = NULL;
int localSize = 0, localCount = 0, totalCount = 0;
int number;
// declare MPI Variables
int rank; // processor rank
int size; // size of cluster
MPI_Status status; // MPI status object
// initalize the MPI environment
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
// when process rank 0 is active read data file and distribute data
if (rank == 0) {
// get number to count from user input
number = atoi(argv[argc-1]);
// open data file and read data
FILE *fp = fopen("data.dat", "r");

2. int totalSize;
fscanf(fp, "%d", &totalSize);
data = (int *) malloc(totalSize * sizeof(int));
int i =0;
for (; i < totalSize; i++)
{
fscanf(fp, "%d", &data[i]);
}
fclose(fp);
// compute block size for each process
int blockSize = totalSize / size;
// send block size and data to each process
for (i = 1; i < size; i++)
{
int start = i * blockSize;
MPI_Send(&blockSize, 1, MPI_INT, i, 0, MPI_COMM_WORLD);
MPI_Send(&data[start], blockSize, MPI_INT, i, 0, MPI_COMM_WORLD);
}
localSize = blockSize;
localData = data;
}
// when slave process is active receive data
else
{
MPI_Recv(&localSize, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &status);
localData = (int *) malloc(localSize * sizeof(int));
MPI_Recv(localData, localSize, MPI_INT, 0, 0, MPI_COMM_WORLD, &status);
}
// count frequency of number in the local memory of each processor
localCount = freq(localData, localSize, number);
// gather local counts from all processes to master process
MPI_Reduce(&localCount, &totalCount, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
// print frequency count for each process
printf("My id is %d and the frequency of %d is %dn", rank, number, localCount);
// when master process is active print total frequency count
if (rank == 0)
{
printf("##################################n");
printf("The total frequency of %d is %dn", number, totalCount);
// free allocated memory
free(data);
}

3. MPI_Finalize();
return 0;
}
input1.dat
19
79
24
14
5
64
48
46
75
58
19
80
89
4
52
5
10
97
21
18
55
2
86
18
60
9
70
74
7
67
100
50
83
54
64
97
55

4. 63
35
89
1
92
5
98
68
6
36
54
68
77
100
7
75
97
25
55
96
4
53
71
33
60
1
92
90
57
15
38
60
80
63
98
33
3
17
47
26
42
95

5. 12
52
18
3
49
89
26
61
18
86
36
46
44
65
53
83
35
43
21
42
28
64
18
10
60
68
80
19
46
94
80
23
26
48
21
92
88
24
96
38
82
50

6. 4
84
74
43
85
77
4
56
18
14
51
45
78
19
20
87
48
44
72
68
99
85
6
58
7
18
27
87
49
31
41
32
57
6
5
78
48
26
62
42
49
44

7. 87
69
38
74
42
31
43
61
20
15
66
51
27
94
61
42
19
83
97
3
85
48
90
36
20
93
100
90
41
50
54
33
44
85
89
21
56
56
55
3
60
52

8. 61
54
9
79
31
62
34
70
47
31
43
29
57
35
70
21
14
12
34
55
76
37
52
79
27
12
27
65
100
37
89
51
13
35
88
56
98
96
11
76
18
25

9. 47
80
4
44
78
14
32
92
61
55
43
65
53
40
58
16
63
28
87
86
43
12
88
96
20
23
64
66
49
88
4
98
73
45
73
87
53
4
23
56
46
10

10. 92
83
96
99
63
60
96
43
12
56
41
3
38
68
50
96
6
100
61
88
37
55
57
80
14
100
6
55
31
39
85
70
43
37
47
100
50
26
29
51
47
67

11. 100
56
42
55
66
33
4
100
99
63
20
27
54
68
28
18
56
79
63
29
3
13
76
11
26
10
97
81
47
64
44
7
13
45
34
84
64
15
82
57
38
89

12. 40
7
60
9
70
84
38
55
6
93
21
28
2
81
20
73
33
33
45
68
57
85
61
99
16
39
83
1
16
82
12
39
34
12
87
78
3
64
81
32
55
44

13. 79
87
95
39
70
78
40
12
25
4
91
62
41
58
94
80
2
95
94
30
44
36
57
21
15
41
53
24
75
35
24
40
60
51
57
11
88
35
29
71
42
53

14. 6
46
81
8
28
15
91
81
54
25
7
10
4
35
69
88
50
68
51
3
91
7
55
32
55
83
43
14
21
71
21
6
42
43
22
11
96
30
21
1
9
44

15. 87
9
44
43
27
52
10
37
40
79
48
100
42
14
94
81
43
2
15
39
61
80
29
45
90
29
86
79
91
70
73
58
38
2
19
37
56
73
46
55
78
12

16. 26
24
1
15
25
94
82
52
78
6
30
4
26
32
50
41
91
49
41
91
83
74
3
79
9
18
95
100
94
8
24
75
28
88
49
46
88
11
49
64
11
82

17. 25
88
78
83
65
2
86
6
71
19
11
14
4
63
68
12
22
12
31
53
14
36
64
79
83
53
63
43
92
33
28
95
37
73
40
17
36
6
100
87
14
65

18. 54
94
25
79
68
21
82
35
29
84
78
91
2
93
49
52
67
33
49
18
58
59
96
29
63
40
39
63
24
60
39
49
3
67
3
15
56
56
81
92
35
79

19. 80
22
8
99
20
89
36
75
89
1
18
30
80
23
63
57
56
47
55
37
8
45
64
42
66
57
9
60
83
72
48
8
2
82
74
25
32
85
40
55
88
54

20. 59
58
62
13
23
94
58
32
34
24
18
64
11
11
79
100
30
43
99
86
78
83
26
55
94
11
18
14
88
71
38
89
81
32
11
68
45
56
25
84
6
85

21. 66
36
73
57
45
51
82
13
22
89
80
14
51
35
41
81
85
52
90
34
73
71
98
38
87
2
33
12
90
35
73
50
2
3
4
97
41
11
93
78
96
40

22. 57
25
81
48
83
90
56
53
13
98
48
5
40
62
96
92
55
70
95
47
15
77
7
22
1
17
12
60
44
29
94
15
75
38
31
36
62
10
97
10
7
42

23. 45
52
65
7
48
97
29
92
8
29
87
44
91
67
63
36
44
95
76
60
50
29
88
87
11
56
99
78
96
13
49
87
87
31
67
18
43
17
85
49
70
5

24. 84
84
75
23
89
30
85
46
8
94
10
41
49
27
34
44
33
34
1
44
43
37
47
73
72
2
10
23
24
47
96
78
28
32
38
55
4
84
56
36
38
77

25. 34
95
94
94
29
94
66
18
83
78
12
31
34
16
75
69
53
76
58
66
40
69
36
47
3
75
81
35
92
6
40
52
61
90
74
3
86
55
29
83
52
73

26. 89
23
66
63
16
6
37
48
50
62
76
8
88
68
49
94
3
67
51
9
83
96
16
64
1
65
87
32
3
87
98
1
96
89
7
52
42
10
12
Write the parallel code to find the frequency of the number using MPI master/slave model. Master
gets the number to count from user using the command line input, reads the data from input file,
decomposes the input data, and assigns decomposed input data to each slave uniformly. Once all

27. slaves finish their counting, they should pass their results to the master and displays the count of
each slave. The master displays the total count of the number. Your MPI code should be flexible
enough to run with any number of processor(s) for any input size. You should decompose the
input data as uniform as possible. The output example with 5 processors is shown below. Submit
your report with source code. Your report should explain your code such as code structure,
parallelization method (i.e., data decomposition), data distribution, and collection (i.e.,
communication method) with your code. In the report, you should include the sample output of
your code. Your grade is based on your explanation in your report and completion of the code. 10
points for the code algorithm, logic, and explanation 10 points for the completion of job Example
output: It finds the total count of number 11 in the file using 4 slave processors. Each slave
processors display its count of 11. Master displays "number to find" and "total number of 11 " in
the file. Number to find is 11 My id is 1 and the frequency of 11 is 1 My id is 2 and the frequency of
11 is 3 My id is 3 and the frequency of 11 is 7 My id is 4 and the frequency of 11 is 2 The total
frequency of 11 is 13