diff --git a/.gitignore b/.gitignore
index 0c2595e1cdc1afa174980034b71609f7bdbcc821..383f2ac4d503ab2edc82746003a31583426922d6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,5 @@
-# Binary file
-/bin
\ No newline at end of file
+# IDE Settings
+.vscode/
+
+# Binary files
+bin/*
\ No newline at end of file
diff --git a/README.md b/README.md
index c9540db93a247645022e8bc25e581a6d0f242baa..3acc7748b702cbcb7b51bd1fc25fcea9a8b419f4 100644
--- a/README.md
+++ b/README.md
@@ -1,96 +1,34 @@
-# SISTER_WE_THE_CLOWN_PART_2
-
-
-
-## Getting started
-
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
-
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
-
-## Resource
-
-[Google Colaboratory](https://colab.research.google.com/drive/17W09R-Vo0bf_k3r5APhE8ozb5lHHPaQl)
-
-## Add your files
-
-- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
-- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
-
-```
-cd existing_repo
-git remote add origin https://gitlab.informatika.org/azharfatrr/sister_we_the_clown_part_2.git
-git branch -M main
-git push -uf origin main
-```
-
-## Integrate with your tools
-
-- [ ] [Set up project integrations](https://gitlab.informatika.org/azharfatrr/sister_we_the_clown_part_2/-/settings/integrations)
-
-## Collaborate with your team
-
-- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
-- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
-- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
-- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
-- [ ] [Automatically merge when pipeline succeeds](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
-
-## Test and Deploy
-
-Use the built-in continuous integration in GitLab.
-
-- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
-- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing(SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
-- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
-- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
-- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
-
-***
-
-# Editing this README
-
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thank you to [makeareadme.com](https://www.makeareadme.com/) for this template.
-
-## Suggestions for a good README
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
-
-## Name
-Choose a self-explaining name for your project.
-
-## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
-
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
-
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
-
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
-
-## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
-
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
-
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
-
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
-
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
-
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
-
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
-
-## License
-For open source projects, say how it is licensed.
-
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
+# SISTER_WE_THE_CLOWN
+
+## Semester II Tahun 2021/2022
+
+### Tugas Besar 1 IF3230 Sistem Paralel dan Terdistribusi
+
+*Program Studi Teknik Informatika* <br />
+*Sekolah Teknik Elektro dan Informatika* <br />
+*Institut Teknologi Bandung* <br />
+
+*Semester II Tahun 2021/2022*
+
+## Description
+
+Program paralel yang menerima satu matriks kernel dan n buah matriks masukan. Program akan melakukan operasi konvolusi matriks pada matriks kernel dan setiap matriks masukan untuk menghasilkan matriks hasil konvolusi. Setelah itu, program Anda akan membuat n bilangan bulat positif yang merupakan selisih elemen terbesar dan terkecil dari setiap matriks hasil konvolusi, serta melakukan sorting dari n bilangan tersebut.
+Keluaran program Anda adalah nilai maksimum, nilai minimum, median, dan rata-rata n bilangan tersebut. Nilai median dan rata-rata dihitung menggunakan integer division untuk pembulatan. Program harus dibuat secara parallel dengan memanfaatkan OpenMPI (untuk komunikasi antar mesin) dan OpenMP (untuk melakukan multithreading)
+
+## Author
+
+1. [Muhammad Azhar Faturahman (13519020)](https://github.com/azharfatrr)
+2. [Gde Anantha Priharsena (13519026)](https://github.com/gdeananthap)
+3. [Reihan Andhika Putra (13519043)](https://github.com/AndhikaRei)
+
+## Resources
+
+[Google Colaboratory](https://colab.research.google.com/drive/17W09R-Vo0bf_k3r5APhE8ozb5lHHPaQl)
+
+## Requirements
+
+- [C](https://www.gnu.org/software/gcc/gcc.html)
+- [OpenMPI](https://www.open-mpi.org/)
+- [OpenMP](https://openmp.org/)
+
+## Installation
\ No newline at end of file
diff --git a/asset/Ilustrasi Merge Sort.png b/asset/Ilustrasi Merge Sort.png
new file mode 100644
index 0000000000000000000000000000000000000000..452a577c9f5fadeb7a2365857db9e5c703437fe3
Binary files /dev/null and b/asset/Ilustrasi Merge Sort.png differ
diff --git a/makefile b/makefile
new file mode 100644
index 0000000000000000000000000000000000000000..3d8f75e64f66c3cde25b7c3e6ad255ce577e51e8
--- /dev/null
+++ b/makefile
@@ -0,0 +1,70 @@
+SOURCE_SERIAL=./src/serial.c
+SOURCE_PARALLEL=./src/parallel.cu
+SOURCE_TEST=./src/test.c
+
+EXEC_SERIAL=main-serial
+EXEC_PARALLEL=main-parallel
+EXEC_TEST=test
+
+COMPILER_PARALLEL=nvcc
+COMPILER_SERIAL=gcc
+
+
+
+# Compile program.
+compile-serial:
+ ${COMPILER_SERIAL} -o ./bin/${EXEC_SERIAL} ${SOURCE_SERIAL}
+compile-parallel:
+ ${COMPILER_PARALLEL} -rdc=true -o ./bin/${EXEC_PARALLEL} ${SOURCE_PARALLEL} ./src/lib/matrix.cu ./src/lib/utils.cu ./src/lib/bitonic_sort.cu
+
+# Link program.
+link-serial: compile-serial
+link-parallel: compile-parallel
+
+# Compile and link.
+install-serial: compile-serial link-serial
+install-parallel: compile-parallel link-parallel
+
+# Clean bin folder.
+clean:
+ rm ./bin/*
+
+# Running program
+run-serial: install-serial
+ ./bin/${EXEC_SERIAL}
+run-serial-example: install-serial
+ ./bin/${EXEC_SERIAL} < ./testcase/Example-TC
+run-parallel: install-parallel
+ ./bin/${EXEC_PARALLEL
+run-parallel-example: install-parallel
+ ./bin/${EXEC_PARALLEL} < ./testcase/Example-TC
+
+# Example testcase.
+TC-example:
+ (make run < ./testcase/Example-TC) > ./testcase/Example-TC.out
+
+# Serial Testcase.
+TC1-serial: install-serial
+ (./bin/${EXEC_SERIAL} < ./testcase/K01-03-TC1) > ./result/K01-03-TC1_serial.txt
+TC2-serial: install-serial
+ (./bin/${EXEC_SERIAL} < ./testcase/K01-03-TC2) > ./result/K01-03-TC2_serial.txt
+TC3-serial: install-serial
+ (./bin/${EXEC_SERIAL} < ./testcase/K01-03-TC3) > ./result/K01-03-TC3_serial.txt
+TC4-serial: install-serial
+ (./bin/${EXEC_SERIAL} < ./testcase/K01-03-TC4) > ./result/K01-03-TC4_serial.txt
+
+TC-serial: TC1-serial TC2-serial TC3-serial TC4-serial
+
+# Generic parallel testcase.
+TC1-parallel: install-parallel
+ (./bin/${EXEC_PARALLEL} < ./testcase/K01-03-TC1) > ./result/K01-03-TC1_parallel.txt
+TC2-parallel: install-parallel
+ (./bin/${EXEC_PARALLEL} < ./testcase/K01-03-TC2) > ./result/K01-03-TC2_parallel.txt
+TC3-parallel: install-parallel
+ (./bin/${EXEC_PARALLEL} < ./testcase/K01-03-TC3) > ./result/K01-03-TC3_parallel.txt
+TC4-parallel: install-parallel
+ (./bin/${EXEC_PARALLEL} < ./testcase/K01-03-TC4) > ./result/K01-03-TC4_parallel.txt
+
+TC-parallel: TC1-parallel TC2-parallel TC3-parallel TC4-parallel
+
+TC-generic: TC-serial TC-parallel
diff --git a/result/K01-03-TC1_parallel.txt b/result/K01-03-TC1_parallel.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a6dd3f6a9db8ee03785586c8a82ea8b487fb8f42
--- /dev/null
+++ b/result/K01-03-TC1_parallel.txt
@@ -0,0 +1,6 @@
+8539213
+11916317
+10114197
+10323010
+
+Runtime: 0.162644 s
diff --git a/result/K01-03-TC1_serial.txt b/result/K01-03-TC1_serial.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d0f9d3b38ab236e4b15aaddde556310ee714d4eb
--- /dev/null
+++ b/result/K01-03-TC1_serial.txt
@@ -0,0 +1,6 @@
+8539213
+11916317
+10114197
+10323010
+
+Runtime: 0.016319 s
diff --git a/result/K01-03-TC2_parallel.txt b/result/K01-03-TC2_parallel.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b0dc0985543b3dc07f5709dff304347b6fb30550
--- /dev/null
+++ b/result/K01-03-TC2_parallel.txt
@@ -0,0 +1,6 @@
+35064588
+46265294
+37739803
+38222937
+
+Runtime: 0.871782 s
diff --git a/result/K01-03-TC2_serial.txt b/result/K01-03-TC2_serial.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c9286062a32a9e71ec01f6da7a6de8d40d086c8c
--- /dev/null
+++ b/result/K01-03-TC2_serial.txt
@@ -0,0 +1,6 @@
+35064588
+46265294
+37739803
+38222937
+
+Runtime: 0.772688 s
diff --git a/result/K01-03-TC3_parallel.txt b/result/K01-03-TC3_parallel.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a2e3dcc6325c485697d7c496849571cd2ed7057f
--- /dev/null
+++ b/result/K01-03-TC3_parallel.txt
@@ -0,0 +1,6 @@
+18815130
+28707695
+23198319
+23380111
+
+Runtime: 1.021110 s
diff --git a/result/K01-03-TC3_serial.txt b/result/K01-03-TC3_serial.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aefabd33e10fbd433489260714e3c183ede9e3dd
--- /dev/null
+++ b/result/K01-03-TC3_serial.txt
@@ -0,0 +1,6 @@
+18815130
+28707695
+23198319
+23380111
+
+Runtime: 0.893097 s
diff --git a/result/K01-03-TC4_parallel.txt b/result/K01-03-TC4_parallel.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0392bae707c69dce16b797a597723dd0644b2ffa
--- /dev/null
+++ b/result/K01-03-TC4_parallel.txt
@@ -0,0 +1,6 @@
+41250811
+71841136
+51451884
+51774352
+
+Runtime: 9.808481 s
diff --git a/result/K01-03-TC4_serial.txt b/result/K01-03-TC4_serial.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fa4259fa99245fa3d1f010d072ff16968b2ff4a7
--- /dev/null
+++ b/result/K01-03-TC4_serial.txt
@@ -0,0 +1,6 @@
+41250811
+71841136
+51451884
+51774352
+
+Runtime: 9.509920 s
diff --git a/algorithm/bitonic_sort.cu b/src/lib/bitonic_sort.cu
similarity index 94%
rename from algorithm/bitonic_sort.cu
rename to src/lib/bitonic_sort.cu
index e35d1c6c26aeba6b5076dd99625f3969a72d815a..c126d18079df6bceae75d311071f39d63c579815 100644
--- a/algorithm/bitonic_sort.cu
+++ b/src/lib/bitonic_sort.cu
@@ -1,220 +1,223 @@
-/*
- * Parallel bitonic sort using CUDA.
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <time.h>
-
-// PROBLEM: THREADS DAN BLOCKS HARUS KELIPATAN 2
-// SOLUTION: PADDING DATA KE DALAM BUFFER DENGAN NILAI MAX_INT
-
-
-void array_fill(int *arr, int length)
-{
- srand(time(NULL));
- int i;
- for (i = 0; i < length; ++i) {
- arr[i] = rand();
- }
-}
-
-void array_print(int *arr, int length)
-{
- int i;
- for (i = 0; i < length; ++i) {
- printf("%d ", arr[i]);
- }
- printf("\n");
-}
-
-int checksum(int *arr, int size)
-{
- int sum = 0;
- for (int i = 0; i < size; i++)
- sum += arr[i];
- return sum;
-}
-
-bool isSorted(int *arr, int size)
-{
- for (int i = 0; i < size - 1; i++)
- if (arr[i] > arr[i + 1])
- return false;
- return true;
-}
-
-void print_elapsed(clock_t start, clock_t stop)
-{
- double elapsed = ((double) (stop - start)) / CLOCKS_PER_SEC;
- printf("Elapsed time: %.3fs\n", elapsed);
-}
-
-/**
- * Swap the values of two elements in an array.
- *
- * @param d_arr - the array.
- * @param i - the index of the first element.
- * @param j - the index of the second element.
- */
-__device__ void swap(int *d_arr, int i, int j)
-{
- int temp = d_arr[i];
- d_arr[i] = d_arr[j];
- d_arr[j] = temp;
-}
-
-/**
- * Pad the remaining empty value in the array with the maximum value.
- *
- * @param arr - the array.
- * @param length - the number of elements inside the array.
- * @param length_buffer - the length of the buffer.
- */
-void padding_array(int *arr, int length, int length_buffer)
-{
- for (int i = length; i < length_buffer; i++) {
- arr[i] = INT_MAX;
- }
-}
-
-/**
- * Copy the array from src to dest and pad the remaining empty value with the maximum value.
- *
- * @param dest - the destination array.
- * @param src - the source array.
- * @param length - the number of elements inside the src array.
- * @param length_buffer - the length of the buffer.
- */
-void copy_padding(int *dest, int *src, int length, int length_buffer)
-{
- for (int i = 0; i < length; i++) {
- dest[i] = src[i];
- }
- padding_array(dest, length, length_buffer);
-}
-
-/**
- * Do the bitnoic sort step by step.
- *
- * @param d_values - array in the device to be sorted.
- * @param i - major step index.
- * @param j - minor step index.
- */
-__global__ void bitonic_sort_step(int *d_arr, int i, int j)
-{
- // The array index and its patner.
- unsigned int idx, patner;
- idx = threadIdx.x + blockDim.x * blockIdx.x;
-
- // Get the patner.
- patner = idx ^ j;
-
- // Sort the array by threads with the lowest idx.
- if (idx < patner) {
- if ((idx & i) == 0) {
- // Sort ascending.
- if (d_arr[idx] > d_arr[patner]) {
- swap(d_arr, idx, patner);
- }
- }
- if ((idx & i) != 0) {
- // Sort descending.
- if (d_arr[idx] < d_arr[patner]) {
- swap(d_arr, idx, patner);
- }
- }
- }
-}
-
-/**
- * Perform a bitonic sort on the array.
- *
- * @param h_arr The host array to sort.
- * @param length The length of the array.
- */
-void bitonic_sort(int *h_arr, int length)
-{
- // Initialize the constants variable.
- const int threads = 1024;
- const int blocks = 32;
- const int buffer_length = threads * blocks;
-
- // Check that the buffer can hold the array.
- if (length > buffer_length) {
- printf("[ERROR] The array length is %d, but the buffer length is %d.\n", length, buffer_length);
- return;
- }
-
- // Initialize the memory size of the array.
- size_t size = length * sizeof(int);
- size_t buffer_size = buffer_length * sizeof(int);
-
- // Create the buffer array and pad with maximum value of Int.
- int *h_buffer = (int *)malloc(buffer_size);
- copy_padding(h_buffer, h_arr, length, buffer_length);
-
- // Allocate and copy array into device memory.
- int *d_arr;
- cudaMalloc((void**) &d_arr, buffer_size);
- cudaMemcpy(d_arr, h_buffer, buffer_size, cudaMemcpyHostToDevice);
-
- // Sort the array using bitonic_sort_step.
- int i, j;
- // The major step.
- for (i = 2; i <= buffer_length; i *= 2) {
- // The minor step.
- for (j = i / 2; j > 0; j = j / 2) {
- bitonic_sort_step<<<blocks, threads>>>(d_arr, i, j);
- }
- }
-
- // Copy the values back to the host.
- cudaMemcpy(h_arr, d_arr, size, cudaMemcpyDeviceToHost);
-
- // Free device memory.
- cudaFree(d_arr);
- free(h_buffer);
-}
-
-int main(void)
-{
- clock_t start, stop;
- int length = 1000000;
-
- int *values = (int*) malloc( length * sizeof(int));
- array_fill(values, length);
-
- // array_print(values, length);
- // printf("\n");
-
- int checksum1 = checksum(values, length);
-
- start = clock();
-
- bitonic_sort(values, length);
-
- stop = clock();
-
- int checksum2 = checksum(values, length);
-
- // array_print(values, length);
- // printf("\n");
-
- print_elapsed(start, stop);
-
- // TESTCASE.
- bool passed_sort = true;
- bool passed_checksum = true;
-
- passed_sort = isSorted(values, length);
-
- if (checksum1 != checksum2)
- {
- passed_checksum = false;
- printf("%d != %d\n", checksum1, checksum2);
- }
-
- printf("Test %s\n", passed_sort ? "PASSED SORT" : "FAILED SORT");
- printf("Test %s\n", passed_checksum ? "PASSED CHECKSUM" : "FAILED CHECKSUM");
+/*
+ * Parallel bitonic sort using CUDA.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include "bitonic_sort.cuh"
+
+// PROBLEM: THREADS DAN BLOCKS HARUS KELIPATAN 2
+// SOLUTION: PADDING DATA KE DALAM BUFFER DENGAN NILAI MAX_INT
+
+
+void array_fill(int *arr, int length)
+{
+ srand(time(NULL));
+ int i;
+ for (i = 0; i < length; ++i) {
+ arr[i] = rand();
+ }
+}
+
+void array_print(int *arr, int length)
+{
+ int i;
+ for (i = 0; i < length; ++i) {
+ printf("%d ", arr[i]);
+ }
+ printf("\n");
+}
+
+int checksum(int *arr, int size)
+{
+ int sum = 0;
+ for (int i = 0; i < size; i++)
+ sum += arr[i];
+ return sum;
+}
+
+bool isSorted(int *arr, int size)
+{
+ for (int i = 0; i < size - 1; i++)
+ if (arr[i] > arr[i + 1])
+ return false;
+ return true;
+}
+
+void print_elapsed(clock_t start, clock_t stop)
+{
+ double elapsed = ((double) (stop - start)) / CLOCKS_PER_SEC;
+ printf("Elapsed time: %.3fs\n", elapsed);
+}
+
+/**
+ * Swap the values of two elements in an array.
+ *
+ * @param d_arr - the array.
+ * @param i - the index of the first element.
+ * @param j - the index of the second element.
+ */
+__device__ void swap(int *d_arr, int i, int j)
+{
+ int temp = d_arr[i];
+ d_arr[i] = d_arr[j];
+ d_arr[j] = temp;
+}
+
+/**
+ * Pad the remaining empty value in the array with the maximum value.
+ *
+ * @param arr - the array.
+ * @param length - the number of elements inside the array.
+ * @param length_buffer - the length of the buffer.
+ */
+void padding_array(int *arr, int length, int length_buffer)
+{
+ for (int i = length; i < length_buffer; i++) {
+ arr[i] = INT_MAX;
+ }
+}
+
+/**
+ * Copy the array from src to dest and pad the remaining empty value with the maximum value.
+ *
+ * @param dest - the destination array.
+ * @param src - the source array.
+ * @param length - the number of elements inside the src array.
+ * @param length_buffer - the length of the buffer.
+ */
+void copy_padding(int *dest, int *src, int length, int length_buffer)
+{
+ for (int i = 0; i < length; i++) {
+ dest[i] = src[i];
+ }
+ padding_array(dest, length, length_buffer);
+}
+
+/**
+ * Do the bitnoic sort step by step.
+ *
+ * @param d_values - array in the device to be sorted.
+ * @param i - major step index.
+ * @param j - minor step index.
+ */
+__global__ void bitonic_sort_step(int *d_arr, int i, int j)
+{
+ // The array index and its patner.
+ unsigned int idx, patner;
+ idx = threadIdx.x + blockDim.x * blockIdx.x;
+
+ // Get the patner.
+ patner = idx ^ j;
+
+ // Sort the array by threads with the lowest idx.
+ if (idx < patner) {
+ if ((idx & i) == 0) {
+ // Sort ascending.
+ if (d_arr[idx] > d_arr[patner]) {
+ swap(d_arr, idx, patner);
+ }
+ }
+ if ((idx & i) != 0) {
+ // Sort descending.
+ if (d_arr[idx] < d_arr[patner]) {
+ swap(d_arr, idx, patner);
+ }
+ }
+ }
+}
+
+/**
+ * Perform a bitonic sort on the array.
+ *
+ * @param h_arr The host array to sort.
+ * @param length The length of the array.
+ */
+void bitonic_sort(int *h_arr, int length)
+{
+ // Initialize the constants variable.
+ const int threads = 1024;
+ const int blocks = 8;
+ const int buffer_length = threads * blocks;
+
+ // Check that the buffer can hold the array.
+ if (length > buffer_length) {
+ printf("[ERROR] The array length is %d, but the buffer length is %d.\n", length, buffer_length);
+ return;
+ }
+
+ // Initialize the memory size of the array.
+ size_t size = length * sizeof(int);
+ size_t buffer_size = buffer_length * sizeof(int);
+
+ // Create the buffer array and pad with maximum value of Int.
+ int *h_buffer = (int *)malloc(buffer_size);
+ copy_padding(h_buffer, h_arr, length, buffer_length);
+
+ // Allocate and copy array into device memory.
+ int *d_arr;
+ cudaMalloc((void**) &d_arr, buffer_size);
+ cudaMemcpy(d_arr, h_buffer, buffer_size, cudaMemcpyHostToDevice);
+
+ // Sort the array using bitonic_sort_step.
+ int i, j;
+ // The major step.
+ for (i = 2; i <= buffer_length; i *= 2) {
+ // The minor step.
+ for (j = i / 2; j > 0; j = j / 2) {
+ bitonic_sort_step<<<blocks, threads>>>(d_arr, i, j);
+ }
+ }
+
+ // Copy the values back to the host.
+ cudaMemcpy(h_arr, d_arr, size, cudaMemcpyDeviceToHost);
+
+ // Free device memory.
+ cudaFree(d_arr);
+ free(h_buffer);
+}
+
+int driver(void)
+{
+ clock_t start, stop;
+ int length = 1000000;
+
+ int *values = (int*) malloc( length * sizeof(int));
+ array_fill(values, length);
+
+ // array_print(values, length);
+ // printf("\n");
+
+ int checksum1 = checksum(values, length);
+
+ start = clock();
+
+ bitonic_sort(values, length);
+
+ stop = clock();
+
+ int checksum2 = checksum(values, length);
+
+ // array_print(values, length);
+ // printf("\n");
+
+ print_elapsed(start, stop);
+
+ // TESTCASE.
+ bool passed_sort = true;
+ bool passed_checksum = true;
+
+ passed_sort = isSorted(values, length);
+
+ if (checksum1 != checksum2)
+ {
+ passed_checksum = false;
+ printf("%d != %d\n", checksum1, checksum2);
+ }
+
+ printf("Test %s\n", passed_sort ? "PASSED SORT" : "FAILED SORT");
+ printf("Test %s\n", passed_checksum ? "PASSED CHECKSUM" : "FAILED CHECKSUM");
+
+ return 0;
}
\ No newline at end of file
diff --git a/src/lib/bitonic_sort.cuh b/src/lib/bitonic_sort.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..e450fcaac3cc6317ec37195d8975ae335437f9a7
--- /dev/null
+++ b/src/lib/bitonic_sort.cuh
@@ -0,0 +1,23 @@
+#ifndef _BITONIC_SORT_H_
+#define _BITONIC_SORT_H_
+
+/**
+ * Do the bitnoic sort step by step.
+ *
+ * @param d_values - array in the device to be sorted.
+ * @param i - major step index.
+ * @param j - minor step index.
+ */
+__global__ void bitonic_sort_step(int *d_arr, int i, int j);
+
+
+/**
+ * Perform a bitonic sort on the array.
+ *
+ * @param h_arr The host array to sort.
+ * @param length The length of the array.
+ */
+void bitonic_sort(int *h_arr, int length);
+
+
+#endif
\ No newline at end of file
diff --git a/algorithm/brick_sort.cu b/src/lib/brick_sort.cu
similarity index 95%
rename from algorithm/brick_sort.cu
rename to src/lib/brick_sort.cu
index aa2c27e2192505d2c01e1ecc1f8d755e7eab8c77..fdf9683640c6429780594d0c632ba892d953e558 100644
--- a/algorithm/brick_sort.cu
+++ b/src/lib/brick_sort.cu
@@ -1,136 +1,136 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <time.h>
-
-// PROBLEM: INI GA JALAN KALAU BLOCKS > 1
-
-/* Every thread gets exactly one value in the unsorted array. */
-#define THREADS 16
-#define NUM_VALS 2000
-
-void print_elapsed(clock_t start, clock_t stop)
-{
- double elapsed = ((double)(stop - start)) / CLOCKS_PER_SEC;
- printf("Elapsed time: %.3fs\n", elapsed);
-}
-
-int checksum(int *arr, int size)
-{
- int sum = 0;
- for (int i = 0; i < size; i++)
- sum += arr[i];
- return sum;
-}
-
-int random_int()
-{
- return (int)rand() / (int)RAND_MAX;
-}
-
-void array_print(int *arr, int length)
-{
- int i;
- for (i = 0; i < length; ++i)
- {
- printf("%d ", arr[i]);
- }
- printf("\n");
-}
-
-void array_fill(int *arr, int length)
-{
- srand(time(NULL));
- int i;
- for (i = 0; i < length; ++i)
- {
- arr[i] = rand();
- }
-}
-
-__device__ void swap(int *d_arr, int i, int j)
-{
- int temp = d_arr[i];
- d_arr[i] = d_arr[j];
- d_arr[j] = temp;
-}
-
-__global__ void brick_sort(int *d_arr, int length)
-{
- int l;
- if (length % 2 == 0)
- l = length / 2;
- else
- l = (length / 2) + 1;
- for (int i = 0; i < l; i++)
- {
- if ((!(threadIdx.x & 1)) && (threadIdx.x < (length - 1))) // even phase
- {
- if (d_arr[threadIdx.x] > d_arr[threadIdx.x + 1])
- swap(d_arr, threadIdx.x, threadIdx.x + 1);
- }
-
- __syncthreads();
- if ((threadIdx.x & 1) && (threadIdx.x < (length - 1))) // odd phase
- {
- if (d_arr[threadIdx.x] > d_arr[threadIdx.x + 1])
- swap(d_arr, threadIdx.x, threadIdx.x + 1);
- }
- __syncthreads();
- } // for
-}
-
-int main(void)
-{
- clock_t start, stop;
- size_t size = NUM_VALS * sizeof(int);
- int blocks = (NUM_VALS + THREADS - 1) / THREADS;
- printf("Blocks: %d\n", blocks);
-
- int *arr = (int *)malloc(NUM_VALS * sizeof(int));
- array_fill(arr, NUM_VALS);
-
- int checksum1 = checksum(arr, NUM_VALS);
-
- start = clock();
-
- int *d_arr;
-
- cudaMalloc((void **)&d_arr, size);
- cudaMemcpy(d_arr, arr, size, cudaMemcpyHostToDevice);
-
- for (int i = 0; i < NUM_VALS / 2; ++i)
- {
- brick_sort<<<1, THREADS>>>(d_arr, NUM_VALS);
- }
-
- cudaMemcpy(arr, d_arr, size, cudaMemcpyDeviceToHost);
- cudaFree(d_arr);
-
- int checksum2 = checksum(arr, NUM_VALS);
-
- stop = clock();
-
- print_elapsed(start, stop);
-
- bool passed_sort = true;
- bool passed_checksum = true;
-
- for (int i = 1; i < NUM_VALS; i++)
- {
- if (arr[i - 1] > arr[i])
- {
- passed_sort = false;
- }
- }
-
- if (checksum1 != checksum2)
- {
- passed_checksum = false;
- printf("%d != %d\n", checksum1, checksum2);
- }
-
- array_print(arr, NUM_VALS);
-
- printf("Test %s\n", passed_sort ? "PASSED SORT" : "FAILED SORT");
- printf("Test %s\n", passed_checksum ? "PASSED CHECKSUM" : "FAILED CHECKSUM");
-}
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+// PROBLEM: INI GA JALAN KALAU BLOCKS > 1
+
+/* Every thread gets exactly one value in the unsorted array. */
+#define THREADS 16
+#define NUM_VALS 2000
+
+void print_elapsed(clock_t start, clock_t stop)
+{
+ double elapsed = ((double)(stop - start)) / CLOCKS_PER_SEC;
+ printf("Elapsed time: %.3fs\n", elapsed);
+}
+
+int checksum(int *arr, int size)
+{
+ int sum = 0;
+ for (int i = 0; i < size; i++)
+ sum += arr[i];
+ return sum;
+}
+
+int random_int()
+{
+ return (int)rand() / (int)RAND_MAX;
+}
+
+void array_print(int *arr, int length)
+{
+ int i;
+ for (i = 0; i < length; ++i)
+ {
+ printf("%d ", arr[i]);
+ }
+ printf("\n");
+}
+
+void array_fill(int *arr, int length)
+{
+ srand(time(NULL));
+ int i;
+ for (i = 0; i < length; ++i)
+ {
+ arr[i] = rand();
+ }
+}
+
+__device__ void swap(int *d_arr, int i, int j)
+{
+ int temp = d_arr[i];
+ d_arr[i] = d_arr[j];
+ d_arr[j] = temp;
+}
+
+__global__ void brick_sort(int *d_arr, int length)
+{
+ int l;
+ if (length % 2 == 0)
+ l = length / 2;
+ else
+ l = (length / 2) + 1;
+ for (int i = 0; i < l; i++)
+ {
+ if ((!(threadIdx.x & 1)) && (threadIdx.x < (length - 1))) // even phase
+ {
+ if (d_arr[threadIdx.x] > d_arr[threadIdx.x + 1])
+ swap(d_arr, threadIdx.x, threadIdx.x + 1);
+ }
+
+ __syncthreads();
+ if ((threadIdx.x & 1) && (threadIdx.x < (length - 1))) // odd phase
+ {
+ if (d_arr[threadIdx.x] > d_arr[threadIdx.x + 1])
+ swap(d_arr, threadIdx.x, threadIdx.x + 1);
+ }
+ __syncthreads();
+ } // for
+}
+
+int main(void)
+{
+ clock_t start, stop;
+ size_t size = NUM_VALS * sizeof(int);
+ int blocks = (NUM_VALS + THREADS - 1) / THREADS;
+ printf("Blocks: %d\n", blocks);
+
+ int *arr = (int *)malloc(NUM_VALS * sizeof(int));
+ array_fill(arr, NUM_VALS);
+
+ int checksum1 = checksum(arr, NUM_VALS);
+
+ start = clock();
+
+ int *d_arr;
+
+ cudaMalloc((void **)&d_arr, size);
+ cudaMemcpy(d_arr, arr, size, cudaMemcpyHostToDevice);
+
+ for (int i = 0; i < NUM_VALS / 2; ++i)
+ {
+ brick_sort<<<1, THREADS>>>(d_arr, NUM_VALS);
+ }
+
+ cudaMemcpy(arr, d_arr, size, cudaMemcpyDeviceToHost);
+ cudaFree(d_arr);
+
+ int checksum2 = checksum(arr, NUM_VALS);
+
+ stop = clock();
+
+ print_elapsed(start, stop);
+
+ bool passed_sort = true;
+ bool passed_checksum = true;
+
+ for (int i = 1; i < NUM_VALS; i++)
+ {
+ if (arr[i - 1] > arr[i])
+ {
+ passed_sort = false;
+ }
+ }
+
+ if (checksum1 != checksum2)
+ {
+ passed_checksum = false;
+ printf("%d != %d\n", checksum1, checksum2);
+ }
+
+ array_print(arr, NUM_VALS);
+
+ printf("Test %s\n", passed_sort ? "PASSED SORT" : "FAILED SORT");
+ printf("Test %s\n", passed_checksum ? "PASSED CHECKSUM" : "FAILED CHECKSUM");
+}
diff --git a/src/lib/matrix.cu b/src/lib/matrix.cu
new file mode 100644
index 0000000000000000000000000000000000000000..6d401529fd9c8f3ee7fb83fca0779a84189bd02e
--- /dev/null
+++ b/src/lib/matrix.cu
@@ -0,0 +1,119 @@
+#include <stdio.h>
+#include <omp.h>
+
+#include "matrix.cuh"
+
+
+/*
+ * 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;
+
+ 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;
+}
diff --git a/src/lib/matrix.cuh b/src/lib/matrix.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..89af83b477738167be17d59d13621f72ae60e736
--- /dev/null
+++ b/src/lib/matrix.cuh
@@ -0,0 +1,75 @@
+#ifndef _MATRIX_H_
+#define _MATRIX_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);
+
+
+/*
+ * Function input_matrix
+ *
+ * Returns a matrix with values from stdin input
+ * */
+Matrix input_matrix(int nrow, int ncol);
+
+
+/*
+ * Procedure print_matrix
+ *
+ * Print matrix data
+ * */
+void print_matrix(Matrix *m);
+
+
+/*
+ * Function get_matrix_datarange
+ *
+ * Returns the range between maximum and minimum
+ * element of a matrix
+ * */
+int get_matrix_datarange(Matrix *m);
+
+
+/*
+ * 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);
+
+/*
+ * Function convolution
+ *
+ * Return the output matrix of convolution operation
+ * between kernel and target
+ * */
+Matrix convolution(Matrix *kernel, Matrix *target);
+
+
+
+#endif
\ No newline at end of file
diff --git a/src/lib/utils.cu b/src/lib/utils.cu
new file mode 100644
index 0000000000000000000000000000000000000000..b0efc57357cbd7fe362069bacbd8b4c84396d13d
--- /dev/null
+++ b/src/lib/utils.cu
@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include "utils.cuh"
+#include "matrix.cuh"
+
+/*
+ * 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;
+}
diff --git a/src/lib/utils.cuh b/src/lib/utils.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..763d092a06033825a12acdfa7768af6dcbfe7733
--- /dev/null
+++ b/src/lib/utils.cuh
@@ -0,0 +1,29 @@
+
+#ifndef _UTILS_H_
+#define _UTILS_H_
+
+
+/*
+ * Procedure print_array
+ *
+ * Prints all elements of array n of size to stdout
+ * */
+void print_array(int *n, int size);
+
+
+/*
+ * Function get_median
+ *
+ * Returns median of array n of length
+ * */
+int get_median(int *n, int length);
+
+
+/*
+ * Function get_floored_mean
+ *
+ * Returns floored mean from an array of integers
+ * */
+long get_floored_mean(int *n, int length);
+
+#endif
\ No newline at end of file
diff --git a/src/parallel.cu b/src/parallel.cu
new file mode 100644
index 0000000000000000000000000000000000000000..f43975e01362a5e1c4c54191dcfaa013aa432c1c
--- /dev/null
+++ b/src/parallel.cu
@@ -0,0 +1,55 @@
+// serial.c
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include "./lib/bitonic_sort.cuh"
+#include "./lib/matrix.cuh"
+#include "./lib/utils.cuh"
+
+
+// main() driver
+int main() {
+ // Time.
+ clock_t t;
+ t = clock();
+
+ 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));
+ int *arr_range = (int*)malloc(num_targets * sizeof(int));
+
+ // 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);
+ arr_mat[i] = convolution(&kernel, &arr_mat[i]);
+ arr_range[i] = get_matrix_datarange(&arr_mat[i]);
+ }
+
+ // sort the data range array
+ bitonic_sort(arr_range, num_targets);
+
+ 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);
+
+ // Print execution time in seconds.
+ t = clock() - t;
+ printf("\nRuntime: %f s\n", ((float)t) / CLOCKS_PER_SEC);
+
+ return 0;
+}
diff --git a/src/serial.c b/src/serial.c
new file mode 100644
index 0000000000000000000000000000000000000000..ab02e0f5a4eb458acf82d82df7410930d60ba64f
--- /dev/null
+++ b/src/serial.c
@@ -0,0 +1,277 @@
+// serial.c
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.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;
+
+ 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;
+}
+
+
+
+// main() driver
+int main() {
+ // Time.
+ clock_t t;
+ t = clock();
+
+ 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));
+ 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);
+ arr_mat[i] = convolution(&kernel, &arr_mat[i]);
+ arr_range[i] = get_matrix_datarange(&