diff --git a/README.md b/README.md
index e9609977b58af00d2e2d247affdfe1d9710e30a5..198a1bc838b37ba92aebc2b43413ff74766ba4f5 100644
--- a/README.md
+++ b/README.md
@@ -1,21 +1,44 @@
# Cara Kerja Program
-Jelaskan cara kerja program Anda, terutama pada paralelisasi dengan CUDA yang Anda implementasikan berdasarkan skema di atas.
-# Perbandingan dan Analisis
-| Jenis Program | Waktu Eksekusi Terbaik (Detik)|
-| ----------- | ----------- |
-| Serial| |
-| Paralel| |
+Program akan menerima seluruh input matriks target dan matriks kernel, setelah itu, fungsi CUDA akan dijalankan yang berfungsi mengalokasikan array of matrix target, matrix kernel kedalam GPU, lalu array matrix target dan matrix target tersebut akan dicopy kedalam GPU. Setelah itu fungsi konvolusi matriks akan dijalankan, skema yang paralelisasi yang digunakan adalah multiple block dan multiple thread dengan pembagian 1 block untuk minimal 1 perhitungan matriks kernel dan 1 matrix target, dengan pembagian thread untuk minimal 1 perhitungan konvolusi untuk setiap sub-matrix yang ada. Ketika jumlah matriks target melebihi jumlah blok, maka matriks tersebut akan dialokasikan sesuai dengan block yang ada (jika sudah sampai block terakhir, matriks tersebut akan diprogram pada block pertama), hal berikut juga sama dengan thread.
-Analisis mengapa waktu eksekusi program Anda bisa lebih lambat / lebih cepat / sama saja. Lalu simpulkan bagaimana CUDA memengaruhi waktu eksekusi program Anda. Buktikan dengan menunjukkan waktu eksekusi yang diperlukan saat demo.
+Setelah fungsi konvolusi dijalankan, akan dihasilkan suatu array of matrix yang berisikan matrix yang sudah dikonvolusi. Array of matrix tersebut akan dimasukan pada fungsi getDataRangeArray, untuk mengembalikan array yang berisikan data range dari setiap matriks konvolusi yang ada. Skema paralelisasi yang digunakan adalah 1 block, dengan multiple thread (1 Dimensi), 1 thread akan meng-handle minimal 1 pencarian data range dari 1 matriks konvolusi.
+Setelah fungsi getDataRangeArray dijalankan, akan dihasilkan suatu array of integer yang berisikan data range dari setiap matrix konvolusi, setelah itu akan dilakukan merge sort. Skema paralelisasi yang digunakan adalah 1 block dan multiple thread, dengan pembagian setiap thread akan mendapatkan minimal 2 elemen, dan akan terus dilakukan merge array (2 sorted array), hingga seluruh elemen ada dalam pada 1 array (sorted).
+
+Langkah terakhir lakukan copy kembali data hasil merge sort dari GPU kedalam CPU, setelah itu lakukan free() terhadap variabel variabel yang sudah tidak lagi digunakan untuk meningkatkan efektivitas memori.
+
+# Perbandingan dan Analisis
+
+| Test Case | Waktu Terbaik Serial (detik) | Waktu Terbaik Paralel (detik) |
+| --------- | ---------------------------- | ----------------------------- |
+| TC1 | 0.010470 | 0.134379 |
+| TC2 | 0.823485 | 0.501233 |
+| TC3 | 0.833403 | 0.612360 |
+| TC4 | 10.478817 | 3.792444 |
+
+Dapat dilihat dari hasil di atas bahwa program paralel lebih cepat dari program serial untuk semua test case kecuali TC1. Ini dikarenakan program paralel dapat melakukan berbagai perhitungan sekaligus, sehingga secara teori waktu eksekusinya harusnya lebih cepat dari program serial. Namun, perlu diperhatikan juga pada program paralel dibutuhkan waktu untuk komunikasi, transfer data antar mesin, dan biaya lainnya yang muncul akibat paralelisasi. Ini membuat perbedaan waktu antara program serial dan paralel tidak begitu signifikan sampai jumlah data yang harus diolah itu cukup besar sehingga paralelisasi dari program paralel dapat memberikan waktu eksekusi yang lebih cepat secara signifikan.
+
+Dapat dilihat dari tabel di atas, untuk testcase dengan data yang sedikit yaitu TC1, waktu eksekusi secara serial lebih cepat, sementara pada data dalam jumlah besar yaitu TC4, eksekusi secara paralel jauh lebih cepat.
# Perbedaan Hasil Serial dan Paralel
-Hasil eksekusi program serial dan paralel memiliki hasil keluaran yang sama. Yang berbeda adalah waktu yang dibutuhkan untuk eksekusi program serial dan paralel.
+
+Hasil eksekusi program serial dan paralel seharusnya memiliki hasil keluaran yang sama. Yang berbeda adalah waktu yang dibutuhkan untuk eksekusi program serial dan paralel. Perbedaan waktu ini diakibatkan perbedaan cara eksekusi program serial dan paralel, namun perbedaan ini seharusnya tidak akan mengakibatkan perbedaan hasil keluaran.
# Perhitungan Waktu Eksekusi Untuk Beberapa Kasus
-| Jumlah Matrix | Ukuran Kernel | Ukuran Matrix | Waktu Eksekusi (Detik) |
-| ----------- | ----------- | ----------- | ----------- |
-| 1000 | 1x1 | 1x1 | |
-| 1 | 1x1 | 100x100 | |
-| 1 | 100x100 | 100x100 | |
+
+| Jumlah Matrix | Ukuran Kernel | Ukuran Matrix | Waktu Eksekusi (Detik) |
+| ------------- | ------------- | ------------- | ---------------------- |
+| 10000 | 1x1 | 1x1 | 0.154368 |
+| 1 | 1x1 | 100x100 | 0.124067 |
+| 1 | 100x100 | 100x100 | 0.141902 |
+
+Pada kasus pertama, skema paralelisasi yang digunakan hanya pada block, dikarenakan karena ukuran matrix dan kernal 1x1, maka setiap block hanya akan digunakan 1 thread saja.
+
+Pada kasus kedua, skema paralelisasi yang digunakan hanya pada thread, dikarenakan jumlah matrixnya hanya 1, maka 1 matrix tersebut akan dihandle pada 1 block.
+
+Pada kasus ketiga, tidak ada skema paralelisasi yang digunakan, dikarenakan pembagian 1 block untuk 1 matrix, dan 1 thread untuk 1 perhitungan konvolusi (Hasil Matrix konvolusi berukuran 1x1). Maka dari itu kasus ketiga dijalankan secara serial.
+
+Dari ketiga kasus tersebut, dapat dilihat kasus kedua memiliki waktu yang tercepat, dikarenakan jumlah thread yang digunakan merupakan thread 2D, sehingga jika jumlah thread yang di-input adalah 16, maka thread yang digunakan dalam skema paralelisasi adalah 16x16 = 256 Thread.
+
+Tentunya waktu eksekusi dari program juga tidak konstan dan dapat berubah pada setiap eksekusi tergantung banyak faktor di luar kode dan input. Sehingga waktu yang ditampilkan di sini hanya merupakan gambaran dari waktu eksekusi secara umum dan urutan waktu kecepatannya dapat berbeda saat eksekusi lain.
diff --git a/result/K02-07-TC1-Paralel.txt b/result/K02-07-TC1-Paralel.txt
new file mode 100644
index 0000000000000000000000000000000000000000..80ec4b7c76b6c637e7ccaab8ff894ef73423ae61
--- /dev/null
+++ b/result/K02-07-TC1-Paralel.txt
@@ -0,0 +1,5 @@
+MIN : 8798239
+MAX : 11538791
+MEDIAN : 9652033
+AVERAGE : 9793375
+Time taken (second): 0.134379
\ No newline at end of file
diff --git a/result/K02-07-TC1-Serial.txt b/result/K02-07-TC1-Serial.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bd653e1fb8f4906ed4a6c0c982eb87a451d692aa
--- /dev/null
+++ b/result/K02-07-TC1-Serial.txt
@@ -0,0 +1,6 @@
+8798239
+11538791
+9652033
+9793375
+
+Exec time: 0.010470
\ No newline at end of file
diff --git a/result/K02-07-TC2-Paralel.txt b/result/K02-07-TC2-Paralel.txt
new file mode 100644
index 0000000000000000000000000000000000000000..35aa6d71df89a75627846eb1543430b013c6f8ab
--- /dev/null
+++ b/result/K02-07-TC2-Paralel.txt
@@ -0,0 +1,5 @@
+MIN : 30656756
+MAX : 39695818
+MEDIAN : 34432914
+AVERAGE : 34677488
+Time taken (second): 0.501233
\ No newline at end of file
diff --git a/result/K02-07-TC2-Serial.txt b/result/K02-07-TC2-Serial.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a1fc2e629b2c0e7b531dc3bf9be96e91900bff2b
--- /dev/null
+++ b/result/K02-07-TC2-Serial.txt
@@ -0,0 +1,6 @@
+30656756
+39695818
+34432914
+34677488
+
+Exec time: 0.823485
\ No newline at end of file
diff --git a/result/K02-07-TC3-Paralel.txt b/result/K02-07-TC3-Paralel.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7cf71bdc14c32e370716583701322c802128f045
--- /dev/null
+++ b/result/K02-07-TC3-Paralel.txt
@@ -0,0 +1,5 @@
+MIN : 18311228
+MAX : 28481918
+MEDIAN : 21846445
+AVERAGE : 22036559
+Time taken (second): 0.612360
\ No newline at end of file
diff --git a/result/K02-07-TC3-Serial.txt b/result/K02-07-TC3-Serial.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a89cbbdfb311b3fab3b1d95222f0d50883a77aea
--- /dev/null
+++ b/result/K02-07-TC3-Serial.txt
@@ -0,0 +1,6 @@
+18311228
+28481918
+21846445
+22036559
+
+Exec time: 0.833403
\ No newline at end of file
diff --git a/result/K02-07-TC4-Paralel.txt b/result/K02-07-TC4-Paralel.txt
new file mode 100644
index 0000000000000000000000000000000000000000..62e360cf91917c1de4e4a95fc3e2552fa0be4cc2
--- /dev/null
+++ b/result/K02-07-TC4-Paralel.txt
@@ -0,0 +1,5 @@
+MIN : 38812931
+MAX : 69918782
+MEDIAN : 49136317
+AVERAGE : 49528074
+Time taken (second): 3.792444
\ No newline at end of file
diff --git a/result/K02-07-TC4-Serial.txt b/result/K02-07-TC4-Serial.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ce9d459c95ffcb0e438034e3cf6ae541c6ec561a
--- /dev/null
+++ b/result/K02-07-TC4-Serial.txt
@@ -0,0 +1,6 @@
+38812931
+69918782
+49136317
+49528074
+
+Exec time: 10.478817
\ No newline at end of file
diff --git a/src/cuda.cu b/src/cuda.cu
index 3b1a043ca2360978a4344c836c95a6a7b2718234..a85cbaa0cb5ffdf2dfb7c7027ddc23adecd0bc48 100644
--- a/src/cuda.cu
+++ b/src/cuda.cu
@@ -258,7 +258,7 @@ int main(int argc, char **argv){
scanf("%d %d %d", &num_targets, &rowB, &colB);
// INISIASI ARRAY/MATRIX
- printf("%d %d %d\n", num_targets, rowB, colB);
+ // printf("%d %d %d\n", num_targets, rowB, colB);
int *b = (int *)malloc(num_targets*rowB*colB * sizeof(int));
// INPUT MATRIX TARGET
for (int k = 0; k < num_targets ; k++){
@@ -271,18 +271,11 @@ int main(int argc, char **argv){
}
}
- // int rowC = rowB-rowA + 1;
- // int colC = colB-colA + 1;
- // int c[num_targets][rowC*colC] = { 0 };
int c[num_targets];
convolutionWithCUDA(c, a, b, rowA,colA,rowB,colB,num_targets,block_num,thread_num);
free(b);
- // convolution(c,a,b[0],rowA,colA,rowB,colB);
- // print_matrix(c[0],rowC,colC);
- // print_matrix(c[1],rowC,colC);
- // print_matrix(c[2],rowC,colC);
- print_array(c,num_targets);
+ // print_array(c,num_targets);
printf("\n");
printf("MIN : %d \n",c[0]);
printf("MAX : %d \n",c[num_targets-1]);