From f24b3cff2f00158219a4146451aa2591b28e5ef2 Mon Sep 17 00:00:00 2001
From: mfikrin <muhammad.fikrin1729@gmail.com>
Date: Sun, 6 Mar 2022 16:07:23 +0700
Subject: [PATCH] feat : data type matrix
---
src/change | Bin 0 -> 16752 bytes
src/change.c | 9 +
src/par | Bin 0 -> 21944 bytes
src/parallel.c | 466 +++++++++++++++++++++++++++++++++++++++++++++++++
src/person.c | 150 ++++++++++++++++
src/serial | Bin 0 -> 21480 bytes
src/serial.c | 17 +-
7 files changed, 641 insertions(+), 1 deletion(-)
create mode 100644 src/change
create mode 100644 src/change.c
create mode 100644 src/par
create mode 100644 src/parallel.c
create mode 100644 src/person.c
create mode 100644 src/serial
diff --git a/src/change b/src/change
new file mode 100644
index 0000000000000000000000000000000000000000..d78540c6dc330c412b7850b2a1bc976244ee4fc3
GIT binary patch
literal 16752
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
V*C@p~d3pP%+YOB^HUpa|{sqg6fV%(y
literal 0
HcmV?d00001
diff --git a/src/change.c b/src/change.c
new file mode 100644
index 0000000..d77c2d9
--- /dev/null
+++ b/src/change.c
@@ -0,0 +1,9 @@
+#include <stdio.h>
+int main() {
+ const int x = 10; //define constant int
+ int *ptr;
+ printf("x = %d\n", x);
+ ptr = &x; //ptr points the variable x
+ *ptr = 15; //Updating through pointer
+ printf("x = %d\n", x);
+}
\ No newline at end of file
diff --git a/src/par b/src/par
new file mode 100644
index 0000000000000000000000000000000000000000..ffe23201b382ad85b854f2b410f170a9d593b6e4
GIT binary patch
literal 21944
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
NR!PkAD0q_MzX0J|fC~Ts
literal 0
HcmV?d00001
diff --git a/src/parallel.c b/src/parallel.c
new file mode 100644
index 0000000..4ae1b64
--- /dev/null
+++ b/src/parallel.c
@@ -0,0 +1,466 @@
+// serial.c
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <mpi.h>
+
+#define NMAX 100
+#define DATAMAX 1000
+#define DATAMIN -1000
+
+/*
+ * Struct Matrix
+ *
+ * Matrix representation consists of matrix data
+ * and effective dimensions
+ * */
+typedef struct Matrix {
+ int mat[NMAX][NMAX]; // Matrix cells
+ int row_eff; // Matrix effective row
+ int col_eff; // Matrix effective column
+} Matrix;
+
+
+/*
+ * Procedure init_matrix
+ *
+ * Initializing newly allocated matrix
+ * Setting all data to 0 and effective dimensions according
+ * to nrow and ncol
+ * */
+void init_matrix(Matrix *m, int nrow, int ncol) {
+ m->row_eff = nrow;
+ m->col_eff = ncol;
+
+ for (int i = 0; i < m->row_eff; i++) {
+ for (int j = 0; j < m->col_eff; j++) {
+ m->mat[i][j] = 0;
+ }
+ }
+}
+
+
+/*
+ * Function input_matrix
+ *
+ * Returns a matrix with values from stdin input
+ * */
+Matrix input_matrix(int nrow, int ncol) {
+ Matrix input;
+ init_matrix(&input, nrow, ncol);
+
+ for (int i = 0; i < nrow; i++) {
+ for (int j = 0; j < ncol; j++) {
+ scanf("%d", &input.mat[i][j]);
+ }
+ }
+
+ return input;
+}
+
+
+/*
+ * Procedure print_matrix
+ *
+ * Print matrix data
+ * */
+void print_matrix(Matrix *m) {
+ for (int i = 0; i < m->row_eff; i++) {
+ for (int j = 0; j < m->col_eff; j++) {
+ printf("%d ", m->mat[i][j]);
+ }
+ printf("\n");
+ }
+}
+
+
+/*
+ * Function get_matrix_datarange
+ *
+ * Returns the range between maximum and minimum
+ * element of a matrix
+ * */
+int get_matrix_datarange(Matrix *m) {
+ int max = DATAMIN;
+ int min = DATAMAX;
+ for (int i = 0; i < m->row_eff; i++) {
+ for (int j = 0; j < m->col_eff; j++) {
+ int el = m->mat[i][j];
+ if (el > max) max = el;
+ if (el < min) min = el;
+ }
+ }
+
+ return max - min;
+}
+
+
+/*
+ * Function supression_op
+ *
+ * Returns the sum of intermediate value of special multiplication
+ * operation where kernel[0][0] corresponds to target[row][col]
+ * */
+int supression_op(Matrix *kernel, Matrix *target, int row, int col) {
+ int intermediate_sum = 0;
+ for (int i = 0; i < kernel->row_eff; i++) {
+ for (int j = 0; j < kernel->col_eff; j++) {
+ intermediate_sum += kernel->mat[i][j] * target->mat[row + i][col + j];
+ }
+ }
+
+ return intermediate_sum;
+}
+
+
+/*
+ * Function convolution
+ *
+ * Return the output matrix of convolution operation
+ * between kernel and target
+ * */
+Matrix convolution(Matrix *kernel, Matrix *target) {
+ Matrix out;
+ int out_row_eff = target->row_eff - kernel->row_eff + 1;
+ int out_col_eff = target->col_eff - kernel->col_eff + 1;
+
+ // printf("kernel row %d",kernel->row_eff);
+ // printf("kernel col %d",kernel->col_eff);
+
+ // printf("out_row_eff %d %d",out_row_eff,out_col_eff);
+
+ init_matrix(&out, out_row_eff, out_col_eff);
+
+ for (int i = 0; i < out.row_eff; i++) {
+ for (int j = 0; j < out.col_eff; j++) {
+ out.mat[i][j] = supression_op(kernel, target, i, j);
+ }
+ }
+
+ return out;
+}
+
+
+/*
+ * Procedure merge_array
+ *
+ * Merges two subarrays of n with n[left..mid] and n[mid+1..right]
+ * to n itself, with n now ordered ascendingly
+ * */
+void merge_array(int *n, int left, int mid, int right) {
+ int n_left = mid - left + 1;
+ int n_right = right - mid;
+ int iter_left = 0, iter_right = 0, iter_merged = left;
+ int arr_left[n_left], arr_right[n_right];
+
+ for (int i = 0; i < n_left; i++) {
+ arr_left[i] = n[i + left];
+ }
+
+ for (int i = 0; i < n_right; i++) {
+ arr_right[i] = n[i + mid + 1];
+ }
+
+ while (iter_left < n_left && iter_right < n_right) {
+ if (arr_left[iter_left] <= arr_right[iter_right]) {
+ n[iter_merged] = arr_left[iter_left++];
+ } else {
+ n[iter_merged] = arr_right[iter_right++];
+ }
+ iter_merged++;
+ }
+
+ while (iter_left < n_left) {
+ n[iter_merged++] = arr_left[iter_left++];
+ }
+ while (iter_right < n_right) {
+ n[iter_merged++] = arr_right[iter_right++];
+ }
+}
+
+
+/*
+ * Procedure merge_sort
+ *
+ * Sorts array n with merge sort algorithm
+ * */
+void merge_sort(int *n, int left, int right) {
+ if (left < right) {
+ int mid = left + (right - left) / 2;
+
+ merge_sort(n, left, mid);
+ merge_sort(n, mid + 1, right);
+
+ merge_array(n, left, mid, right);
+ }
+}
+
+
+/*
+ * Procedure print_array
+ *
+ * Prints all elements of array n of size to stdout
+ * */
+void print_array(int *n, int size) {
+ for (int i = 0; i < size; i++ ) printf("%d ", n[i]);
+ printf("\n");
+}
+
+
+/*
+ * Function get_median
+ *
+ * Returns median of array n of length
+ * */
+int get_median(int *n, int length) {
+ int mid = length / 2;
+ if (length & 1) return n[mid];
+
+ return (n[mid - 1] + n[mid]) / 2;
+}
+
+
+/*
+ * Function get_floored_mean
+ *
+ * Returns floored mean from an array of integers
+ * */
+long get_floored_mean(int *n, int length) {
+ long sum = 0;
+ for (int i = 0; i < length; i++) {
+ sum += n[i];
+ }
+
+ return sum / length;
+}
+
+
+void distribute(void* data, int count, MPI_Datatype datatype, int root,
+ MPI_Comm communicator) {
+ int world_rank;
+ MPI_Comm_rank(communicator, &world_rank);
+ int world_size;
+ MPI_Comm_size(communicator, &world_size);
+
+ // Procecss 0 --> Kirim matriks inputan 1,2,3 ke prcess 1,2,3
+ // process 1,2,3 -> receive
+ // prcess 0 --> kirim matriks input 4,5,6, ke process 1,2,3
+
+ if (world_rank == root) {
+ // If we are the root process, send our data to every process
+ int i;
+ for (i = 0; i < world_size; i++) {
+ if (i != world_rank) {
+ MPI_Send(data, count, datatype, i, 0, communicator);
+ }
+ }
+ } else {
+ // If we are a receiver process, receive the data from the root
+ MPI_Recv(data, count, datatype, root, 0, communicator,
+ MPI_STATUS_IGNORE);
+
+
+ // Ngitung con sama data range
+ }
+}
+
+// void init_matrix_kernel() {
+// m->row_eff = 2;
+// m->col_eff = 2;
+
+// m->mat[0][0] = 1;
+// m->mat[0][1] = 0;
+// m->mat[1][0] = 0;
+// m->mat[1][1] = -1;
+// }
+
+// main() driver
+int main() {
+ // OPEN MPI
+ MPI_Init(NULL, NULL);
+
+ int world_rank;
+ MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
+ int world_size;
+ MPI_Comm_size(MPI_COMM_WORLD, &world_size);
+
+ const int PING_PONG_LIMIT = 3;
+ printf("HELLO WORLD\n");
+
+ // 10 / 4 = 2 2 2 (10-6)
+ int kernel_row, kernel_col, target_row, target_col, num_targets;
+
+ // reads kernel's row and column and initalize kernel matrix from input
+ scanf("%d %d", &kernel_row, &kernel_col);
+ Matrix kernel = input_matrix(kernel_row, kernel_col);
+
+ // reads number of target matrices and their dimensions.
+ // initialize array of matrices and array of data ranges (int)
+ scanf("%d %d %d", &num_targets, &target_row, &target_col);
+ Matrix* arr_mat = (Matrix*)malloc(num_targets * sizeof(Matrix));
+ Matrix* arr_mat2 = (Matrix*)malloc(num_targets * sizeof(Matrix));
+ int arr_range[num_targets];
+
+
+ // read each target matrix, compute their convolution matrices, and compute their data ranges
+ for (int i = 0; i < num_targets; i++) {
+ arr_mat[i] = input_matrix(target_row, target_col);
+ }
+
+ print_matrix(&kernel);
+
+ int counter_distribute = 0;
+ int counter_receiver = 0;
+
+ printf("HELLO OPEN MPI\n");
+
+
+
+ // --------------------------- Create the datatype ----------------------------- //
+ MPI_Datatype mat_MPI;
+ int lengths[3] = { NMAX * NMAX, 1, 1 };
+
+ // Calculate displacements
+ // In C, by default padding can be inserted between fields. MPI_Get_address will allow
+ // to get the address of each struct field and calculate the corresponding displacement
+ // relative to that struct base address. The displacements thus calculated will therefore
+ // include padding if any.
+ MPI_Aint displacements[3];
+ Matrix dummy_matrix;
+ MPI_Aint base_address;
+ MPI_Get_address(&dummy_matrix, &base_address);
+ MPI_Get_address(&dummy_matrix.mat, &displacements[0]);
+ MPI_Get_address(&dummy_matrix.row_eff, &displacements[1]);
+ MPI_Get_address(&dummy_matrix.col_eff, &displacements[2]);
+ displacements[0] = MPI_Aint_diff(displacements[0], base_address);
+ displacements[1] = MPI_Aint_diff(displacements[1], base_address);
+ displacements[2] = MPI_Aint_diff(displacements[2], base_address);
+
+ MPI_Datatype types[3] = { MPI_INT, MPI_INT, MPI_INT };
+ MPI_Type_create_struct(3, lengths, displacements, types, &mat_MPI);
+ MPI_Type_commit(&mat_MPI);
+
+ // --------------------------- End Create the datatype ----------------------------- //
+
+ // Distribusi matriks input ke process-process
+
+ /*
+ 0 1 2 3 4 5 6 7 8 9
+
+ 0 1 2
+
+ 3 4 5
+
+ 6 7 8
+
+ 9
+
+ */
+
+
+
+
+ int root = 0;
+
+ if (world_rank == root) {
+ // If we are the root process, send our data to every process
+ int i;
+ for (i = 0; i < world_size; i++) {
+ if (i != world_rank) {
+ MPI_Send(&arr_mat[counter_distribute], 1, mat_MPI, i, 0, MPI_COMM_WORLD);
+ counter_distribute++;
+ }
+ }
+ print_matrix(&kernel);
+ printf("PRocess 0 distribute\n ");
+
+ } else {
+ printf("PRocess selain 0 distribute %d \n", world_rank);
+ // If we are a receiver process, receive the data from the root
+ Matrix recv_data;
+ MPI_Recv(&recv_data, 1, mat_MPI, root, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+ print_matrix(&recv_data);
+
+ printf("HASILLL\n");
+ arr_mat2[counter_receiver] = convolution(&m, &recv_data);
+
+ print_matrix(&arr_mat2[counter_receiver]);
+ arr_range[counter_receiver] = get_matrix_datarange(&arr_mat2[counter_receiver]);
+
+ counter_receiver++;
+ }
+
+ while (counter_distribute < PING_PONG_LIMIT){
+ // distribute(arr_mat[counter_distribute],1,mat_MPI,0, MPI_COMM_WORLD)
+ printf("Counter dis %d \n", counter_distribute);
+ if (world_rank == root) {
+ // If we are the root process, send our data to every process
+ int i;
+ for (i = 0; i < world_size; i++) {
+ if (i != world_rank) {
+ MPI_Send(&arr_mat[counter_distribute], 1, mat_MPI, i, 0, MPI_COMM_WORLD);
+ counter_distribute++;
+ }
+ }
+ print_matrix(&kernel);
+ printf("PRocess 0 distribute\n ");
+
+ } else {
+ printf("PRocess selain 0 distribute %d \n", world_rank);
+ // If we are a receiver process, receive the data from the root
+ Matrix recv_data;
+ MPI_Recv(&recv_data, 1, mat_MPI, root, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+ print_matrix(&recv_data);
+ Matrix m;
+ m.row_eff = 2;
+ m.col_eff = 2;
+
+ m.mat[0][0] = 1;
+ m.mat[0][1] = 0;
+ m.mat[1][0] = 0;
+ m.mat[1][1] = -1;
+ print_matrix(&m);
+
+ printf("HASILLL\n");
+ arr_mat2[counter_receiver] = convolution(&m, &recv_data);
+
+ print_matrix(&arr_mat2[counter_receiver]);
+ arr_range[counter_receiver] = get_matrix_datarange(&arr_mat2[counter_receiver]);
+
+ counter_receiver++;
+ }
+ }
+
+ MPI_Finalize();
+
+
+ // // Print hasil
+ // for (int i = 0; i < num_targets; i++) {
+ // printf("\nMATRIX CONV %d",i);
+ // print_matrix(arr_mat2);
+ // }
+
+ // // sort the data range array
+ // printf("\n");
+ // print_array(arr_range,num_targets);
+ // merge_sort(arr_range, 0, num_targets - 1);
+
+ // int median = get_median(arr_range, num_targets);
+ // int floored_mean = get_floored_mean(arr_range, num_targets);
+
+ // // print the min, max, median, and floored mean of data range array
+ // printf("%d\n%d\n%d\n%d\n",
+ // arr_range[0],
+ // arr_range[num_targets - 1],
+ // median,
+ // floored_mean);
+
+
+
+ // START OPEN MP
+
+
+
+
+ return 0;
+}
diff --git a/src/person.c b/src/person.c
new file mode 100644
index 0000000..3b22c3f
--- /dev/null
+++ b/src/person.c
@@ -0,0 +1,150 @@
+/**
+ * @author RookieHPC
+ * @brief Original source code at https://www.rookiehpc.com/mpi/docs/mpi_type_create_struct.php
+ **/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <mpi.h>
+
+/**
+ * @brief Illustrates how to create an indexed MPI datatype.
+ * @details This program is meant to be run with 2 processes: a sender and a
+ * receiver. These two MPI processes will exchange a message made of a
+ * structure representing a person.
+ *
+ * Structure of a person:
+ * - age: int
+ * - height: double
+ * - name: char[10]
+ *
+ * How to represent such a structure with an MPI struct:
+ *
+ * +----------------- displacement for
+ * | block 2: sizeof(int) + sizeof(double)
+ * | (+ potential padding)
+ * | |
+ * +----- displacement for |
+ * | block 2: sizeof(int) |
+ * | (+ potential padding) |
+ * | | |
+ * displacement for | |
+ * block 1: 0 | |
+ * (+ potential padding) | |
+ * | | |
+ * V V V
+ * +------------+------------+------------+
+ * | age | height | name |
+ * +------------+------------+------------+
+ * <----------> <----------> <---------->
+ * block 1 block 2 block 3
+ * 1 MPI_INT 1 MPI_DOUBLE 10 MPI_CHAR
+ **/
+
+// struct person_t
+// {
+// int age;
+// double height;
+// char name[10];
+// };
+
+#define NMAX 100
+#define DATAMAX 1000
+#define DATAMIN -1000
+
+typedef struct Matrix {
+ int mat[NMAX][NMAX]; // Matrix cells
+ int row_eff; // Matrix effective row
+ int col_eff; // Matrix effective column
+} Matrix;
+
+void init_matrix(Matrix *m, int nrow, int ncol) {
+ m->row_eff = nrow;
+ m->col_eff = ncol;
+
+ for (int i = 0; i < m->row_eff; i++) {
+ for (int j = 0; j < m->col_eff; j++) {
+ m->mat[i][j] = 3;
+ }
+ }
+}
+
+void print_matrix(Matrix *m) {
+ for (int i = 0; i < m->row_eff; i++) {
+ for (int j = 0; j < m->col_eff; j++) {
+ printf("%d ", m->mat[i][j]);
+ }
+ printf("\n");
+ }
+}
+
+int main(int argc, char* argv[])
+{
+ MPI_Init(&argc, &argv);
+
+ // Get the number of processes and check only 2 processes are used
+ int size;
+ MPI_Comm_size(MPI_COMM_WORLD, &size);
+ if(size != 2)
+ {
+ printf("This application is meant to be run with 2 processes.\n");
+ MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
+ }
+
+ MPI_Datatype mat_MPI;
+ int lengths[3] = { NMAX * NMAX, 1, 1 };
+
+ // Calculate displacements
+ // In C, by default padding can be inserted between fields. MPI_Get_address will allow
+ // to get the address of each struct field and calculate the corresponding displacement
+ // relative to that struct base address. The displacements thus calculated will therefore
+ // include padding if any.
+ MPI_Aint displacements[3];
+ Matrix dummy_matrix;
+ MPI_Aint base_address;
+ MPI_Get_address(&dummy_matrix, &base_address);
+ MPI_Get_address(&dummy_matrix.mat, &displacements[0]);
+ MPI_Get_address(&dummy_matrix.row_eff, &displacements[1]);
+ MPI_Get_address(&dummy_matrix.col_eff, &displacements[2]);
+ displacements[0] = MPI_Aint_diff(displacements[0], base_address);
+ displacements[1] = MPI_Aint_diff(displacements[1], base_address);
+ displacements[2] = MPI_Aint_diff(displacements[2], base_address);
+
+ MPI_Datatype types[3] = { MPI_INT, MPI_INT, MPI_INT };
+ MPI_Type_create_struct(3, lengths, displacements, types, &mat_MPI);
+ MPI_Type_commit(&mat_MPI);
+
+ // Get my rank and do the corresponding job
+ enum rank_roles { SENDER, RECEIVER };
+ int my_rank;
+ MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
+ switch(my_rank)
+ {
+ case SENDER:
+ {
+ // Send the message
+ Matrix buffer;
+
+ buffer.row_eff = 4;
+ buffer.col_eff = 4;
+ init_matrix(&buffer,buffer.row_eff,buffer.col_eff);
+ printf("MPI process %d sends person:\n\t- ROW = %d\n\t- COL = %d\n\t-\n", my_rank, buffer.row_eff, buffer.row_eff);
+ MPI_Send(&buffer, 1, mat_MPI, RECEIVER, 0, MPI_COMM_WORLD);
+ break;
+ }
+ case RECEIVER:
+ {
+ // Receive the message
+ Matrix received;
+ MPI_Recv(&received, 1, mat_MPI, SENDER, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+ printf("MPI process %d received person:\n\t- ROW = %d\n\t- COL = %d\n\t-\n", my_rank, received.row_eff, received.row_eff);
+ print_matrix(&received);
+ break;
+ }
+ }
+
+ MPI_Finalize();
+
+ return EXIT_SUCCESS;
+}
diff --git a/src/serial b/src/serial
new file mode 100644
index 0000000000000000000000000000000000000000..8405e5cb485403663d575d0118b9b239f66a299e
GIT binary patch
literal 21480
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
literal 0
HcmV?d00001
diff --git a/src/serial.c b/src/serial.c
index 94b6f16..0b57468 100644
--- a/src/serial.c
+++ b/src/serial.c
@@ -237,6 +237,8 @@ int main() {
// reads kernel's row and column and initalize kernel matrix from input
scanf("%d %d", &kernel_row, &kernel_col);
Matrix kernel = input_matrix(kernel_row, kernel_col);
+
+
// reads number of target matrices and their dimensions.
// initialize array of matrices and array of data ranges (int)
@@ -248,10 +250,23 @@ int main() {
for (int i = 0; i < num_targets; i++) {
arr_mat[i] = input_matrix(target_row, target_col);
arr_mat[i] = convolution(&kernel, &arr_mat[i]);
- arr_range[i] = get_matrix_datarange(&arr_mat[i]);
+ arr_range[i] = get_matrix_datarange(&arr_mat[i]);
+
+ printf("\nhmmmm\n");
+ print_matrix(&arr_mat[i]);
+ }
+
+ // Print hasil
+ for (int i = 0; i < num_targets; i++) {
+ printf("\nMATRIX CONV %d",i);
+ printf("\nArray mat\n");
+ print_matrix(&arr_mat[i]);
}
+
// sort the data range array
+ printf("\n");
+ print_array(arr_range,num_targets);
merge_sort(arr_range, 0, num_targets - 1);
int median = get_median(arr_range, num_targets);
--
GitLab