From 2d1313b6cd6f3f3707c77c7ef65343792c9a8020 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Wed, 13 Sep 2017 14:40:53 -0400
Subject: [PATCH 01/27] CPU functions

---
 stream_compaction/cpu.cu   | 57 ++++++++++++++++++++++++++++++++------
 stream_compaction/naive.cu | 29 +++++++++++++++----
 2 files changed, 72 insertions(+), 14 deletions(-)

diff --git a/stream_compaction/cpu.cu b/stream_compaction/cpu.cu
index 05ce667..c47c2ef 100644
--- a/stream_compaction/cpu.cu
+++ b/stream_compaction/cpu.cu
@@ -1,15 +1,15 @@
 #include <cstdio>
 #include "cpu.h"
 
-#include "common.h"
+#include "common.h"
 
 namespace StreamCompaction {
     namespace CPU {
-        using StreamCompaction::Common::PerformanceTimer;
-        PerformanceTimer& timer()
-        {
-	        static PerformanceTimer timer;
-	        return timer;
+        using StreamCompaction::Common::PerformanceTimer;
+        PerformanceTimer& timer()
+        {
+	        static PerformanceTimer timer;
+	        return timer;
         }
 
         /**
@@ -19,7 +19,14 @@ namespace StreamCompaction {
          */
         void scan(int n, int *odata, const int *idata) {
 	        timer().startCpuTimer();
+
             // TODO
+			int sum = 0;
+			for (int i = 0; i < n; ++i ) {
+				odata[i] = sum;
+				sum += idata[i];
+			}
+			
 	        timer().endCpuTimer();
         }
 
@@ -30,9 +37,19 @@ namespace StreamCompaction {
          */
         int compactWithoutScan(int n, int *odata, const int *idata) {
 	        timer().startCpuTimer();
+
             // TODO
+			int num = 0;
+			for (int i = 0; i < n; ++i) {
+				int val = idata[i];
+				if (val != 0) {
+					odata[num] = val;
+					num++;
+				}
+			}
+
 	        timer().endCpuTimer();
-            return -1;
+            return num;
         }
 
         /**
@@ -43,8 +60,32 @@ namespace StreamCompaction {
         int compactWithScan(int n, int *odata, const int *idata) {
 	        timer().startCpuTimer();
 	        // TODO
+
+			int* temp = new int[n];
+			int num = 0;
+			// compute temporary array
+			for (int i = 0; i < n; ++i) {
+				temp[i] = (idata[i] == 0) ? 0 : 1;
+			}
+			// run exclusive scan on temporary array
+			int sum = 0;
+			for (int i = 0; i < n; ++i) {
+				int val = temp[i];
+				temp[i] = sum;
+				sum += val;
+			}
+
+			// scatter
+			for (int i = 1; i < n; ++i) {
+				if (temp[i] != temp[i-1]) {
+					odata[num] = idata[i - 1];
+					num++;
+				}
+			}
+
+			delete[] temp;
 	        timer().endCpuTimer();
-            return -1;
+            return num;
         }
     }
 }
diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu
index 9218f8e..698170e 100644
--- a/stream_compaction/naive.cu
+++ b/stream_compaction/naive.cu
@@ -5,20 +5,37 @@
 
 namespace StreamCompaction {
     namespace Naive {
-        using StreamCompaction::Common::PerformanceTimer;
-        PerformanceTimer& timer()
-        {
-            static PerformanceTimer timer;
-            return timer;
+        using StreamCompaction::Common::PerformanceTimer;
+        PerformanceTimer& timer()
+        {
+            static PerformanceTimer timer;
+            return timer;
         }
-        // TODO: __global__
+        // TODO
+		__global__ void kernNaiveScan(int n, int d, int *odata, const int *idata) 
+		{
+			int index = threadIdx.x;
+			if (index >= n) return;
+
+			int val = 1 << (d - 1);
+			for (int k = val; k < n; ++k) {
+				odata[k] = odata[k] + odata[k - val];
+			}
+		}
 
         /**
          * Performs prefix-sum (aka scan) on idata, storing the result into odata.
          */
         void scan(int n, int *odata, const int *idata) {
             timer().startGpuTimer();
+
             // TODO
+			for (int i = 0; i < n; ++i) odata[i] = idata[i];
+			for (int d = 1; d < ilog2ceil(n); ++d) {
+				kernNaiveScan << <1, n >> > (n, d, odata, idata);
+			}
+			checkCUDAError("kernComputeIndices failed!");
+
             timer().endGpuTimer();
         }
     }

From 916ed397c6b3dbcda9c5e7d92c4d14a039a7ba16 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Wed, 13 Sep 2017 15:52:02 -0400
Subject: [PATCH 02/27] kernel compiles but wrong

---
 src/main.cpp               |  6 +++---
 stream_compaction/naive.cu | 40 +++++++++++++++++++++++++++++---------
 2 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index 7305641..37df638 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -36,7 +36,7 @@ int main(int argc, char* argv[]) {
     printDesc("cpu scan, power-of-two");
     StreamCompaction::CPU::scan(SIZE, b, a);
     printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(SIZE, b, true);
+    printArray(SIZE, b, false);
 
     zeroArray(SIZE, c);
     printDesc("cpu scan, non-power-of-two");
@@ -49,7 +49,7 @@ int main(int argc, char* argv[]) {
     printDesc("naive scan, power-of-two");
     StreamCompaction::Naive::scan(SIZE, c, a);
     printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(SIZE, c, true);
+    printArray(SIZE, c, false);
     printCmpResult(SIZE, b, c);
 
     zeroArray(SIZE, c);
@@ -129,7 +129,7 @@ int main(int argc, char* argv[]) {
     printDesc("work-efficient compact, power-of-two");
     count = StreamCompaction::Efficient::compact(SIZE, c, a);
     printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(count, c, true);
+    printArray(count, c, true);
     printCmpLenResult(count, expectedCount, b, c);
 
     zeroArray(SIZE, c);
diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu
index 698170e..44a16a6 100644
--- a/stream_compaction/naive.cu
+++ b/stream_compaction/naive.cu
@@ -3,6 +3,8 @@
 #include "common.h"
 #include "naive.h"
 
+#define blockSize 128
+
 namespace StreamCompaction {
     namespace Naive {
         using StreamCompaction::Common::PerformanceTimer;
@@ -12,15 +14,12 @@ namespace StreamCompaction {
             return timer;
         }
         // TODO
-		__global__ void kernNaiveScan(int n, int d, int *odata, const int *idata) 
+		__global__ void kernNaiveScan(int n, int val, int *odata, int *idata) 
 		{
-			int index = threadIdx.x;
+			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
 			if (index >= n) return;
 
-			int val = 1 << (d - 1);
-			for (int k = val; k < n; ++k) {
-				odata[k] = odata[k] + odata[k - val];
-			}
+			odata[index] = (n >= val) ? idata[index] + idata[index - val] : idata[index];
 		}
 
         /**
@@ -30,11 +29,34 @@ namespace StreamCompaction {
             timer().startGpuTimer();
 
             // TODO
-			for (int i = 0; i < n; ++i) odata[i] = idata[i];
+			int *dev_in;
+			int *dev_out;
+
+			dim3 blocksPerGrid((n + blockSize - 1) / blockSize);
+
+			cudaMalloc((void**)&dev_in, n * sizeof(int));
+			checkCUDAError("cudaMalloc dev_in failed!");
+
+			cudaMalloc((void**)&dev_out, n * sizeof(int));
+			checkCUDAError("cudaMalloc dev_in failed!");
+
+			cudaMemcpy(dev_in, idata, n * sizeof(int), cudaMemcpyHostToDevice);
+			checkCUDAError("cudaMemcpy dev_in failed!");
+			cudaMemcpy(dev_out, odata, n * sizeof(int), cudaMemcpyHostToDevice);
+			checkCUDAError("cudaMemcpy dev_out failed!");
+
 			for (int d = 1; d < ilog2ceil(n); ++d) {
-				kernNaiveScan << <1, n >> > (n, d, odata, idata);
+				int val = 1 << (d - 1);
+				kernNaiveScan << <blocksPerGrid, blockSize >> > (n, val, dev_out, dev_in);
+				std::swap(dev_in, dev_out);
+				checkCUDAError("kernNaiveScan failed!");
 			}
-			checkCUDAError("kernComputeIndices failed!");
+
+			cudaMemcpy(odata, dev_in, n * sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+
+			cudaFree(dev_in);
+			cudaFree(dev_out);
 
             timer().endGpuTimer();
         }

From 1630006d91155a9a1d490ff101503b4400aaea51 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Thu, 14 Sep 2017 15:45:12 -0400
Subject: [PATCH 03/27] work efficient scan

---
 CMakeLists.txt                   |  1 +
 src/main.cpp                     | 24 +++++----
 stream_compaction/CMakeLists.txt |  4 +-
 stream_compaction/cpu.cu         |  7 +--
 stream_compaction/efficient.cu   | 84 ++++++++++++++++++++++++++++----
 stream_compaction/naive.cu       | 15 +++---
 6 files changed, 103 insertions(+), 32 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 16abe08..a51d998 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,6 +9,7 @@ set(CMAKE_CXX_STANDARD 11)
 
 list(APPEND CUDA_NVCC_FLAGS_DEBUG -G -g)
 list(APPEND CUDA_NVCC_FLAGS_RELWITHDEBUGINFO -lineinfo)
+list(APPEND CUDA_NVCC_FLAGS -gencode arch=compute_60,code=sm_60)
 
 # Crucial magic for CUDA linking
 find_package(Threads REQUIRED)
diff --git a/src/main.cpp b/src/main.cpp
index 37df638..f51985c 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -13,7 +13,8 @@
 #include <stream_compaction/thrust.h>
 #include "testing_helpers.hpp"
 
-const int SIZE = 1 << 8; // feel free to change the size of array
+//const int SIZE = 1 << 8; // feel free to change the size of array
+const int SIZE = 1 << 3;
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 int a[SIZE], b[SIZE], c[SIZE];
 
@@ -25,8 +26,11 @@ int main(int argc, char* argv[]) {
     printf("** SCAN TESTS **\n");
     printf("****************\n");
 
-    genArray(SIZE - 1, a, 50);  // Leave a 0 at the end to test that edge case
-    a[SIZE - 1] = 0;
+    //genArray(SIZE - 1, a, 50);  // Leave a 0 at the end to test that edge case
+    //a[SIZE - 1] = 0;
+
+	for (int i = 0; i < SIZE; ++i) a[i] = i;
+
     printArray(SIZE, a, true);
 
     // initialize b using StreamCompaction::CPU::scan you implement
@@ -36,7 +40,7 @@ int main(int argc, char* argv[]) {
     printDesc("cpu scan, power-of-two");
     StreamCompaction::CPU::scan(SIZE, b, a);
     printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(SIZE, b, false);
+    printArray(SIZE, b, true);
 
     zeroArray(SIZE, c);
     printDesc("cpu scan, non-power-of-two");
@@ -49,42 +53,42 @@ int main(int argc, char* argv[]) {
     printDesc("naive scan, power-of-two");
     StreamCompaction::Naive::scan(SIZE, c, a);
     printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, c, false);
+    printArray(SIZE, c, true);
     printCmpResult(SIZE, b, c);
 
     zeroArray(SIZE, c);
     printDesc("naive scan, non-power-of-two");
     StreamCompaction::Naive::scan(NPOT, c, a);
     printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(SIZE, c, true);
+    printArray(NPOT, c, true);
     printCmpResult(NPOT, b, c);
 
     zeroArray(SIZE, c);
     printDesc("work-efficient scan, power-of-two");
     StreamCompaction::Efficient::scan(SIZE, c, a);
     printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(SIZE, c, true);
+    printArray(SIZE, c, true);
     printCmpResult(SIZE, b, c);
 
     zeroArray(SIZE, c);
     printDesc("work-efficient scan, non-power-of-two");
     StreamCompaction::Efficient::scan(NPOT, c, a);
     printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(NPOT, c, true);
+    printArray(NPOT, c, true);
     printCmpResult(NPOT, b, c);
 
     zeroArray(SIZE, c);
     printDesc("thrust scan, power-of-two");
     StreamCompaction::Thrust::scan(SIZE, c, a);
     printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(SIZE, c, true);
+    printArray(SIZE, c, true);
     printCmpResult(SIZE, b, c);
 
     zeroArray(SIZE, c);
     printDesc("thrust scan, non-power-of-two");
     StreamCompaction::Thrust::scan(NPOT, c, a);
     printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(NPOT, c, true);
+    printArray(NPOT, c, true);
     printCmpResult(NPOT, b, c);
 
     printf("\n");
diff --git a/stream_compaction/CMakeLists.txt b/stream_compaction/CMakeLists.txt
index cdbef77..595d731 100644
--- a/stream_compaction/CMakeLists.txt
+++ b/stream_compaction/CMakeLists.txt
@@ -13,5 +13,5 @@ set(SOURCE_FILES
 
 cuda_add_library(stream_compaction
     ${SOURCE_FILES}
-    OPTIONS -arch=sm_20
-    )
+    OPTIONS -arch=sm_60
+    )
\ No newline at end of file
diff --git a/stream_compaction/cpu.cu b/stream_compaction/cpu.cu
index c47c2ef..c107c81 100644
--- a/stream_compaction/cpu.cu
+++ b/stream_compaction/cpu.cu
@@ -61,7 +61,8 @@ namespace StreamCompaction {
 	        timer().startCpuTimer();
 	        // TODO
 
-			int* temp = new int[n];
+			int* temp = new int[n + 1];
+			temp[n] = 0;
 			int num = 0;
 			// compute temporary array
 			for (int i = 0; i < n; ++i) {
@@ -69,14 +70,14 @@ namespace StreamCompaction {
 			}
 			// run exclusive scan on temporary array
 			int sum = 0;
-			for (int i = 0; i < n; ++i) {
+			for (int i = 0; i <= n; ++i) {
 				int val = temp[i];
 				temp[i] = sum;
 				sum += val;
 			}
 
 			// scatter
-			for (int i = 1; i < n; ++i) {
+			for (int i = 1; i <= n; ++i) {
 				if (temp[i] != temp[i-1]) {
 					odata[num] = idata[i - 1];
 					num++;
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index 36c5ef2..2a49784 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -3,22 +3,88 @@
 #include "common.h"
 #include "efficient.h"
 
+#define blockSize 128
+
 namespace StreamCompaction {
     namespace Efficient {
-        using StreamCompaction::Common::PerformanceTimer;
-        PerformanceTimer& timer()
-        {
-            static PerformanceTimer timer;
-            return timer;
+        using StreamCompaction::Common::PerformanceTimer;
+        PerformanceTimer& timer()
+        {
+            static PerformanceTimer timer;
+            return timer;
         }
 
+		__global__ void kernZeroed(int totalN, int n, int *odata)
+		{
+			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+			if (index >= totalN) return;
+
+			odata[index] = (index < n) ? odata[index] : 0;
+		}
+
+		__global__ void kernUpSweep(int n, int d, int *odata) 
+		{
+			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+			if (index >= n) return;
+
+			int offset = 1 << (d + 1);
+			int i = (index + 1) * offset - 1;
+
+			int val = 1 << d;
+			odata[i] += odata[i - val];
+			if (i == n - 1) odata[i] = 0;
+		}
+
+		__global__ void kernDownSweep(int n, int d, int *odata)
+		{
+			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+			if (index >= n) return;
+
+			int i = index + 1;
+			int val = 1 << d;
+			int offset = 1 << (d + 1);
+			int temp = odata[i * offset - 1];
+			odata[i * offset - 1] += odata[i * offset - val - 1];
+			odata[i * offset - val - 1] = temp;
+		}
+
         /**
          * Performs prefix-sum (aka scan) on idata, storing the result into odata.
          */
-        void scan(int n, int *odata, const int *idata) {
-            timer().startGpuTimer();
-            // TODO
-            timer().endGpuTimer();
+        void scan(int n, int *odata, const int *idata) 
+		{
+			int *dev_out;
+			int pow2n = 1 << ilog2ceil(n);
+
+			cudaMalloc((void**)&dev_out, pow2n * sizeof(int));
+			checkCUDAError("cudaMalloc dev_out failed!");
+
+			cudaMemcpy(dev_out, idata, pow2n * sizeof(int), cudaMemcpyHostToDevice);
+			checkCUDAError("cudaMemcpy dev_out failed!");
+
+			timer().startGpuTimer();
+			dim3 blocksPerGrid((pow2n + blockSize - 1) / blockSize);
+			kernZeroed << <blocksPerGrid, blockSize >> > (pow2n, n, dev_out);
+			checkCUDAError("kernZeroed failed!");
+
+			for (int d = 0; d < ilog2ceil(pow2n); ++d) {
+				dim3 blocksPerGrid((pow2n /(1 << (d + 1)) + blockSize - 1) / blockSize);
+				kernUpSweep << <blocksPerGrid, blockSize >> > (pow2n, d, dev_out);
+				checkCUDAError("kernUpSweep failed!");
+			}
+
+			for (int d = ilog2ceil(pow2n) - 1; d >= 0; --d) {
+				dim3 blocksPerGrid((pow2n / (1 << (d + 1)) + blockSize - 1) / blockSize);
+				kernDownSweep << <blocksPerGrid, blockSize >> > (pow2n, d, dev_out);
+				checkCUDAError("kernDownSweep failed!");
+			}
+
+			timer().endGpuTimer();
+
+			cudaMemcpy(odata, dev_out, n * sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+
+			cudaFree(dev_out);
         }
 
         /**
diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu
index 44a16a6..252a718 100644
--- a/stream_compaction/naive.cu
+++ b/stream_compaction/naive.cu
@@ -18,16 +18,14 @@ namespace StreamCompaction {
 		{
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
 			if (index >= n) return;
-
-			odata[index] = (n >= val) ? idata[index] + idata[index - val] : idata[index];
+			odata[index] = (index >= val) ? idata[index] + idata[index - val] : idata[index];
 		}
 
         /**
          * Performs prefix-sum (aka scan) on idata, storing the result into odata.
          */
         void scan(int n, int *odata, const int *idata) {
-            timer().startGpuTimer();
-
+            
             // TODO
 			int *dev_in;
 			int *dev_out;
@@ -45,20 +43,21 @@ namespace StreamCompaction {
 			cudaMemcpy(dev_out, odata, n * sizeof(int), cudaMemcpyHostToDevice);
 			checkCUDAError("cudaMemcpy dev_out failed!");
 
-			for (int d = 1; d < ilog2ceil(n); ++d) {
+			timer().startGpuTimer();
+			for (int d = 1; d <= ilog2ceil(n); ++d) {
 				int val = 1 << (d - 1);
 				kernNaiveScan << <blocksPerGrid, blockSize >> > (n, val, dev_out, dev_in);
 				std::swap(dev_in, dev_out);
 				checkCUDAError("kernNaiveScan failed!");
 			}
 
-			cudaMemcpy(odata, dev_in, n * sizeof(int), cudaMemcpyDeviceToHost);
+			timer().endGpuTimer();
+
+			cudaMemcpy(odata + 1, dev_in, n * sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");
 
 			cudaFree(dev_in);
 			cudaFree(dev_out);
-
-            timer().endGpuTimer();
         }
     }
 }

From 705bd52241c157156d7d90e2073d461cf79c5a03 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Thu, 14 Sep 2017 16:38:08 -0400
Subject: [PATCH 04/27] scatter

---
 src/main.cpp                   |  2 +-
 stream_compaction/common.cu    | 10 ++++++++++
 stream_compaction/efficient.cu | 36 ++++++++++++++++++++++++++++++----
 stream_compaction/thrust.cu    | 34 ++++++++++++++++++++++++++------
 4 files changed, 71 insertions(+), 11 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index f51985c..2f11606 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -140,7 +140,7 @@ int main(int argc, char* argv[]) {
     printDesc("work-efficient compact, non-power-of-two");
     count = StreamCompaction::Efficient::compact(NPOT, c, a);
     printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(count, c, true);
+    printArray(count, c, true);
     printCmpLenResult(count, expectedNPOT, b, c);
 
     system("pause"); // stop Win32 console from closing on exit
diff --git a/stream_compaction/common.cu b/stream_compaction/common.cu
index 8fc0211..a66ea91 100644
--- a/stream_compaction/common.cu
+++ b/stream_compaction/common.cu
@@ -24,6 +24,10 @@ namespace StreamCompaction {
          */
         __global__ void kernMapToBoolean(int n, int *bools, const int *idata) {
             // TODO
+			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+			if (index >= n) return;
+
+			bools[index] = (idata[index] != 0 || index == n - 1) ? 1 : 0;
         }
 
         /**
@@ -33,6 +37,12 @@ namespace StreamCompaction {
         __global__ void kernScatter(int n, int *odata,
                 const int *idata, const int *bools, const int *indices) {
             // TODO
+			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+			if (index >= n) return;
+
+			if (bools[index] == 1) {
+				odata[indices[index]] = idata[index];
+			}
         }
 
     }
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index 2a49784..d22624b 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -96,10 +96,38 @@ namespace StreamCompaction {
          * @param idata  The array of elements to compact.
          * @returns      The number of elements remaining after compaction.
          */
-        int compact(int n, int *odata, const int *idata) {
-            timer().startGpuTimer();
-            // TODO
-            timer().endGpuTimer();
+        int compact(int n, int *odata, const int *idata) 
+		{
+			// TODO
+			int *bools;
+			int *dev_in;
+
+			cudaMalloc((void**)&bools, (n + 1) * sizeof(int));
+			checkCUDAError("cudaMalloc bools failed!");
+
+			cudaMalloc((void**)&dev_in, (n + 1) * sizeof(int));
+			checkCUDAError("cudaMalloc dev_in failed!");
+
+			cudaMemcpy(dev_in, idata, (n + 1) * sizeof(int), cudaMemcpyHostToDevice);
+			checkCUDAError("cudaMemcpy dev_in failed!");
+
+			timer().startGpuTimer();
+
+			dim3 blocksPerGrid((n + blockSize) / blockSize);
+			StreamCompaction::Common::kernMapToBoolean << <blocksPerGrid, blockSize >> > (n+1, bools, dev_in);
+			checkCUDAError("kernMapToBoolean failed!");
+
+			/*scan(n + 1, odata, bools);
+
+			dim3 blocksPerGrid((n + blockSize) / blockSize);
+			StreamCompaction::Common::kernScatter << <blocksPerGrid, blockSize >> > (n + 1, odata, idata, bools, indices);
+			checkCUDAError("kernScatter failed!");*/
+
+			timer().endGpuTimer();
+
+			cudaMemcpy(odata, dev_in, n * sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+            
             return -1;
         }
     }
diff --git a/stream_compaction/thrust.cu b/stream_compaction/thrust.cu
index 36b732d..351b8dd 100644
--- a/stream_compaction/thrust.cu
+++ b/stream_compaction/thrust.cu
@@ -8,21 +8,43 @@
 
 namespace StreamCompaction {
     namespace Thrust {
-        using StreamCompaction::Common::PerformanceTimer;
-        PerformanceTimer& timer()
-        {
-            static PerformanceTimer timer;
-            return timer;
+        using StreamCompaction::Common::PerformanceTimer;
+        PerformanceTimer& timer()
+        {
+            static PerformanceTimer timer;
+            return timer;
         }
         /**
          * Performs prefix-sum (aka scan) on idata, storing the result into odata.
          */
         void scan(int n, int *odata, const int *idata) {
+
+			int *dev_in;
+			int *dev_out;
+
+			cudaMalloc((void**)&dev_in, n * sizeof(int));
+			checkCUDAError("cudaMalloc dev_in failed!");
+
+			cudaMalloc((void**)&dev_out, n * sizeof(int));
+			checkCUDAError("cudaMalloc dev_out failed!");
+
+			cudaMemcpy(dev_in, idata, n * sizeof(int), cudaMemcpyHostToDevice);
+			checkCUDAError("cudaMemcpy dev_in failed!");
+
+			cudaMemcpy(dev_out, odata, n * sizeof(int), cudaMemcpyHostToDevice);
+			checkCUDAError("cudaMemcpy dev_in failed!");
+
             timer().startGpuTimer();
             // TODO use `thrust::exclusive_scan`
             // example: for device_vectors dv_in and dv_out:
             // thrust::exclusive_scan(dv_in.begin(), dv_in.end(), dv_out.begin());
-            timer().endGpuTimer();
+			thrust::exclusive_scan(dev_in, dev_in + n, dev_out);
+
+			timer().endGpuTimer();
+
+			cudaMemcpy(odata, dev_out, n * sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+
         }
     }
 }

From 861fd8e3cb0282ad8a2c8b041bf7406d9c004013 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Fri, 15 Sep 2017 17:26:21 -0400
Subject: [PATCH 05/27] race conditions?

---
 src/main.cpp                   |  45 ++++----
 stream_compaction/common.cu    |  11 +-
 stream_compaction/common.h     | 200 ++++++++++++++++-----------------
 stream_compaction/cpu.cu       |  22 ++--
 stream_compaction/efficient.cu |  60 ++++++----
 stream_compaction/thrust.cu    |  36 +++---
 6 files changed, 193 insertions(+), 181 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index 2f11606..ea2d683 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -13,8 +13,7 @@
 #include <stream_compaction/thrust.h>
 #include "testing_helpers.hpp"
 
-//const int SIZE = 1 << 8; // feel free to change the size of array
-const int SIZE = 1 << 3;
+const int SIZE = 1 << 5; // feel free to change the size of array
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 int a[SIZE], b[SIZE], c[SIZE];
 
@@ -26,10 +25,8 @@ int main(int argc, char* argv[]) {
     printf("** SCAN TESTS **\n");
     printf("****************\n");
 
-    //genArray(SIZE - 1, a, 50);  // Leave a 0 at the end to test that edge case
-    //a[SIZE - 1] = 0;
-
-	for (int i = 0; i < SIZE; ++i) a[i] = i;
+    genArray(SIZE - 1, a, 50);  // Leave a 0 at the end to test that edge case
+    a[SIZE - 1] = 0;
 
     printArray(SIZE, a, true);
 
@@ -102,46 +99,46 @@ int main(int argc, char* argv[]) {
     a[SIZE - 1] = 0;
     printArray(SIZE, a, true);
 
-    int count, expectedCount, expectedNPOT;
+    int countSIZE, countNPOT, expectedSIZE, expectedNPOT;
 
     // initialize b using StreamCompaction::CPU::compactWithoutScan you implement
     // We use b for further comparison. Make sure your StreamCompaction::CPU::compactWithoutScan is correct.
     zeroArray(SIZE, b);
     printDesc("cpu compact without scan, power-of-two");
-    count = StreamCompaction::CPU::compactWithoutScan(SIZE, b, a);
+    countSIZE = StreamCompaction::CPU::compactWithoutScan(SIZE, b, a);
     printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    expectedCount = count;
-    printArray(count, b, true);
-    printCmpLenResult(count, expectedCount, b, b);
+	expectedSIZE = countSIZE;
+    printArray(expectedSIZE, b, true);
+    printCmpLenResult(countSIZE, expectedSIZE, b, b);
 
     zeroArray(SIZE, c);
     printDesc("cpu compact without scan, non-power-of-two");
-    count = StreamCompaction::CPU::compactWithoutScan(NPOT, c, a);
+	countNPOT = StreamCompaction::CPU::compactWithoutScan(NPOT, c, a);
     printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    expectedNPOT = count;
-    printArray(count, c, true);
-    printCmpLenResult(count, expectedNPOT, b, c);
+    expectedNPOT = countNPOT;
+    printArray(countNPOT, c, true);
+    printCmpLenResult(countNPOT, expectedNPOT, b, c);
 
     zeroArray(SIZE, c);
     printDesc("cpu compact with scan");
-    count = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
+	countSIZE = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
     printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(count, c, true);
-    printCmpLenResult(count, expectedCount, b, c);
+    printArray(countSIZE, c, true);
+    printCmpLenResult(countSIZE, expectedSIZE, b, c);
 
     zeroArray(SIZE, c);
     printDesc("work-efficient compact, power-of-two");
-    count = StreamCompaction::Efficient::compact(SIZE, c, a);
+	countSIZE = StreamCompaction::Efficient::compact(SIZE, c, a);
     printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(count, c, true);
-    printCmpLenResult(count, expectedCount, b, c);
+    printArray(expectedSIZE, c, true);
+    printCmpLenResult(countSIZE, expectedSIZE, b, c);
 
     zeroArray(SIZE, c);
     printDesc("work-efficient compact, non-power-of-two");
-    count = StreamCompaction::Efficient::compact(NPOT, c, a);
+	countNPOT = StreamCompaction::Efficient::compact(NPOT, c, a);
     printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(count, c, true);
-    printCmpLenResult(count, expectedNPOT, b, c);
+    printArray(expectedNPOT, c, true);
+    printCmpLenResult(countNPOT, expectedNPOT, b, c);
 
     system("pause"); // stop Win32 console from closing on exit
 }
diff --git a/stream_compaction/common.cu b/stream_compaction/common.cu
index a66ea91..2ba70c7 100644
--- a/stream_compaction/common.cu
+++ b/stream_compaction/common.cu
@@ -34,16 +34,15 @@ namespace StreamCompaction {
          * Performs scatter on an array. That is, for each element in idata,
          * if bools[idx] == 1, it copies idata[idx] to odata[indices[idx]].
          */
-        __global__ void kernScatter(int n, int *odata,
-                const int *idata, const int *bools, const int *indices) {
+        __global__ void kernScatter(int n, int *odata, const int *idata, const int *bools) {
             // TODO
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
 			if (index >= n) return;
 
-			if (bools[index] == 1) {
-				odata[indices[index]] = idata[index];
+			int idx = bools[index];
+			if (bools[index + 1] != idx) {
+				odata[idx] = idata[index];
 			}
         }
-
     }
-}
+}
\ No newline at end of file
diff --git a/stream_compaction/common.h b/stream_compaction/common.h
index 55f1b38..9d0a895 100644
--- a/stream_compaction/common.h
+++ b/stream_compaction/common.h
@@ -1,14 +1,14 @@
 #pragma once
 
-#include <cuda.h>
-#include <cuda_runtime.h>
-
-#include <cstdio>
-#include <cstring>
-#include <cmath>
-#include <algorithm>
+#include <cuda.h>
+#include <cuda_runtime.h>
+
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
 #include <chrono>
-#include <stdexcept>
+#include <stdexcept>
 
 #define FILENAME (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
 #define checkCUDAError(msg) checkCUDAErrorFn(msg, FILENAME, __LINE__)
@@ -35,98 +35,98 @@ namespace StreamCompaction {
         __global__ void kernMapToBoolean(int n, int *bools, const int *idata);
 
         __global__ void kernScatter(int n, int *odata,
-                const int *idata, const int *bools, const int *indices);
-
-	    /**
-	    * This class is used for timing the performance
-	    * Uncopyable and unmovable
-        *
-        * Adapted from WindyDarian(https://github.com/WindyDarian)
-	    */
-	    class PerformanceTimer
-	    {
-	    public:
-		    PerformanceTimer()
-		    {
-			    cudaEventCreate(&event_start);
-			    cudaEventCreate(&event_end);
-		    }
-
-		    ~PerformanceTimer()
-		    {
-			    cudaEventDestroy(event_start);
-			    cudaEventDestroy(event_end);
-		    }
-
-		    void startCpuTimer()
-		    {
-			    if (cpu_timer_started) { throw std::runtime_error("CPU timer already started"); }
-			    cpu_timer_started = true;
-
-			    time_start_cpu = std::chrono::high_resolution_clock::now();
-		    }
-
-		    void endCpuTimer()
-		    {
-			    time_end_cpu = std::chrono::high_resolution_clock::now();
-
-			    if (!cpu_timer_started) { throw std::runtime_error("CPU timer not started"); }
-
-			    std::chrono::duration<double, std::milli> duro = time_end_cpu - time_start_cpu;
-			    prev_elapsed_time_cpu_milliseconds =
-				    static_cast<decltype(prev_elapsed_time_cpu_milliseconds)>(duro.count());
-
-			    cpu_timer_started = false;
-		    }
-
-		    void startGpuTimer()
-		    {
-			    if (gpu_timer_started) { throw std::runtime_error("GPU timer already started"); }
-			    gpu_timer_started = true;
-
-			    cudaEventRecord(event_start);
-		    }
-
-		    void endGpuTimer()
-		    {
-			    cudaEventRecord(event_end);
-			    cudaEventSynchronize(event_end);
-
-			    if (!gpu_timer_started) { throw std::runtime_error("GPU timer not started"); }
-
-			    cudaEventElapsedTime(&prev_elapsed_time_gpu_milliseconds, event_start, event_end);
-			    gpu_timer_started = false;
-		    }
-
-		    float getCpuElapsedTimeForPreviousOperation() //noexcept //(damn I need VS 2015
-		    {
-			    return prev_elapsed_time_cpu_milliseconds;
-		    }
-
-		    float getGpuElapsedTimeForPreviousOperation() //noexcept
-		    {
-			    return prev_elapsed_time_gpu_milliseconds;
-		    }
-
-		    // remove copy and move functions
-		    PerformanceTimer(const PerformanceTimer&) = delete;
-		    PerformanceTimer(PerformanceTimer&&) = delete;
-		    PerformanceTimer& operator=(const PerformanceTimer&) = delete;
-		    PerformanceTimer& operator=(PerformanceTimer&&) = delete;
-
-	    private:
-		    cudaEvent_t event_start = nullptr;
-		    cudaEvent_t event_end = nullptr;
-
-		    using time_point_t = std::chrono::high_resolution_clock::time_point;
-		    time_point_t time_start_cpu;
-		    time_point_t time_end_cpu;
-
-		    bool cpu_timer_started = false;
-		    bool gpu_timer_started = false;
-
-		    float prev_elapsed_time_cpu_milliseconds = 0.f;
-		    float prev_elapsed_time_gpu_milliseconds = 0.f;
+                const int *idata, const int *bools);
+
+	    /**
+	    * This class is used for timing the performance
+	    * Uncopyable and unmovable
+        *
+        * Adapted from WindyDarian(https://github.com/WindyDarian)
+	    */
+	    class PerformanceTimer
+	    {
+	    public:
+		    PerformanceTimer()
+		    {
+			    cudaEventCreate(&event_start);
+			    cudaEventCreate(&event_end);
+		    }
+
+		    ~PerformanceTimer()
+		    {
+			    cudaEventDestroy(event_start);
+			    cudaEventDestroy(event_end);
+		    }
+
+		    void startCpuTimer()
+		    {
+			    if (cpu_timer_started) { throw std::runtime_error("CPU timer already started"); }
+			    cpu_timer_started = true;
+
+			    time_start_cpu = std::chrono::high_resolution_clock::now();
+		    }
+
+		    void endCpuTimer()
+		    {
+			    time_end_cpu = std::chrono::high_resolution_clock::now();
+
+			    if (!cpu_timer_started) { throw std::runtime_error("CPU timer not started"); }
+
+			    std::chrono::duration<double, std::milli> duro = time_end_cpu - time_start_cpu;
+			    prev_elapsed_time_cpu_milliseconds =
+				    static_cast<decltype(prev_elapsed_time_cpu_milliseconds)>(duro.count());
+
+			    cpu_timer_started = false;
+		    }
+
+		    void startGpuTimer()
+		    {
+			    if (gpu_timer_started) { throw std::runtime_error("GPU timer already started"); }
+			    gpu_timer_started = true;
+
+			    cudaEventRecord(event_start);
+		    }
+
+		    void endGpuTimer()
+		    {
+			    cudaEventRecord(event_end);
+			    cudaEventSynchronize(event_end);
+
+			    if (!gpu_timer_started) { throw std::runtime_error("GPU timer not started"); }
+
+			    cudaEventElapsedTime(&prev_elapsed_time_gpu_milliseconds, event_start, event_end);
+			    gpu_timer_started = false;
+		    }
+
+		    float getCpuElapsedTimeForPreviousOperation() //noexcept //(damn I need VS 2015
+		    {
+			    return prev_elapsed_time_cpu_milliseconds;
+		    }
+
+		    float getGpuElapsedTimeForPreviousOperation() //noexcept
+		    {
+			    return prev_elapsed_time_gpu_milliseconds;
+		    }
+
+		    // remove copy and move functions
+		    PerformanceTimer(const PerformanceTimer&) = delete;
+		    PerformanceTimer(PerformanceTimer&&) = delete;
+		    PerformanceTimer& operator=(const PerformanceTimer&) = delete;
+		    PerformanceTimer& operator=(PerformanceTimer&&) = delete;
+
+	    private:
+		    cudaEvent_t event_start = nullptr;
+		    cudaEvent_t event_end = nullptr;
+
+		    using time_point_t = std::chrono::high_resolution_clock::time_point;
+		    time_point_t time_start_cpu;
+		    time_point_t time_end_cpu;
+
+		    bool cpu_timer_started = false;
+		    bool gpu_timer_started = false;
+
+		    float prev_elapsed_time_cpu_milliseconds = 0.f;
+		    float prev_elapsed_time_gpu_milliseconds = 0.f;
 	    };
     }
 }
diff --git a/stream_compaction/cpu.cu b/stream_compaction/cpu.cu
index c107c81..dbd5ffd 100644
--- a/stream_compaction/cpu.cu
+++ b/stream_compaction/cpu.cu
@@ -12,21 +12,25 @@ namespace StreamCompaction {
 	        return timer;
         }
 
+		void scan_implementation(int n, int *odata, const int *idata) 
+		{
+			// TODO
+			int sum = 0;
+			for (int i = 0; i < n; ++i) {
+				odata[i] = sum;
+				sum += idata[i];
+			}
+		}
+
         /**
          * CPU scan (prefix sum).
          * For performance analysis, this is supposed to be a simple for loop.
          * (Optional) For better understanding before starting moving to GPU, you can simulate your GPU scan in this function first.
          */
-        void scan(int n, int *odata, const int *idata) {
+        void scan(int n, int *odata, const int *idata)
+		{
 	        timer().startCpuTimer();
-
-            // TODO
-			int sum = 0;
-			for (int i = 0; i < n; ++i ) {
-				odata[i] = sum;
-				sum += idata[i];
-			}
-			
+			scan_implementation(n, odata, idata);
 	        timer().endCpuTimer();
         }
 
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index d22624b..de549e1 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -48,6 +48,23 @@ namespace StreamCompaction {
 			odata[i * offset - val - 1] = temp;
 		}
 
+		void scan_implementation(int n, int *dev_out)
+		{
+			int pow2n = 1 << ilog2ceil(n);
+			
+			for (int d = 0; d < ilog2ceil(pow2n); ++d) {
+				dim3 blocksPerGrid((pow2n / (1 << (d + 1)) + blockSize - 1) / blockSize);
+				kernUpSweep << <blocksPerGrid, blockSize >> > (pow2n, d, dev_out);
+				checkCUDAError("kernUpSweep failed!");
+			}
+
+			for (int d = ilog2ceil(pow2n) - 1; d >= 0; --d) {
+				dim3 blocksPerGrid((pow2n / (1 << (d + 1)) + blockSize - 1) / blockSize);
+				kernDownSweep << <blocksPerGrid, blockSize >> > (pow2n, d, dev_out);
+				checkCUDAError("kernDownSweep failed!");
+			}
+		}
+
         /**
          * Performs prefix-sum (aka scan) on idata, storing the result into odata.
          */
@@ -62,23 +79,12 @@ namespace StreamCompaction {
 			cudaMemcpy(dev_out, idata, pow2n * sizeof(int), cudaMemcpyHostToDevice);
 			checkCUDAError("cudaMemcpy dev_out failed!");
 
-			timer().startGpuTimer();
 			dim3 blocksPerGrid((pow2n + blockSize - 1) / blockSize);
 			kernZeroed << <blocksPerGrid, blockSize >> > (pow2n, n, dev_out);
 			checkCUDAError("kernZeroed failed!");
-
-			for (int d = 0; d < ilog2ceil(pow2n); ++d) {
-				dim3 blocksPerGrid((pow2n /(1 << (d + 1)) + blockSize - 1) / blockSize);
-				kernUpSweep << <blocksPerGrid, blockSize >> > (pow2n, d, dev_out);
-				checkCUDAError("kernUpSweep failed!");
-			}
-
-			for (int d = ilog2ceil(pow2n) - 1; d >= 0; --d) {
-				dim3 blocksPerGrid((pow2n / (1 << (d + 1)) + blockSize - 1) / blockSize);
-				kernDownSweep << <blocksPerGrid, blockSize >> > (pow2n, d, dev_out);
-				checkCUDAError("kernDownSweep failed!");
-			}
-
+			
+			timer().startGpuTimer();
+			scan_implementation(n, dev_out);
 			timer().endGpuTimer();
 
 			cudaMemcpy(odata, dev_out, n * sizeof(int), cudaMemcpyDeviceToHost);
@@ -99,10 +105,12 @@ namespace StreamCompaction {
         int compact(int n, int *odata, const int *idata) 
 		{
 			// TODO
-			int *bools;
+			int *dbools;
 			int *dev_in;
+			int *dev_out;
+			int *indices;
 
-			cudaMalloc((void**)&bools, (n + 1) * sizeof(int));
+			cudaMalloc((void**)&dbools, (n + 1) * sizeof(int));
 			checkCUDAError("cudaMalloc bools failed!");
 
 			cudaMalloc((void**)&dev_in, (n + 1) * sizeof(int));
@@ -113,22 +121,26 @@ namespace StreamCompaction {
 
 			timer().startGpuTimer();
 
-			dim3 blocksPerGrid((n + blockSize) / blockSize);
-			StreamCompaction::Common::kernMapToBoolean << <blocksPerGrid, blockSize >> > (n+1, bools, dev_in);
+			dim3 blocksPerGrid1((n + blockSize) / blockSize);
+			StreamCompaction::Common::kernMapToBoolean << <blocksPerGrid1, blockSize >> > (n+1, dbools, dev_in);
 			checkCUDAError("kernMapToBoolean failed!");
 
-			/*scan(n + 1, odata, bools);
+			scan_implementation(n + 1, dbools);
 
-			dim3 blocksPerGrid((n + blockSize) / blockSize);
-			StreamCompaction::Common::kernScatter << <blocksPerGrid, blockSize >> > (n + 1, odata, idata, bools, indices);
-			checkCUDAError("kernScatter failed!");*/
+			dim3 blocksPerGrid((n + blockSize - 1) / blockSize);
+			StreamCompaction::Common::kernScatter << <blocksPerGrid, blockSize >> > (n, dev_out, dev_in, dbools);
+			checkCUDAError("kernScatter failed!");
 
 			timer().endGpuTimer();
 
-			cudaMemcpy(odata, dev_in, n * sizeof(int), cudaMemcpyDeviceToHost);
+			cudaMemcpy(odata, dev_out, n * sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+
+			int *num = (int *)malloc(sizeof(int));
+			cudaMemcpy(num, dbools + n , sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");
             
-            return -1;
+            return *num;
         }
     }
 }
diff --git a/stream_compaction/thrust.cu b/stream_compaction/thrust.cu
index 351b8dd..e10c811 100644
--- a/stream_compaction/thrust.cu
+++ b/stream_compaction/thrust.cu
@@ -19,31 +19,31 @@ namespace StreamCompaction {
          */
         void scan(int n, int *odata, const int *idata) {
 
-			int *dev_in;
-			int *dev_out;
+			//int *dev_in;
+			//int *dev_out;
 
-			cudaMalloc((void**)&dev_in, n * sizeof(int));
-			checkCUDAError("cudaMalloc dev_in failed!");
+			//cudaMalloc((void**)&dev_in, n * sizeof(int));
+			//checkCUDAError("cudaMalloc dev_in failed!");
 
-			cudaMalloc((void**)&dev_out, n * sizeof(int));
-			checkCUDAError("cudaMalloc dev_out failed!");
+			//cudaMalloc((void**)&dev_out, n * sizeof(int));
+			//checkCUDAError("cudaMalloc dev_out failed!");
 
-			cudaMemcpy(dev_in, idata, n * sizeof(int), cudaMemcpyHostToDevice);
-			checkCUDAError("cudaMemcpy dev_in failed!");
+			//cudaMemcpy(dev_in, idata, n * sizeof(int), cudaMemcpyHostToDevice);
+			//checkCUDAError("cudaMemcpy dev_in failed!");
 
-			cudaMemcpy(dev_out, odata, n * sizeof(int), cudaMemcpyHostToDevice);
-			checkCUDAError("cudaMemcpy dev_in failed!");
+			//cudaMemcpy(dev_out, odata, n * sizeof(int), cudaMemcpyHostToDevice);
+			//checkCUDAError("cudaMemcpy dev_in failed!");
 
-            timer().startGpuTimer();
-            // TODO use `thrust::exclusive_scan`
-            // example: for device_vectors dv_in and dv_out:
-            // thrust::exclusive_scan(dv_in.begin(), dv_in.end(), dv_out.begin());
-			thrust::exclusive_scan(dev_in, dev_in + n, dev_out);
+   //         timer().startGpuTimer();
+   //         // TODO use `thrust::exclusive_scan`
+   //         // example: for device_vectors dv_in and dv_out:
+   //         // thrust::exclusive_scan(dv_in.begin(), dv_in.end(), dv_out.begin());
+			//thrust::exclusive_scan(dev_in, dev_in + n, dev_out);
 
-			timer().endGpuTimer();
+			//timer().endGpuTimer();
 
-			cudaMemcpy(odata, dev_out, n * sizeof(int), cudaMemcpyDeviceToHost);
-			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+			//cudaMemcpy(odata, dev_out, n * sizeof(int), cudaMemcpyDeviceToHost);
+			//checkCUDAError("cudaMemcpyDeviceToHost failed!");
 
         }
     }

From f69f9c119d70c4165d67389954ad721b3fb96064 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Fri, 15 Sep 2017 17:49:28 -0400
Subject: [PATCH 06/27] thrust

---
 src/main.cpp                |  2 +-
 stream_compaction/thrust.cu | 31 +++++++++----------------------
 2 files changed, 10 insertions(+), 23 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index ea2d683..e75f631 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -13,7 +13,7 @@
 #include <stream_compaction/thrust.h>
 #include "testing_helpers.hpp"
 
-const int SIZE = 1 << 5; // feel free to change the size of array
+const int SIZE = 1 << 8; // feel free to change the size of array
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 int a[SIZE], b[SIZE], c[SIZE];
 
diff --git a/stream_compaction/thrust.cu b/stream_compaction/thrust.cu
index e10c811..35ea3dc 100644
--- a/stream_compaction/thrust.cu
+++ b/stream_compaction/thrust.cu
@@ -19,31 +19,18 @@ namespace StreamCompaction {
          */
         void scan(int n, int *odata, const int *idata) {
 
-			//int *dev_in;
-			//int *dev_out;
+			thrust::host_vector<int> host_in = thrust::host_vector<int>(idata, idata + n);
+			thrust::host_vector<int> host_out = thrust::host_vector<int>(odata, odata + n);
 
-			//cudaMalloc((void**)&dev_in, n * sizeof(int));
-			//checkCUDAError("cudaMalloc dev_in failed!");
+			thrust::device_vector<int> dev_in = thrust::device_vector<int>(host_in);
+			thrust::device_vector<int> dev_out = thrust::device_vector<int>(host_out);
 
-			//cudaMalloc((void**)&dev_out, n * sizeof(int));
-			//checkCUDAError("cudaMalloc dev_out failed!");
+			// TODO
+            timer().startGpuTimer();
+			thrust::exclusive_scan(dev_in.begin(), dev_in.end(), dev_out.begin());
+			timer().endGpuTimer();
 
-			//cudaMemcpy(dev_in, idata, n * sizeof(int), cudaMemcpyHostToDevice);
-			//checkCUDAError("cudaMemcpy dev_in failed!");
-
-			//cudaMemcpy(dev_out, odata, n * sizeof(int), cudaMemcpyHostToDevice);
-			//checkCUDAError("cudaMemcpy dev_in failed!");
-
-   //         timer().startGpuTimer();
-   //         // TODO use `thrust::exclusive_scan`
-   //         // example: for device_vectors dv_in and dv_out:
-   //         // thrust::exclusive_scan(dv_in.begin(), dv_in.end(), dv_out.begin());
-			//thrust::exclusive_scan(dev_in, dev_in + n, dev_out);
-
-			//timer().endGpuTimer();
-
-			//cudaMemcpy(odata, dev_out, n * sizeof(int), cudaMemcpyDeviceToHost);
-			//checkCUDAError("cudaMemcpyDeviceToHost failed!");
+			thrust::copy(dev_out.begin(), dev_out.end(), odata);
 
         }
     }

From 14893cf2f5216a01bde09ebb114a8ff981a89a83 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Fri, 15 Sep 2017 20:55:53 -0400
Subject: [PATCH 07/27] performance

---
 performance.xlsx               | Bin 0 -> 19609 bytes
 src/main.cpp                   |   2 +-
 stream_compaction/common.h     |   1 +
 stream_compaction/efficient.cu |   2 --
 stream_compaction/naive.cu     |   2 --
 5 files changed, 2 insertions(+), 5 deletions(-)
 create mode 100644 performance.xlsx

diff --git a/performance.xlsx b/performance.xlsx
new file mode 100644
index 0000000000000000000000000000000000000000..653579af2c4a5438ad0d96961daac924e5b3db03
GIT binary patch
literal 19609
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

literal 0
HcmV?d00001

diff --git a/src/main.cpp b/src/main.cpp
index e75f631..478bd58 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -13,7 +13,7 @@
 #include <stream_compaction/thrust.h>
 #include "testing_helpers.hpp"
 
-const int SIZE = 1 << 8; // feel free to change the size of array
+const int SIZE = 1 << 12; // feel free to change the size of array
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 int a[SIZE], b[SIZE], c[SIZE];
 
diff --git a/stream_compaction/common.h b/stream_compaction/common.h
index 9d0a895..8229c25 100644
--- a/stream_compaction/common.h
+++ b/stream_compaction/common.h
@@ -12,6 +12,7 @@
 
 #define FILENAME (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
 #define checkCUDAError(msg) checkCUDAErrorFn(msg, FILENAME, __LINE__)
+#define blockSize 128
 
 /**
  * Check for CUDA errors; print and exit if there was a problem.
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index de549e1..a9267fb 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -3,8 +3,6 @@
 #include "common.h"
 #include "efficient.h"
 
-#define blockSize 128
-
 namespace StreamCompaction {
     namespace Efficient {
         using StreamCompaction::Common::PerformanceTimer;
diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu
index 252a718..713eaa3 100644
--- a/stream_compaction/naive.cu
+++ b/stream_compaction/naive.cu
@@ -3,8 +3,6 @@
 #include "common.h"
 #include "naive.h"
 
-#define blockSize 128
-
 namespace StreamCompaction {
     namespace Naive {
         using StreamCompaction::Common::PerformanceTimer;

From 7675dbbf3408828adde4a3f9f5fe2e3a4d5bb9a8 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Sun, 17 Sep 2017 19:26:20 -0400
Subject: [PATCH 08/27] radix sort, untested

---
 stream_compaction/CMakeLists.txt |   2 +
 stream_compaction/efficient.cu   |  15 +++-
 stream_compaction/radix.cu       | 148 +++++++++++++++++++++++++++++++
 stream_compaction/radix.h        |  11 +++
 4 files changed, 174 insertions(+), 2 deletions(-)
 create mode 100644 stream_compaction/radix.cu
 create mode 100644 stream_compaction/radix.h

diff --git a/stream_compaction/CMakeLists.txt b/stream_compaction/CMakeLists.txt
index 595d731..68d8d1f 100644
--- a/stream_compaction/CMakeLists.txt
+++ b/stream_compaction/CMakeLists.txt
@@ -9,6 +9,8 @@ set(SOURCE_FILES
     "efficient.cu"
     "thrust.h"
     "thrust.cu"
+    "radix.h"
+    "radix.cu"
     )
 
 cuda_add_library(stream_compaction
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index a9267fb..25fce23 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -106,7 +106,7 @@ namespace StreamCompaction {
 			int *dbools;
 			int *dev_in;
 			int *dev_out;
-			int *indices;
+			// int *indices;
 
 			cudaMalloc((void**)&dbools, (n + 1) * sizeof(int));
 			checkCUDAError("cudaMalloc bools failed!");
@@ -125,6 +125,9 @@ namespace StreamCompaction {
 
 			scan_implementation(n + 1, dbools);
 
+			cudaMalloc((void**)&dev_out, n * sizeof(int));
+			checkCUDAError("cudaMalloc dev_out failed!");
+
 			dim3 blocksPerGrid((n + blockSize - 1) / blockSize);
 			StreamCompaction::Common::kernScatter << <blocksPerGrid, blockSize >> > (n, dev_out, dev_in, dbools);
 			checkCUDAError("kernScatter failed!");
@@ -137,8 +140,16 @@ namespace StreamCompaction {
 			int *num = (int *)malloc(sizeof(int));
 			cudaMemcpy(num, dbools + n , sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+
+			int ret = *num;
+			free(num);
+
+			cudaFree(dbools);
+			cudaFree(dev_in);
+			cudaFree(dev_out);
+			// cudaFree(indices);
             
-            return *num;
+            return ret;
         }
     }
 }
diff --git a/stream_compaction/radix.cu b/stream_compaction/radix.cu
new file mode 100644
index 0000000..3856d55
--- /dev/null
+++ b/stream_compaction/radix.cu
@@ -0,0 +1,148 @@
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include "common.h"
+#include "efficient.h"
+
+namespace StreamCompaction {
+    namespace Radix {
+        using StreamCompaction::Common::PerformanceTimer;
+        PerformanceTimer& timer()
+        {
+            static PerformanceTimer timer;
+            return timer;
+        }
+
+		/**
+         * Maps an array to an array of 0s and 1s for bit n.
+         */
+        __global__ void kernMapToBoolean(int n, int k, int *bools, const int *idata) {
+            // TODO
+			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+			if (index >= n) return;
+
+			int val = 1 << k;
+			bools[index] = (idata[index] & val != 0) ? 0 : 1;
+        }
+
+        /**
+         * Computes t array: t[i] = i - f[i] + totalFalses; f = idata, t = odata
+         */
+        __global__ void kernComputeT(int n, int totalFalses, int *odata, const int *idata) {
+            // TODO
+			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+			if (index >= n) return;
+
+			odata[index] = index - idata[index] + totalFalses;
+        }
+
+        /**
+         * Computes d array: d[i] = e[i] ? f[i] : t[i]; 
+         */
+        __global__ void kernComputeD(int n, int *e, const int *f, const int *t) {
+            // TODO
+			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+			if (index >= n) return;
+
+			e[index] = (e[index] != 0) ? f[index] : t[index];
+        }
+
+        /**
+         * Computes scattered array based on D indices
+         */
+        __global__ void kernScatterD(int n, int *odata, int *indices, const int *idata) {
+            // TODO
+			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+			if (index >= n) return;
+
+			odata[indices[index]] = idata[index];
+        }
+
+		void sort_implementation(int n, int k, int* last_e, int* last_f, 
+								 int *e_arr, int *f_arr, int *t_arr, int *dev_in)
+		{
+			dim3 blocksPerGrid((n + blockSize - 1) / blockSize);
+
+			// Step 1: compute e array
+			kernMapToBoolean<<<blocksPerGrid, blockSize>>>(n, k, f_arr, dev_in);
+			checkCUDAError("kernMapToBoolean failed!");
+
+			cudaMemcpy(e_arr, f_arr, n * sizeof(int), cudaMemcpyDeviceToDevice);
+			checkCUDAError("cudaMemcpyDeviceToDevice failed!");
+
+			// Step 2: exclusive scan e
+			scan_implementation(n, f_arr);
+
+			// Step 3: compute totalFalses
+			cudaMemcpy(last_e, e_arr + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("last_e cudaMemcpyDeviceToHost failed!");
+
+			cudaMemcpy(last_f, dbools + n - 1 , sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("last_f cudaMemcpyDeviceToHost failed!");
+
+			int totalFalses = *last_e + *last_f;
+
+			// Step 4: compute t array
+			kernComputeT<<<blocksPerGrid, blockSize>>>(n, totalFalses, t_arr, f_arr);
+			checkCUDAError("kernComputeT failed!");
+
+			// Step 4: scatter based on address d
+			kernComputeD<<<blocksPerGrid, blockSize>>>(n, e_arr, f_arr, t_arr);
+			checkCUDAError("kernComputeD failed!");
+
+			kernScatterD<<<blocksPerGrid, blockSize>>>(n, f_arr, e_arr, dev_in);
+			checkCUDAError("kernScatterD failed!");
+		}
+
+        /**
+         * Performs radix sort on idata, storing the result into odata.
+         *
+         * @param n      The number of elements in idata.
+         * @param odata  The array into which to store elements.
+         * @param idata  The array of elements to compact.
+         * @returns      The number of elements remaining after compaction.
+         */
+        void sort(int n, int *odata, const int *idata) 
+		{
+			// TODO
+			int *e_arr;
+			int *f_arr;
+			int *t_arr;
+			int *dev_in;
+
+			int *last_e = (int *)malloc(sizeof(int));
+			int *last_f = (int *)malloc(sizeof(int));
+
+			cudaMalloc((void**)&e_arr, n * sizeof(int));
+			checkCUDAError("cudaMalloc e_arr failed!");
+
+			cudaMalloc((void**)&f_arr, n * sizeof(int));
+			checkCUDAError("cudaMalloc f_arr failed!");
+
+			cudaMalloc((void**)&t_arr, n * sizeof(int));
+			checkCUDAError("cudaMalloc t_arr failed!");
+
+			cudaMalloc((void**)&dev_in, n * sizeof(int));
+			checkCUDAError("cudaMalloc dev_in failed!");
+
+			cudaMemcpy(dev_in, idata, n * sizeof(int), cudaMemcpyHostToDevice);
+			checkCUDAError("cudaMemcpy dev_in failed!");
+
+			timer().startGpuTimer();
+			for (int k = 0; k < 8 * sizeof(int); ++k) {
+				sort_implementation(n, k, last_e, last_f, e_arr, f_arr, t_arr, dev_in);
+			}
+			timer().endGpuTimer();
+
+			cudaMemcpy(odata, f_arr, n * sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+
+			free(last_e);
+			free(last_f);
+
+			cudaFree(e_arr);
+			cudaFree(f_arr);
+			cudaFree(t_arr);
+			cudaFree(dev_in);
+        }
+    }
+}
diff --git a/stream_compaction/radix.h b/stream_compaction/radix.h
new file mode 100644
index 0000000..aa489d9
--- /dev/null
+++ b/stream_compaction/radix.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "common.h"
+
+namespace StreamCompaction {
+    namespace Radix {
+        StreamCompaction::Common::PerformanceTimer& timer();
+
+        void sort(int n, int *odata, const int *idata);
+    }
+}

From 50e566d69edaa635c87f42806e85ca6ff7ef27ce Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Sun, 17 Sep 2017 23:58:36 -0400
Subject: [PATCH 09/27] testing

---
 src/main.cpp             | 36 ++++++++++++++++++++++++++++++++++++
 stream_compaction/cpu.cu | 19 +++++++++++++++++++
 2 files changed, 55 insertions(+)

diff --git a/src/main.cpp b/src/main.cpp
index 478bd58..3a6c4b9 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -140,5 +140,41 @@ int main(int argc, char* argv[]) {
     printArray(expectedNPOT, c, true);
     printCmpLenResult(countNPOT, expectedNPOT, b, c);
 
+    printf("\n");
+    printf("*****************************\n");
+    printf("** RADIX SORT TESTS **\n");
+    printf("*****************************\n");
+
+    // Radix Tests
+
+    genArray(SIZE - 1, a, 4);  // Leave a 0 at the end to test that edge case
+    printArray(SIZE, a, true);
+
+    zeroArray(SIZE, b);
+    printDesc("cpu sort, power-of-two");
+    StreamCompaction::CPU::sort(SIZE, b, a);
+    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+    printArray(SIZE, b, true);
+
+    zeroArray(SIZE, c);
+    printDesc("cpu sort, non-power-of-two");
+    StreamCompaction::CPU::sort(NPOT, c, a);
+    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+    printArray(NPOT, b, true);
+
+    zeroArray(SIZE, c);
+    printDesc("radix sort, power-of-two");
+    StreamCompaction::Radix::sort(SIZE, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(SIZE, c, true);
+    printCmpResult(SIZE, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("radix sort, non-power-of-two");
+    StreamCompaction::Radix::sort(NPOT, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(NPOT, c, true);
+    printCmpResult(NPOT, b, c);
+
     system("pause"); // stop Win32 console from closing on exit
 }
diff --git a/stream_compaction/cpu.cu b/stream_compaction/cpu.cu
index dbd5ffd..8ea6230 100644
--- a/stream_compaction/cpu.cu
+++ b/stream_compaction/cpu.cu
@@ -92,5 +92,24 @@ namespace StreamCompaction {
 	        timer().endCpuTimer();
             return num;
         }
+
+        /**
+         * CPU sort
+         */
+        void sort_implementation(int n, int *odata, const int *idata)
+		{
+	        // TODO
+        }
+
+		/**
+         * CPU sort
+         */
+        void sort(int n, int *odata, const int *idata)
+		{
+	        timer().startCpuTimer();
+			sort_implementation(n, odata, idata);
+	        timer().endCpuTimer();
+        }
+
     }
 }

From 8908c5e80880c74c4f2e1b92e930dbb13ea48e38 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Mon, 18 Sep 2017 10:21:31 -0400
Subject: [PATCH 10/27] radix cpu

---
 stream_compaction/cpu.cu | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/stream_compaction/cpu.cu b/stream_compaction/cpu.cu
index 8ea6230..7d7ac6a 100644
--- a/stream_compaction/cpu.cu
+++ b/stream_compaction/cpu.cu
@@ -93,12 +93,46 @@ namespace StreamCompaction {
             return num;
         }
 
+        int findMax(int n, const int *idata) 
+        {
+        	int max = idata[0];
+        	for (int i = 1; i < n; ++i) {
+        		int val = idata[i];
+        		if (val > max) {
+        			max = val;
+        		}
+        	}
+        }
+
+        void countSort(int n, int d, int *odata, int *idata)
+        {
+        	int count[10] = {0};
+
+        	for (int i = 0; i < n; ++i) {
+        		count[(idata[i]/d)%10] ++;
+        	}
+
+        	for (int i = 1; i < 10; ++i) {
+        		count[i] += count[i - 1];
+        	}
+
+        	for (int i = n - 1; i >= 0; --i) {
+        		odata[ count[(idata[i]/d)%10] - 1] = idata[i];
+        		count[(idata[i]/d)%10] --;
+        	}
+        }
+
         /**
          * CPU sort
          */
         void sort_implementation(int n, int *odata, const int *idata)
 		{
 	        // TODO
+	        int max = findMax(n, idata);
+	        for (int d = 1; max/d > 0; d *= 10) {
+	        	countSort(n, d, odata, idata);
+	        	std::swap(idata, odata);
+	        }
         }
 
 		/**

From 5a668e39946db1cadc62ee224bd5712acc098716 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Mon, 18 Sep 2017 15:29:41 -0400
Subject: [PATCH 11/27] fixed dev_in overwriting

---
 src/main.cpp                   | 21 +++++++------
 stream_compaction/common.cu    |  4 +--
 stream_compaction/common.h     |  2 +-
 stream_compaction/cpu.cu       | 41 ++++++++++++++----------
 stream_compaction/cpu.h        |  2 ++
 stream_compaction/efficient.cu | 57 +++++++++++++++++-----------------
 stream_compaction/efficient.h  |  2 ++
 stream_compaction/radix.cu     | 39 ++++++++++++-----------
 8 files changed, 91 insertions(+), 77 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index 3a6c4b9..6798008 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -11,9 +11,10 @@
 #include <stream_compaction/naive.h>
 #include <stream_compaction/efficient.h>
 #include <stream_compaction/thrust.h>
+#include <stream_compaction/radix.h>
 #include "testing_helpers.hpp"
 
-const int SIZE = 1 << 12; // feel free to change the size of array
+const int SIZE = 1 << 3; // feel free to change the size of array
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 int a[SIZE], b[SIZE], c[SIZE];
 
@@ -147,7 +148,7 @@ int main(int argc, char* argv[]) {
 
     // Radix Tests
 
-    genArray(SIZE - 1, a, 4);  // Leave a 0 at the end to test that edge case
+	genArray(SIZE - 1, a, 7); 
     printArray(SIZE, a, true);
 
     zeroArray(SIZE, b);
@@ -167,14 +168,14 @@ int main(int argc, char* argv[]) {
     StreamCompaction::Radix::sort(SIZE, c, a);
     printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
     printArray(SIZE, c, true);
-    printCmpResult(SIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("radix sort, non-power-of-two");
-    StreamCompaction::Radix::sort(NPOT, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(NPOT, c, true);
-    printCmpResult(NPOT, b, c);
+	//printCmpResult(SIZE, b, c);
+
+    //zeroArray(SIZE, c);
+    //printDesc("radix sort, non-power-of-two");
+    //StreamCompaction::Radix::sort(NPOT, c, a);
+    //printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    //printArray(NPOT, c, true);
+    //printCmpResult(NPOT, b, c);
 
     system("pause"); // stop Win32 console from closing on exit
 }
diff --git a/stream_compaction/common.cu b/stream_compaction/common.cu
index 2ba70c7..b50e1e3 100644
--- a/stream_compaction/common.cu
+++ b/stream_compaction/common.cu
@@ -22,12 +22,12 @@ namespace StreamCompaction {
          * Maps an array to an array of 0s and 1s for stream compaction. Elements
          * which map to 0 will be removed, and elements which map to 1 will be kept.
          */
-        __global__ void kernMapToBoolean(int n, int *bools, const int *idata) {
+        __global__ void kernMapToBoolean(int pos2, int n, int *bools, const int *idata) {
             // TODO
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
 			if (index >= n) return;
 
-			bools[index] = (idata[index] != 0 || index == n - 1) ? 1 : 0;
+			bools[index] = (index < n && idata[index] != 0) ? 1 : 0;
         }
 
         /**
diff --git a/stream_compaction/common.h b/stream_compaction/common.h
index 8229c25..9e120a4 100644
--- a/stream_compaction/common.h
+++ b/stream_compaction/common.h
@@ -33,7 +33,7 @@ inline int ilog2ceil(int x) {
 
 namespace StreamCompaction {
     namespace Common {
-        __global__ void kernMapToBoolean(int n, int *bools, const int *idata);
+		__global__ void kernMapToBoolean(int pos2, int n, int *bools, const int *idata);
 
         __global__ void kernScatter(int n, int *odata,
                 const int *idata, const int *bools);
diff --git a/stream_compaction/cpu.cu b/stream_compaction/cpu.cu
index 7d7ac6a..3644788 100644
--- a/stream_compaction/cpu.cu
+++ b/stream_compaction/cpu.cu
@@ -102,6 +102,8 @@ namespace StreamCompaction {
         			max = val;
         		}
         	}
+
+			return max;
         }
 
         void countSort(int n, int d, int *odata, int *idata)
@@ -122,28 +124,33 @@ namespace StreamCompaction {
         	}
         }
 
-        /**
-         * CPU sort
-         */
-        void sort_implementation(int n, int *odata, const int *idata)
-		{
-	        // TODO
-	        int max = findMax(n, idata);
-	        for (int d = 1; max/d > 0; d *= 10) {
-	        	countSort(n, d, odata, idata);
-	        	std::swap(idata, odata);
-	        }
-        }
-
 		/**
          * CPU sort
          */
         void sort(int n, int *odata, const int *idata)
 		{
-	        timer().startCpuTimer();
-			sort_implementation(n, odata, idata);
-	        timer().endCpuTimer();
-        }
+	        // TODO
+			int* temp = new int[n];
 
+			for (int i = 0; i < n; ++i) {
+				odata[i] = idata[i];
+			}
+				
+			timer().startCpuTimer();
+			int max = findMax(n, idata);
+			bool eo = true;
+			for (int d = 1; max / d > 0; d *= 10) {
+				countSort(n, d, temp, odata);
+				std::swap(temp, odata);
+				eo = !eo;
+			}
+			timer().endCpuTimer();
+
+			if (!eo) {
+				std::swap(temp, odata);
+				std::memcpy(odata, temp, n * sizeof(int));
+			}
+			delete[] temp;
+        }
     }
 }
diff --git a/stream_compaction/cpu.h b/stream_compaction/cpu.h
index 236ce11..9ba529e 100644
--- a/stream_compaction/cpu.h
+++ b/stream_compaction/cpu.h
@@ -11,5 +11,7 @@ namespace StreamCompaction {
         int compactWithoutScan(int n, int *odata, const int *idata);
 
         int compactWithScan(int n, int *odata, const int *idata);
+
+		void sort(int n, int *odata, const int *idata);
     }
 }
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index 25fce23..c1279c3 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -23,10 +23,9 @@ namespace StreamCompaction {
 		__global__ void kernUpSweep(int n, int d, int *odata) 
 		{
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
-			if (index >= n) return;
-
 			int offset = 1 << (d + 1);
 			int i = (index + 1) * offset - 1;
+			if (i >= n) return;
 
 			int val = 1 << d;
 			odata[i] += odata[i - val];
@@ -36,20 +35,19 @@ namespace StreamCompaction {
 		__global__ void kernDownSweep(int n, int d, int *odata)
 		{
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
-			if (index >= n) return;
+			int offset = 1 << (d + 1);
+			int i = (index + 1) * offset - 1;
+			if (i >= n) return;
 
-			int i = index + 1;
 			int val = 1 << d;
-			int offset = 1 << (d + 1);
-			int temp = odata[i * offset - 1];
-			odata[i * offset - 1] += odata[i * offset - val - 1];
-			odata[i * offset - val - 1] = temp;
+			
+			int temp = odata[i];
+			odata[i] += odata[i - val];
+			odata[i - val] = temp;
 		}
 
-		void scan_implementation(int n, int *dev_out)
+		void scan_implementation(int pow2n, int *dev_out)
 		{
-			int pow2n = 1 << ilog2ceil(n);
-			
 			for (int d = 0; d < ilog2ceil(pow2n); ++d) {
 				dim3 blocksPerGrid((pow2n / (1 << (d + 1)) + blockSize - 1) / blockSize);
 				kernUpSweep << <blocksPerGrid, blockSize >> > (pow2n, d, dev_out);
@@ -82,7 +80,7 @@ namespace StreamCompaction {
 			checkCUDAError("kernZeroed failed!");
 			
 			timer().startGpuTimer();
-			scan_implementation(n, dev_out);
+			scan_implementation(pow2n, dev_out);
 			timer().endGpuTimer();
 
 			cudaMemcpy(odata, dev_out, n * sizeof(int), cudaMemcpyDeviceToHost);
@@ -106,26 +104,35 @@ namespace StreamCompaction {
 			int *dbools;
 			int *dev_in;
 			int *dev_out;
-			// int *indices;
 
-			cudaMalloc((void**)&dbools, (n + 1) * sizeof(int));
-			checkCUDAError("cudaMalloc bools failed!");
+			int pow2n = 1 << ilog2ceil(n + 1);
+
+			cudaMalloc((void**)&dbools, pow2n * sizeof(int));
+			checkCUDAError("cudaMalloc dbools failed!");
 
-			cudaMalloc((void**)&dev_in, (n + 1) * sizeof(int));
+			cudaMalloc((void**)&dev_in, n * sizeof(int));
 			checkCUDAError("cudaMalloc dev_in failed!");
 
-			cudaMemcpy(dev_in, idata, (n + 1) * sizeof(int), cudaMemcpyHostToDevice);
+			cudaMemcpy(dev_in, idata, n * sizeof(int), cudaMemcpyHostToDevice);
 			checkCUDAError("cudaMemcpy dev_in failed!");
 
 			timer().startGpuTimer();
 
-			dim3 blocksPerGrid1((n + blockSize) / blockSize);
-			StreamCompaction::Common::kernMapToBoolean << <blocksPerGrid1, blockSize >> > (n+1, dbools, dev_in);
+			dim3 blocksPerGrid1((pow2n + blockSize - 1) / blockSize);
+			StreamCompaction::Common::kernMapToBoolean << <blocksPerGrid1, blockSize >> > (pow2n, n, dbools, dev_in);
 			checkCUDAError("kernMapToBoolean failed!");
+		
+			// TODO: THIS IS CLOBBERING DEV_IN!!
+			scan_implementation(pow2n, dbools); // requires power of 2
 
-			scan_implementation(n + 1, dbools);
+			int *num = (int *)malloc(sizeof(int));
+			cudaMemcpy(num, dbools + n, sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("cudaMemcpyDeviceToHost failed!");
 
-			cudaMalloc((void**)&dev_out, n * sizeof(int));
+			int ret = *num;
+			free(num);
+
+			cudaMalloc((void**)&dev_out, pow2n * sizeof(int));
 			checkCUDAError("cudaMalloc dev_out failed!");
 
 			dim3 blocksPerGrid((n + blockSize - 1) / blockSize);
@@ -137,17 +144,9 @@ namespace StreamCompaction {
 			cudaMemcpy(odata, dev_out, n * sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");
 
-			int *num = (int *)malloc(sizeof(int));
-			cudaMemcpy(num, dbools + n , sizeof(int), cudaMemcpyDeviceToHost);
-			checkCUDAError("cudaMemcpyDeviceToHost failed!");
-
-			int ret = *num;
-			free(num);
-
 			cudaFree(dbools);
 			cudaFree(dev_in);
 			cudaFree(dev_out);
-			// cudaFree(indices);
             
             return ret;
         }
diff --git a/stream_compaction/efficient.h b/stream_compaction/efficient.h
index 803cb4f..6653205 100644
--- a/stream_compaction/efficient.h
+++ b/stream_compaction/efficient.h
@@ -6,6 +6,8 @@ namespace StreamCompaction {
     namespace Efficient {
         StreamCompaction::Common::PerformanceTimer& timer();
 
+		void scan_implementation(int n, int *dev_out);
+
         void scan(int n, int *odata, const int *idata);
 
         int compact(int n, int *odata, const int *idata);
diff --git a/stream_compaction/radix.cu b/stream_compaction/radix.cu
index 3856d55..220b013 100644
--- a/stream_compaction/radix.cu
+++ b/stream_compaction/radix.cu
@@ -69,28 +69,28 @@ namespace StreamCompaction {
 			cudaMemcpy(e_arr, f_arr, n * sizeof(int), cudaMemcpyDeviceToDevice);
 			checkCUDAError("cudaMemcpyDeviceToDevice failed!");
 
-			// Step 2: exclusive scan e
-			scan_implementation(n, f_arr);
+			//// Step 2: exclusive scan e
+			//StreamCompaction::Efficient::scan_implementation(n, f_arr);
 
-			// Step 3: compute totalFalses
-			cudaMemcpy(last_e, e_arr + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
-			checkCUDAError("last_e cudaMemcpyDeviceToHost failed!");
+			//// Step 3: compute totalFalses
+			//cudaMemcpy(last_e, e_arr + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
+			//checkCUDAError("last_e cudaMemcpyDeviceToHost failed!");
 
-			cudaMemcpy(last_f, dbools + n - 1 , sizeof(int), cudaMemcpyDeviceToHost);
-			checkCUDAError("last_f cudaMemcpyDeviceToHost failed!");
+			//cudaMemcpy(last_f, f_arr + n - 1 , sizeof(int), cudaMemcpyDeviceToHost);
+			//checkCUDAError("last_f cudaMemcpyDeviceToHost failed!");
 
-			int totalFalses = *last_e + *last_f;
+			//int totalFalses = *last_e + *last_f;
 
-			// Step 4: compute t array
-			kernComputeT<<<blocksPerGrid, blockSize>>>(n, totalFalses, t_arr, f_arr);
-			checkCUDAError("kernComputeT failed!");
+			//// Step 4: compute t array
+			//kernComputeT<<<blocksPerGrid, blockSize>>>(n, totalFalses, t_arr, f_arr);
+			//checkCUDAError("kernComputeT failed!");
 
-			// Step 4: scatter based on address d
-			kernComputeD<<<blocksPerGrid, blockSize>>>(n, e_arr, f_arr, t_arr);
-			checkCUDAError("kernComputeD failed!");
+			//// Step 4: scatter based on address d
+			//kernComputeD<<<blocksPerGrid, blockSize>>>(n, e_arr, f_arr, t_arr);
+			//checkCUDAError("kernComputeD failed!");
 
-			kernScatterD<<<blocksPerGrid, blockSize>>>(n, f_arr, e_arr, dev_in);
-			checkCUDAError("kernScatterD failed!");
+			//kernScatterD<<<blocksPerGrid, blockSize>>>(n, f_arr, e_arr, dev_in);
+			//checkCUDAError("kernScatterD failed!");
 		}
 
         /**
@@ -128,12 +128,15 @@ namespace StreamCompaction {
 			checkCUDAError("cudaMemcpy dev_in failed!");
 
 			timer().startGpuTimer();
-			for (int k = 0; k < 8 * sizeof(int); ++k) {
+			for (int k = 1; k < 2; ++k) {
 				sort_implementation(n, k, last_e, last_f, e_arr, f_arr, t_arr, dev_in);
+
+				cudaMemcpy(dev_in, f_arr, n * sizeof(int), cudaMemcpyDeviceToDevice);
+				checkCUDAError("cudaMemcpyDeviceToDevice failed!");
 			}
 			timer().endGpuTimer();
 
-			cudaMemcpy(odata, f_arr, n * sizeof(int), cudaMemcpyDeviceToHost);
+			cudaMemcpy(odata, e_arr, n * sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");
 
 			free(last_e);

From dfb5ee8010699f63350229f8f665553c18e47867 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Mon, 18 Sep 2017 15:57:30 -0400
Subject: [PATCH 12/27] radix sort

---
 src/main.cpp                   | 30 ++++++++++----------
 stream_compaction/common.cu    |  4 +--
 stream_compaction/cpu.cu       |  2 +-
 stream_compaction/efficient.cu |  1 -
 stream_compaction/radix.cu     | 50 ++++++++++++++++++----------------
 5 files changed, 45 insertions(+), 42 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index 6798008..f98c2fe 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -14,9 +14,9 @@
 #include <stream_compaction/radix.h>
 #include "testing_helpers.hpp"
 
-const int SIZE = 1 << 3; // feel free to change the size of array
+const int SIZE = 1 << 4; // feel free to change the size of array
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
-int a[SIZE], b[SIZE], c[SIZE];
+int a[SIZE], b[SIZE], c[SIZE], d[SIZE];
 
 int main(int argc, char* argv[]) {
     // Scan tests
@@ -148,7 +148,7 @@ int main(int argc, char* argv[]) {
 
     // Radix Tests
 
-	genArray(SIZE - 1, a, 7); 
+	genArray(SIZE - 1, a, 50); 
     printArray(SIZE, a, true);
 
     zeroArray(SIZE, b);
@@ -161,21 +161,21 @@ int main(int argc, char* argv[]) {
     printDesc("cpu sort, non-power-of-two");
     StreamCompaction::CPU::sort(NPOT, c, a);
     printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(NPOT, b, true);
+    printArray(NPOT, c, true);
 
-    zeroArray(SIZE, c);
+    zeroArray(SIZE, d);
     printDesc("radix sort, power-of-two");
-    StreamCompaction::Radix::sort(SIZE, c, a);
+    StreamCompaction::Radix::sort(SIZE, d, a);
     printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, c, true);
-	//printCmpResult(SIZE, b, c);
-
-    //zeroArray(SIZE, c);
-    //printDesc("radix sort, non-power-of-two");
-    //StreamCompaction::Radix::sort(NPOT, c, a);
-    //printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(NPOT, c, true);
-    //printCmpResult(NPOT, b, c);
+    printArray(SIZE, d, true);
+	printCmpResult(SIZE, b, d);
+
+    zeroArray(SIZE, d);
+    printDesc("radix sort, non-power-of-two");
+    StreamCompaction::Radix::sort(NPOT, d, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(NPOT, d, true);
+    printCmpResult(NPOT, c, d);
 
     system("pause"); // stop Win32 console from closing on exit
 }
diff --git a/stream_compaction/common.cu b/stream_compaction/common.cu
index b50e1e3..711612f 100644
--- a/stream_compaction/common.cu
+++ b/stream_compaction/common.cu
@@ -22,10 +22,10 @@ namespace StreamCompaction {
          * Maps an array to an array of 0s and 1s for stream compaction. Elements
          * which map to 0 will be removed, and elements which map to 1 will be kept.
          */
-        __global__ void kernMapToBoolean(int pos2, int n, int *bools, const int *idata) {
+        __global__ void kernMapToBoolean(int pos2n, int n, int *bools, const int *idata) {
             // TODO
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
-			if (index >= n) return;
+			if (index >= pos2n) return;
 
 			bools[index] = (index < n && idata[index] != 0) ? 1 : 0;
         }
diff --git a/stream_compaction/cpu.cu b/stream_compaction/cpu.cu
index 3644788..275ef45 100644
--- a/stream_compaction/cpu.cu
+++ b/stream_compaction/cpu.cu
@@ -129,7 +129,7 @@ namespace StreamCompaction {
          */
         void sort(int n, int *odata, const int *idata)
 		{
-	        // TODO
+	        // TODO (from GeeksforGeeks Radix Sort)
 			int* temp = new int[n];
 
 			for (int i = 0; i < n; ++i) {
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index c1279c3..0f004ad 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -122,7 +122,6 @@ namespace StreamCompaction {
 			StreamCompaction::Common::kernMapToBoolean << <blocksPerGrid1, blockSize >> > (pow2n, n, dbools, dev_in);
 			checkCUDAError("kernMapToBoolean failed!");
 		
-			// TODO: THIS IS CLOBBERING DEV_IN!!
 			scan_implementation(pow2n, dbools); // requires power of 2
 
 			int *num = (int *)malloc(sizeof(int));
diff --git a/stream_compaction/radix.cu b/stream_compaction/radix.cu
index 220b013..1d9eb32 100644
--- a/stream_compaction/radix.cu
+++ b/stream_compaction/radix.cu
@@ -15,13 +15,13 @@ namespace StreamCompaction {
 		/**
          * Maps an array to an array of 0s and 1s for bit n.
          */
-        __global__ void kernMapToBoolean(int n, int k, int *bools, const int *idata) {
+        __global__ void kernMapToBoolean(int pow2n, int n, int k, int *bools, const int *idata) {
             // TODO
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
-			if (index >= n) return;
+			if (index >= pow2n) return;
 
 			int val = 1 << k;
-			bools[index] = (idata[index] & val != 0) ? 0 : 1;
+			bools[index] = ((idata[index] & val) != 0 || index >= n) ? 0 : 1;
         }
 
         /**
@@ -62,35 +62,37 @@ namespace StreamCompaction {
 		{
 			dim3 blocksPerGrid((n + blockSize - 1) / blockSize);
 
+			int pow2n = 1 << ilog2ceil(n + 1);
+
 			// Step 1: compute e array
-			kernMapToBoolean<<<blocksPerGrid, blockSize>>>(n, k, f_arr, dev_in);
+			kernMapToBoolean<<<blocksPerGrid, blockSize>>>(pow2n, n, k, f_arr, dev_in);
 			checkCUDAError("kernMapToBoolean failed!");
 
 			cudaMemcpy(e_arr, f_arr, n * sizeof(int), cudaMemcpyDeviceToDevice);
 			checkCUDAError("cudaMemcpyDeviceToDevice failed!");
 
-			//// Step 2: exclusive scan e
-			//StreamCompaction::Efficient::scan_implementation(n, f_arr);
+			// Step 2: exclusive scan e
+			StreamCompaction::Efficient::scan_implementation(pow2n, f_arr);
 
-			//// Step 3: compute totalFalses
-			//cudaMemcpy(last_e, e_arr + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
-			//checkCUDAError("last_e cudaMemcpyDeviceToHost failed!");
+			// Step 3: compute totalFalses
+			cudaMemcpy(last_e, e_arr + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("last_e cudaMemcpyDeviceToHost failed!");
 
-			//cudaMemcpy(last_f, f_arr + n - 1 , sizeof(int), cudaMemcpyDeviceToHost);
-			//checkCUDAError("last_f cudaMemcpyDeviceToHost failed!");
+			cudaMemcpy(last_f, f_arr + n - 1 , sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("last_f cudaMemcpyDeviceToHost failed!");
 
-			//int totalFalses = *last_e + *last_f;
+			int totalFalses = *last_e + *last_f;
 
-			//// Step 4: compute t array
-			//kernComputeT<<<blocksPerGrid, blockSize>>>(n, totalFalses, t_arr, f_arr);
-			//checkCUDAError("kernComputeT failed!");
+			// Step 4: compute t array
+			kernComputeT<<<blocksPerGrid, blockSize>>>(n, totalFalses, t_arr, f_arr);
+			checkCUDAError("kernComputeT failed!");
 
-			//// Step 4: scatter based on address d
-			//kernComputeD<<<blocksPerGrid, blockSize>>>(n, e_arr, f_arr, t_arr);
-			//checkCUDAError("kernComputeD failed!");
+			// Step 4: scatter based on address d
+			kernComputeD<<<blocksPerGrid, blockSize>>>(n, e_arr, f_arr, t_arr);
+			checkCUDAError("kernComputeD failed!");
 
-			//kernScatterD<<<blocksPerGrid, blockSize>>>(n, f_arr, e_arr, dev_in);
-			//checkCUDAError("kernScatterD failed!");
+			kernScatterD<<<blocksPerGrid, blockSize>>>(n, f_arr, e_arr, dev_in);
+			checkCUDAError("kernScatterD failed!");
 		}
 
         /**
@@ -109,13 +111,15 @@ namespace StreamCompaction {
 			int *t_arr;
 			int *dev_in;
 
+			int pow2n = 1 << ilog2ceil(n);
+
 			int *last_e = (int *)malloc(sizeof(int));
 			int *last_f = (int *)malloc(sizeof(int));
 
 			cudaMalloc((void**)&e_arr, n * sizeof(int));
 			checkCUDAError("cudaMalloc e_arr failed!");
 
-			cudaMalloc((void**)&f_arr, n * sizeof(int));
+			cudaMalloc((void**)&f_arr, pow2n * sizeof(int));
 			checkCUDAError("cudaMalloc f_arr failed!");
 
 			cudaMalloc((void**)&t_arr, n * sizeof(int));
@@ -128,7 +132,7 @@ namespace StreamCompaction {
 			checkCUDAError("cudaMemcpy dev_in failed!");
 
 			timer().startGpuTimer();
-			for (int k = 1; k < 2; ++k) {
+			for (int k = 0; k < 8 * sizeof(int); ++k) {
 				sort_implementation(n, k, last_e, last_f, e_arr, f_arr, t_arr, dev_in);
 
 				cudaMemcpy(dev_in, f_arr, n * sizeof(int), cudaMemcpyDeviceToDevice);
@@ -136,7 +140,7 @@ namespace StreamCompaction {
 			}
 			timer().endGpuTimer();
 
-			cudaMemcpy(odata, e_arr, n * sizeof(int), cudaMemcpyDeviceToHost);
+			cudaMemcpy(odata, f_arr, n * sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");
 
 			free(last_e);

From 25aa07e382ac19284f4837d5536264347aabe65f Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Tue, 19 Sep 2017 10:10:33 -0400
Subject: [PATCH 13/27] readme

---
 README.md | 101 +++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 96 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index b71c458..f0bbe23 100644
--- a/README.md
+++ b/README.md
@@ -3,11 +3,102 @@ CUDA Stream Compaction
 
 **University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 2**
 
-* (TODO) YOUR NAME HERE
-* Tested on: (TODO) Windows 22, i7-2222 @ 2.22GHz 22GB, GTX 222 222MB (Moore 2222 Lab)
+* Sarah Forcier
+* Tested on GeForce GTX 1070
 
-### (TODO: Your README)
+### Description
+#### Scan
+#### Stream Compaction
+#### Radix SOrt
 
-Include analysis, etc. (Remember, this is public, so don't put
-anything here that you don't want to share with the world.)
+### Output
 
+```
+****************
+** SCAN TESTS **
+****************
+    [  15  26  19   6  48  18   4  40   8  13  32  26  32  37  14   0 ]
+==== cpu scan, power-of-two ====
+   elapsed time: 0.000277ms    (std::chrono Measured)
+    [   0  15  41  60  66 114 132 136 176 184 197 229 255 287 324 338 ]
+==== cpu scan, non-power-of-two ====
+   elapsed time: 0.000277ms    (std::chrono Measured)
+    [   0  15  41  60  66 114 132 136 176 184 197 229 255 ]
+    passed
+==== naive scan, power-of-two ====
+   elapsed time: 0.012288ms    (CUDA Measured)
+    [   0  15  41  60  66 114 132 136 176 184 197 229 255 287 324 338 ]
+    passed
+==== naive scan, non-power-of-two ====
+   elapsed time: 0.010496ms    (CUDA Measured)
+    [   0  15  41  60  66 114 132 136 176 184 197 229 255 ]
+    passed
+==== work-efficient scan, power-of-two ====
+   elapsed time: 0.017664ms    (CUDA Measured)
+    [   0  15  41  60  66 114 132 136 176 184 197 229 255 287 324 338 ]
+    passed
+==== work-efficient scan, non-power-of-two ====
+   elapsed time: 0.017472ms    (CUDA Measured)
+    [   0  15  41  60  66 114 132 136 176 184 197 229 255 ]
+    passed
+==== thrust scan, power-of-two ====
+   elapsed time: 10.5801ms    (CUDA Measured)
+    [   0  15  41  60  66 114 132 136 176 184 197 229 255 287 324 338 ]
+    passed
+==== thrust scan, non-power-of-two ====
+   elapsed time: 0.014368ms    (CUDA Measured)
+    [   0  15  41  60  66 114 132 136 176 184 197 229 255 ]
+    passed
+
+*****************************
+** STREAM COMPACTION TESTS **
+*****************************
+    [   3   1   1   1   2   1   1   0   3   1   0   2   3   0   1   0 ]
+==== cpu compact without scan, power-of-two ====
+   elapsed time: 0.000277ms    (std::chrono Measured)
+    [   3   1   1   1   2   1   1   3   1   2   3   1 ]
+    passed
+==== cpu compact without scan, non-power-of-two ====
+   elapsed time: 0.000277ms    (std::chrono Measured)
+    [   3   1   1   1   2   1   1   3   1   2   3 ]
+    passed
+==== cpu compact with scan ====
+   elapsed time: 0.001387ms    (std::chrono Measured)
+    [   3   1   1   1   2   1   1   3   1   2   3   1 ]
+    passed
+==== work-efficient compact, power-of-two ====
+   elapsed time: 0.216224ms    (CUDA Measured)
+    [   3   1   1   1   2   1   1   3   1   2   3   1 ]
+    passed
+==== work-efficient compact, non-power-of-two ====
+   elapsed time: 0.099584ms    (CUDA Measured)
+    [   3   1   1   1   2   1   1   3   1   2   3 ]
+    passed
+
+*****************************
+** RADIX SORT TESTS **
+*****************************
+    [  21  23  29  15  10  21  29  36  13  17  36  14  41  12  31   0 ]
+==== cpu sort, power-of-two ====
+   elapsed time: 0.000554ms    (std::chrono Measured)
+    [   0  10  12  13  14  15  17  21  21  23  29  29  31  36  36  41 ]
+==== cpu sort, non-power-of-two ====
+   elapsed time: 0.000555ms    (std::chrono Measured)
+    [  10  13  14  15  17  21  21  23  29  29  36  36  41 ]
+==== radix sort, power-of-two ====
+   elapsed time: 0.099584ms    (CUDA Measured)
+    [   0  10  12  13  14  15  17  21  21  23  29  29  31  36  36  41 ]
+    passed
+==== radix sort, non-power-of-two ====
+   elapsed time: 0.099584ms    (CUDA Measured)
+    [  10  13  14  15  17  21  21  23  29  29  36  36  41 ]
+    passed
+ ```
+
+### Performance Analysis
+
+### Q&A
+
+#### Compare GPU Scan implementations to the serial CPU version?
+
+#### Where are the performance bottlenecks?

From 293259d5c50653bc8779a284c53f7c968432f547 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Tue, 19 Sep 2017 10:13:14 -0400
Subject: [PATCH 14/27] formatting

---
 README.md | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index f0bbe23..9f531c9 100644
--- a/README.md
+++ b/README.md
@@ -7,16 +7,15 @@ CUDA Stream Compaction
 * Tested on GeForce GTX 1070
 
 ### Description
-#### Scan
-#### Stream Compaction
-#### Radix SOrt
+#### * Scan
+#### * Stream Compaction
+#### * Radix Sort
 
-### Output
+### Test Output
+
+#### * Scan
 
 ```
-****************
-** SCAN TESTS **
-****************
     [  15  26  19   6  48  18   4  40   8  13  32  26  32  37  14   0 ]
 ==== cpu scan, power-of-two ====
    elapsed time: 0.000277ms    (std::chrono Measured)
@@ -49,10 +48,11 @@ CUDA Stream Compaction
    elapsed time: 0.014368ms    (CUDA Measured)
     [   0  15  41  60  66 114 132 136 176 184 197 229 255 ]
     passed
+```
 
-*****************************
-** STREAM COMPACTION TESTS **
-*****************************
+#### * Stream Compaction
+
+```
     [   3   1   1   1   2   1   1   0   3   1   0   2   3   0   1   0 ]
 ==== cpu compact without scan, power-of-two ====
    elapsed time: 0.000277ms    (std::chrono Measured)
@@ -74,10 +74,11 @@ CUDA Stream Compaction
    elapsed time: 0.099584ms    (CUDA Measured)
     [   3   1   1   1   2   1   1   3   1   2   3 ]
     passed
+```
+
+#### * Radix Sort
 
-*****************************
-** RADIX SORT TESTS **
-*****************************
+```
     [  21  23  29  15  10  21  29  36  13  17  36  14  41  12  31   0 ]
 ==== cpu sort, power-of-two ====
    elapsed time: 0.000554ms    (std::chrono Measured)

From 17f34b4525cdc5d7de15202cd83faa8a8651283e Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Tue, 19 Sep 2017 15:13:52 -0400
Subject: [PATCH 15/27] graphs

---
 README.md                      |  18 +--
 performance.xlsx               | Bin 19609 -> 39991 bytes
 src/main.cpp                   | 259 +++++++++++++++++----------------
 stream_compaction/common.cu    |  14 +-
 stream_compaction/common.h     |   2 +-
 stream_compaction/cpu.cu       |  11 +-
 stream_compaction/efficient.cu |  33 +++--
 stream_compaction/radix.cu     |  16 +-
 stream_compaction/radix.h      |   2 +-
 9 files changed, 188 insertions(+), 167 deletions(-)

diff --git a/README.md b/README.md
index 9f531c9..d268d41 100644
--- a/README.md
+++ b/README.md
@@ -3,17 +3,17 @@ CUDA Stream Compaction
 
 **University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 2**
 
-* Sarah Forcier
-* Tested on GeForce GTX 1070
+Sarah Forcier
+Tested on GeForce GTX 1070
 
-### Description
-#### * Scan
-#### * Stream Compaction
-#### * Radix Sort
+### Algorithm Descriptions
+#### Scan
+#### Stream Compaction
+#### Radix Sort
 
 ### Test Output
 
-#### * Scan
+#### Scan
 
 ```
     [  15  26  19   6  48  18   4  40   8  13  32  26  32  37  14   0 ]
@@ -50,7 +50,7 @@ CUDA Stream Compaction
     passed
 ```
 
-#### * Stream Compaction
+#### Stream Compaction
 
 ```
     [   3   1   1   1   2   1   1   0   3   1   0   2   3   0   1   0 ]
@@ -76,7 +76,7 @@ CUDA Stream Compaction
     passed
 ```
 
-#### * Radix Sort
+#### Radix Sort
 
 ```
     [  21  23  29  15  10  21  29  36  13  17  36  14  41  12  31   0 ]
diff --git a/performance.xlsx b/performance.xlsx
index 653579af2c4a5438ad0d96961daac924e5b3db03..8d322e608c85fbea8ccd90514c552ed1f20c092f 100644
GIT binary patch
delta 23466
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

delta 9901
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
a`Csj;A`b`u7Xt6?Gx4@%Zj$=z>3;wnj6&Q1

diff --git a/src/main.cpp b/src/main.cpp
index f98c2fe..e6d611f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -13,133 +13,137 @@
 #include <stream_compaction/thrust.h>
 #include <stream_compaction/radix.h>
 #include "testing_helpers.hpp"
-
-const int SIZE = 1 << 4; // feel free to change the size of array
+const int SIZE = 1 << 12; // feel free to change the size of array
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
-int a[SIZE], b[SIZE], c[SIZE], d[SIZE];
+//int a[SIZE], b[SIZE], c[SIZE], d[SIZE];
 
 int main(int argc, char* argv[]) {
     // Scan tests
 
-    printf("\n");
-    printf("****************\n");
-    printf("** SCAN TESTS **\n");
-    printf("****************\n");
-
-    genArray(SIZE - 1, a, 50);  // Leave a 0 at the end to test that edge case
-    a[SIZE - 1] = 0;
-
-    printArray(SIZE, a, true);
-
-    // initialize b using StreamCompaction::CPU::scan you implement
-    // We use b for further comparison. Make sure your StreamCompaction::CPU::scan is correct.
-    // At first all cases passed because b && c are all zeroes.
-    zeroArray(SIZE, b);
-    printDesc("cpu scan, power-of-two");
-    StreamCompaction::CPU::scan(SIZE, b, a);
-    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(SIZE, b, true);
-
-    zeroArray(SIZE, c);
-    printDesc("cpu scan, non-power-of-two");
-    StreamCompaction::CPU::scan(NPOT, c, a);
-    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(NPOT, b, true);
-    printCmpResult(NPOT, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("naive scan, power-of-two");
-    StreamCompaction::Naive::scan(SIZE, c, a);
-    printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, c, true);
-    printCmpResult(SIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("naive scan, non-power-of-two");
-    StreamCompaction::Naive::scan(NPOT, c, a);
-    printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(NPOT, c, true);
-    printCmpResult(NPOT, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("work-efficient scan, power-of-two");
-    StreamCompaction::Efficient::scan(SIZE, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, c, true);
-    printCmpResult(SIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("work-efficient scan, non-power-of-two");
-    StreamCompaction::Efficient::scan(NPOT, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(NPOT, c, true);
-    printCmpResult(NPOT, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("thrust scan, power-of-two");
-    StreamCompaction::Thrust::scan(SIZE, c, a);
-    printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, c, true);
-    printCmpResult(SIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("thrust scan, non-power-of-two");
-    StreamCompaction::Thrust::scan(NPOT, c, a);
-    printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(NPOT, c, true);
-    printCmpResult(NPOT, b, c);
-
-    printf("\n");
-    printf("*****************************\n");
-    printf("** STREAM COMPACTION TESTS **\n");
-    printf("*****************************\n");
-
-    // Compaction tests
-
-    genArray(SIZE - 1, a, 4);  // Leave a 0 at the end to test that edge case
-    a[SIZE - 1] = 0;
-    printArray(SIZE, a, true);
-
-    int countSIZE, countNPOT, expectedSIZE, expectedNPOT;
-
-    // initialize b using StreamCompaction::CPU::compactWithoutScan you implement
-    // We use b for further comparison. Make sure your StreamCompaction::CPU::compactWithoutScan is correct.
-    zeroArray(SIZE, b);
-    printDesc("cpu compact without scan, power-of-two");
-    countSIZE = StreamCompaction::CPU::compactWithoutScan(SIZE, b, a);
-    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-	expectedSIZE = countSIZE;
-    printArray(expectedSIZE, b, true);
-    printCmpLenResult(countSIZE, expectedSIZE, b, b);
-
-    zeroArray(SIZE, c);
-    printDesc("cpu compact without scan, non-power-of-two");
-	countNPOT = StreamCompaction::CPU::compactWithoutScan(NPOT, c, a);
-    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    expectedNPOT = countNPOT;
-    printArray(countNPOT, c, true);
-    printCmpLenResult(countNPOT, expectedNPOT, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("cpu compact with scan");
-	countSIZE = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
-    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(countSIZE, c, true);
-    printCmpLenResult(countSIZE, expectedSIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("work-efficient compact, power-of-two");
-	countSIZE = StreamCompaction::Efficient::compact(SIZE, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(expectedSIZE, c, true);
-    printCmpLenResult(countSIZE, expectedSIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("work-efficient compact, non-power-of-two");
-	countNPOT = StreamCompaction::Efficient::compact(NPOT, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(expectedNPOT, c, true);
-    printCmpLenResult(countNPOT, expectedNPOT, b, c);
+	 int* a = reinterpret_cast<int*>(malloc(SIZE * sizeof(int)));
+	 int* b = reinterpret_cast<int*>(malloc(SIZE * sizeof(int)));
+	 int* c = reinterpret_cast<int*>(malloc(SIZE * sizeof(int)));
+	 int* d = reinterpret_cast<int*>(malloc(SIZE * sizeof(int)));
+
+ //   printf("\n");
+ //   printf("****************\n");
+ //   printf("** SCAN TESTS **\n");
+ //   printf("****************\n");
+
+ //   genArray(SIZE - 1, a, 50);  // Leave a 0 at the end to test that edge case
+ //   a[SIZE - 1] = 0;
+
+ //   printArray(SIZE, a, true);
+
+ //   // initialize b using StreamCompaction::CPU::scan you implement
+ //   // We use b for further comparison. Make sure your StreamCompaction::CPU::scan is correct.
+ //   // At first all cases passed because b && c are all zeroes.
+ //   zeroArray(SIZE, b);
+ //   printDesc("cpu scan, power-of-two");
+ //   StreamCompaction::CPU::scan(SIZE, b, a);
+ //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+ //   printArray(SIZE, b, true);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("cpu scan, non-power-of-two");
+ //   StreamCompaction::CPU::scan(NPOT, c, a);
+ //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+ //   printArray(NPOT, b, true);
+ //   printCmpResult(NPOT, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("naive scan, power-of-two");
+ //   StreamCompaction::Naive::scan(SIZE, c, a);
+ //   printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(SIZE, c, true);
+ //   printCmpResult(SIZE, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("naive scan, non-power-of-two");
+ //   StreamCompaction::Naive::scan(NPOT, c, a);
+ //   printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(NPOT, c, true);
+ //   printCmpResult(NPOT, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("work-efficient scan, power-of-two");
+ //   StreamCompaction::Efficient::scan(SIZE, c, a);
+ //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(SIZE, c, true);
+ //   printCmpResult(SIZE, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("work-efficient scan, non-power-of-two");
+ //   StreamCompaction::Efficient::scan(NPOT, c, a);
+ //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(NPOT, c, true);
+ //   printCmpResult(NPOT, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("thrust scan, power-of-two");
+ //   StreamCompaction::Thrust::scan(SIZE, c, a);
+ //   printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(SIZE, c, true);
+ //   printCmpResult(SIZE, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("thrust scan, non-power-of-two");
+ //   StreamCompaction::Thrust::scan(NPOT, c, a);
+ //   printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(NPOT, c, true);
+ //   printCmpResult(NPOT, b, c);
+
+ //   printf("\n");
+ //   printf("*****************************\n");
+ //   printf("** STREAM COMPACTION TESTS **\n");
+ //   printf("*****************************\n");
+
+ //   // Compaction tests
+
+ //   genArray(SIZE - 1, a, 4);  // Leave a 0 at the end to test that edge case
+ //   a[SIZE - 1] = 0;
+ //   printArray(SIZE, a, true);
+
+ //   int countSIZE, countNPOT, expectedSIZE, expectedNPOT;
+
+ //   // initialize b using StreamCompaction::CPU::compactWithoutScan you implement
+ //   // We use b for further comparison. Make sure your StreamCompaction::CPU::compactWithoutScan is correct.
+ //   zeroArray(SIZE, b);
+ //   printDesc("cpu compact without scan, power-of-two");
+ //   countSIZE = StreamCompaction::CPU::compactWithoutScan(SIZE, b, a);
+ //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+	//expectedSIZE = countSIZE;
+ //   printArray(expectedSIZE, b, true);
+ //   printCmpLenResult(countSIZE, expectedSIZE, b, b);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("cpu compact without scan, non-power-of-two");
+	//countNPOT = StreamCompaction::CPU::compactWithoutScan(NPOT, c, a);
+ //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+ //   expectedNPOT = countNPOT;
+ //   printArray(countNPOT, c, true);
+ //   printCmpLenResult(countNPOT, expectedNPOT, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("cpu compact with scan");
+	//countSIZE = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
+ //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+ //   printArray(countSIZE, c, true);
+ //   printCmpLenResult(countSIZE, expectedSIZE, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("work-efficient compact, power-of-two");
+	//countSIZE = StreamCompaction::Efficient::compact(SIZE, c, a);
+ //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(expectedSIZE, c, true);
+ //   printCmpLenResult(countSIZE, expectedSIZE, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("work-efficient compact, non-power-of-two");
+	//countNPOT = StreamCompaction::Efficient::compact(NPOT, c, a);
+ //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(expectedNPOT, c, true);
+ //   printCmpLenResult(countNPOT, expectedNPOT, b, c);
 
     printf("\n");
     printf("*****************************\n");
@@ -148,7 +152,8 @@ int main(int argc, char* argv[]) {
 
     // Radix Tests
 
-	genArray(SIZE - 1, a, 50); 
+	int k = 6;
+	genArray(SIZE - 1, a, 1 << k); 
     printArray(SIZE, a, true);
 
     zeroArray(SIZE, b);
@@ -165,15 +170,15 @@ int main(int argc, char* argv[]) {
 
     zeroArray(SIZE, d);
     printDesc("radix sort, power-of-two");
-    StreamCompaction::Radix::sort(SIZE, d, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    StreamCompaction::Radix::sort(SIZE, k + 1, d, a);
+    printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
     printArray(SIZE, d, true);
 	printCmpResult(SIZE, b, d);
 
     zeroArray(SIZE, d);
     printDesc("radix sort, non-power-of-two");
-    StreamCompaction::Radix::sort(NPOT, d, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    StreamCompaction::Radix::sort(NPOT, k + 1, d, a);
+    printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
     printArray(NPOT, d, true);
     printCmpResult(NPOT, c, d);
 
diff --git a/stream_compaction/common.cu b/stream_compaction/common.cu
index 711612f..22be71c 100644
--- a/stream_compaction/common.cu
+++ b/stream_compaction/common.cu
@@ -34,15 +34,15 @@ namespace StreamCompaction {
          * Performs scatter on an array. That is, for each element in idata,
          * if bools[idx] == 1, it copies idata[idx] to odata[indices[idx]].
          */
-        __global__ void kernScatter(int n, int *odata, const int *idata, const int *bools) {
+        __global__ void kernScatter(int n, int *odata,
+			const int *idata, const int *bools, const int *indices) {
             // TODO
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
-			if (index >= n) return;
-
-			int idx = bools[index];
-			if (bools[index + 1] != idx) {
-				odata[idx] = idata[index];
-			}
+ 			if (index >= n) return;
+ 
+ 			if (bools[index] == 1) {
+ 				odata[indices[index]] = idata[index];
+ 			}
         }
     }
 }
\ No newline at end of file
diff --git a/stream_compaction/common.h b/stream_compaction/common.h
index 9e120a4..6aabc39 100644
--- a/stream_compaction/common.h
+++ b/stream_compaction/common.h
@@ -36,7 +36,7 @@ namespace StreamCompaction {
 		__global__ void kernMapToBoolean(int pos2, int n, int *bools, const int *idata);
 
         __global__ void kernScatter(int n, int *odata,
-                const int *idata, const int *bools);
+			const int *idata, const int *bools, const int *indices);
 
 	    /**
 	    * This class is used for timing the performance
diff --git a/stream_compaction/cpu.cu b/stream_compaction/cpu.cu
index 275ef45..e513108 100644
--- a/stream_compaction/cpu.cu
+++ b/stream_compaction/cpu.cu
@@ -62,12 +62,13 @@ namespace StreamCompaction {
          * @returns the number of elements remaining after compaction.
          */
         int compactWithScan(int n, int *odata, const int *idata) {
-	        timer().startCpuTimer();
+	        
 	        // TODO
 
 			int* temp = new int[n + 1];
 			temp[n] = 0;
 			int num = 0;
+			timer().startCpuTimer();
 			// compute temporary array
 			for (int i = 0; i < n; ++i) {
 				temp[i] = (idata[i] == 0) ? 0 : 1;
@@ -87,9 +88,8 @@ namespace StreamCompaction {
 					num++;
 				}
 			}
-
+			timer().endCpuTimer();
 			delete[] temp;
-	        timer().endCpuTimer();
             return num;
         }
 
@@ -135,9 +135,10 @@ namespace StreamCompaction {
 			for (int i = 0; i < n; ++i) {
 				odata[i] = idata[i];
 			}
-				
-			timer().startCpuTimer();
+			
 			int max = findMax(n, idata);
+
+			timer().startCpuTimer();
 			bool eo = true;
 			for (int d = 1; max / d > 0; d *= 10) {
 				countSort(n, d, temp, odata);
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index 0f004ad..4698a07 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -24,6 +24,7 @@ namespace StreamCompaction {
 		{
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
 			int offset = 1 << (d + 1);
+			if (index >= n >> (d + 1)) return;
 			int i = (index + 1) * offset - 1;
 			if (i >= n) return;
 
@@ -36,6 +37,7 @@ namespace StreamCompaction {
 		{
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
 			int offset = 1 << (d + 1);
+			if (index >= n >> (d + 1)) return;
 			int i = (index + 1) * offset - 1;
 			if (i >= n) return;
 
@@ -72,7 +74,7 @@ namespace StreamCompaction {
 			cudaMalloc((void**)&dev_out, pow2n * sizeof(int));
 			checkCUDAError("cudaMalloc dev_out failed!");
 
-			cudaMemcpy(dev_out, idata, pow2n * sizeof(int), cudaMemcpyHostToDevice);
+			cudaMemcpy(dev_out, idata, n * sizeof(int), cudaMemcpyHostToDevice);
 			checkCUDAError("cudaMemcpy dev_out failed!");
 
 			dim3 blocksPerGrid((pow2n + blockSize - 1) / blockSize);
@@ -82,6 +84,7 @@ namespace StreamCompaction {
 			timer().startGpuTimer();
 			scan_implementation(pow2n, dev_out);
 			timer().endGpuTimer();
+			checkCUDAError("scan_implementation failed!");
 
 			cudaMemcpy(odata, dev_out, n * sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");
@@ -102,14 +105,18 @@ namespace StreamCompaction {
 		{
 			// TODO
 			int *dbools;
+			int *indices;
 			int *dev_in;
 			int *dev_out;
 
-			int pow2n = 1 << ilog2ceil(n + 1);
+			int pow2n = 1 << ilog2ceil(n);
 
 			cudaMalloc((void**)&dbools, pow2n * sizeof(int));
 			checkCUDAError("cudaMalloc dbools failed!");
 
+			cudaMalloc((void**)&indices, pow2n * sizeof(int));
+			checkCUDAError("cudaMalloc indices failed!");
+
 			cudaMalloc((void**)&dev_in, n * sizeof(int));
 			checkCUDAError("cudaMalloc dev_in failed!");
 
@@ -119,33 +126,41 @@ namespace StreamCompaction {
 			timer().startGpuTimer();
 
 			dim3 blocksPerGrid1((pow2n + blockSize - 1) / blockSize);
-			StreamCompaction::Common::kernMapToBoolean << <blocksPerGrid1, blockSize >> > (pow2n, n, dbools, dev_in);
+			StreamCompaction::Common::kernMapToBoolean << <blocksPerGrid1, blockSize >> > (pow2n, n, indices, dev_in);
 			checkCUDAError("kernMapToBoolean failed!");
-		
-			scan_implementation(pow2n, dbools); // requires power of 2
+
+			cudaMemcpy(dbools, indices, pow2n * sizeof(int), cudaMemcpyDeviceToDevice);
+			checkCUDAError("cudaMemcpyDeviceToDevice failed!");
 
 			int *num = (int *)malloc(sizeof(int));
-			cudaMemcpy(num, dbools + n, sizeof(int), cudaMemcpyDeviceToHost);
+			cudaMemcpy(num, dbools + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");
 
 			int ret = *num;
+		
+			scan_implementation(pow2n, indices); // requires power of 2
+
+			cudaMemcpy(num, indices + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+			ret += *num;
 			free(num);
 
-			cudaMalloc((void**)&dev_out, pow2n * sizeof(int));
+			cudaMalloc((void**)&dev_out, ret * sizeof(int));
 			checkCUDAError("cudaMalloc dev_out failed!");
 
 			dim3 blocksPerGrid((n + blockSize - 1) / blockSize);
-			StreamCompaction::Common::kernScatter << <blocksPerGrid, blockSize >> > (n, dev_out, dev_in, dbools);
+			StreamCompaction::Common::kernScatter << <blocksPerGrid, blockSize >> > (n, dev_out, dev_in, dbools, indices);
 			checkCUDAError("kernScatter failed!");
 
 			timer().endGpuTimer();
 
-			cudaMemcpy(odata, dev_out, n * sizeof(int), cudaMemcpyDeviceToHost);
+			cudaMemcpy(odata, dev_out, ret * sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");
 
 			cudaFree(dbools);
 			cudaFree(dev_in);
 			cudaFree(dev_out);
+			cudaFree(indices);
             
             return ret;
         }
diff --git a/stream_compaction/radix.cu b/stream_compaction/radix.cu
index 1d9eb32..b87cfcc 100644
--- a/stream_compaction/radix.cu
+++ b/stream_compaction/radix.cu
@@ -62,7 +62,7 @@ namespace StreamCompaction {
 		{
 			dim3 blocksPerGrid((n + blockSize - 1) / blockSize);
 
-			int pow2n = 1 << ilog2ceil(n + 1);
+			int pow2n = 1 << ilog2ceil(n);
 
 			// Step 1: compute e array
 			kernMapToBoolean<<<blocksPerGrid, blockSize>>>(pow2n, n, k, f_arr, dev_in);
@@ -78,7 +78,7 @@ namespace StreamCompaction {
 			cudaMemcpy(last_e, e_arr + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("last_e cudaMemcpyDeviceToHost failed!");
 
-			cudaMemcpy(last_f, f_arr + n - 1 , sizeof(int), cudaMemcpyDeviceToHost);
+			cudaMemcpy(last_f, f_arr + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("last_f cudaMemcpyDeviceToHost failed!");
 
 			int totalFalses = *last_e + *last_f;
@@ -103,7 +103,7 @@ namespace StreamCompaction {
          * @param idata  The array of elements to compact.
          * @returns      The number of elements remaining after compaction.
          */
-        void sort(int n, int *odata, const int *idata) 
+        void sort(int n, int d, int *odata, const int *idata) 
 		{
 			// TODO
 			int *e_arr;
@@ -132,15 +132,15 @@ namespace StreamCompaction {
 			checkCUDAError("cudaMemcpy dev_in failed!");
 
 			timer().startGpuTimer();
-			for (int k = 0; k < 8 * sizeof(int); ++k) {
+			for (int k = 0; k < d; ++k) {
 				sort_implementation(n, k, last_e, last_f, e_arr, f_arr, t_arr, dev_in);
-
-				cudaMemcpy(dev_in, f_arr, n * sizeof(int), cudaMemcpyDeviceToDevice);
-				checkCUDAError("cudaMemcpyDeviceToDevice failed!");
+				std::swap(dev_in, f_arr);
+				/*cudaMemcpy(dev_in, f_arr, n * sizeof(int), cudaMemcpyDeviceToDevice);
+				checkCUDAError("cudaMemcpyDeviceToDevice failed!");*/
 			}
 			timer().endGpuTimer();
 
-			cudaMemcpy(odata, f_arr, n * sizeof(int), cudaMemcpyDeviceToHost);
+			cudaMemcpy(odata, dev_in, n * sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");
 
 			free(last_e);
diff --git a/stream_compaction/radix.h b/stream_compaction/radix.h
index aa489d9..cbadf0d 100644
--- a/stream_compaction/radix.h
+++ b/stream_compaction/radix.h
@@ -6,6 +6,6 @@ namespace StreamCompaction {
     namespace Radix {
         StreamCompaction::Common::PerformanceTimer& timer();
 
-        void sort(int n, int *odata, const int *idata);
+        void sort(int n, int d, int *odata, const int *idata);
     }
 }

From 24e19a087d3032275cc08d89f6f54b7b5293d074 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Tue, 19 Sep 2017 16:28:58 -0400
Subject: [PATCH 16/27] images

---
 README.md          |  82 ++++++++-------
 img/compact20k.png | Bin 0 -> 12219 bytes
 img/compact4m.png  | Bin 0 -> 9639 bytes
 img/radix20k.png   | Bin 0 -> 10029 bytes
 img/radix4m.png    | Bin 0 -> 6802 bytes
 img/scan20K.png    | Bin 0 -> 12516 bytes
 img/scan4m.png     | Bin 0 -> 14558 bytes
 src/main.cpp       | 242 ++++++++++++++++++++++-----------------------
 8 files changed, 168 insertions(+), 156 deletions(-)
 create mode 100644 img/compact20k.png
 create mode 100644 img/compact4m.png
 create mode 100644 img/radix20k.png
 create mode 100644 img/radix4m.png
 create mode 100644 img/scan20K.png
 create mode 100644 img/scan4m.png

diff --git a/README.md b/README.md
index d268d41..edd77c6 100644
--- a/README.md
+++ b/README.md
@@ -11,93 +11,105 @@ Tested on GeForce GTX 1070
 #### Stream Compaction
 #### Radix Sort
 
-### Test Output
+### Test Program Output
 
 #### Scan
 
 ```
-    [  15  26  19   6  48  18   4  40   8  13  32  26  32  37  14   0 ]
+ [   0  31  19  29  27   6  28  18  48  16  43   0   5  49  24   0 ]
 ==== cpu scan, power-of-two ====
-   elapsed time: 0.000277ms    (std::chrono Measured)
-    [   0  15  41  60  66 114 132 136 176 184 197 229 255 287 324 338 ]
+   elapsed time: 0ms    (std::chrono Measured)
+    [   0   0  31  50  79 106 112 140 158 206 222 265 265 270 319 343 ]
 ==== cpu scan, non-power-of-two ====
-   elapsed time: 0.000277ms    (std::chrono Measured)
-    [   0  15  41  60  66 114 132 136 176 184 197 229 255 ]
+   elapsed time: 0ms    (std::chrono Measured)
+    [   0   0  31  50  79 106 112 140 158 206 222 265 265 ]
     passed
 ==== naive scan, power-of-two ====
-   elapsed time: 0.012288ms    (CUDA Measured)
-    [   0  15  41  60  66 114 132 136 176 184 197 229 255 287 324 338 ]
+   elapsed time: 0.011904ms    (CUDA Measured)
+    [   0   0  31  50  79 106 112 140 158 206 222 265 265 270 319 343 ]
     passed
 ==== naive scan, non-power-of-two ====
-   elapsed time: 0.010496ms    (CUDA Measured)
-    [   0  15  41  60  66 114 132 136 176 184 197 229 255 ]
+   elapsed time: 0.0112ms    (CUDA Measured)
+    [   0   0  31  50  79 106 112 140 158 206 222 265 265 ]
     passed
 ==== work-efficient scan, power-of-two ====
-   elapsed time: 0.017664ms    (CUDA Measured)
-    [   0  15  41  60  66 114 132 136 176 184 197 229 255 287 324 338 ]
+   elapsed time: 0.018048ms    (CUDA Measured)
+    [   0   0  31  50  79 106 112 140 158 206 222 265 265 270 319 343 ]
     passed
 ==== work-efficient scan, non-power-of-two ====
-   elapsed time: 0.017472ms    (CUDA Measured)
-    [   0  15  41  60  66 114 132 136 176 184 197 229 255 ]
+   elapsed time: 0.017888ms    (CUDA Measured)
+    [   0   0  31  50  79 106 112 140 158 206 222 265 265 ]
     passed
 ==== thrust scan, power-of-two ====
-   elapsed time: 10.5801ms    (CUDA Measured)
-    [   0  15  41  60  66 114 132 136 176 184 197 229 255 287 324 338 ]
+   elapsed time: 10.8968ms    (CUDA Measured)
+    [   0   0  31  50  79 106 112 140 158 206 222 265 265 270 319 343 ]
     passed
 ==== thrust scan, non-power-of-two ====
-   elapsed time: 0.014368ms    (CUDA Measured)
-    [   0  15  41  60  66 114 132 136 176 184 197 229 255 ]
+   elapsed time: 0.013568ms    (CUDA Measured)
+    [   0   0  31  50  79 106 112 140 158 206 222 265 265 ]
     passed
 ```
 
 #### Stream Compaction
 
 ```
-    [   3   1   1   1   2   1   1   0   3   1   0   2   3   0   1   0 ]
+	[   0   3   3   3   1   0   0   0   2   2   3   2   1   3   2   0 ]
 ==== cpu compact without scan, power-of-two ====
    elapsed time: 0.000277ms    (std::chrono Measured)
-    [   3   1   1   1   2   1   1   3   1   2   3   1 ]
+    [   3   3   3   1   2   2   3   2   1   3   2 ]
     passed
 ==== cpu compact without scan, non-power-of-two ====
    elapsed time: 0.000277ms    (std::chrono Measured)
-    [   3   1   1   1   2   1   1   3   1   2   3 ]
+    [   3   3   3   1   2   2   3   2   1 ]
     passed
 ==== cpu compact with scan ====
-   elapsed time: 0.001387ms    (std::chrono Measured)
-    [   3   1   1   1   2   1   1   3   1   2   3   1 ]
+   elapsed time: 0.000278ms    (std::chrono Measured)
+    [   3   3   3   1   2   2   3   2   1   3   2 ]
     passed
 ==== work-efficient compact, power-of-two ====
-   elapsed time: 0.216224ms    (CUDA Measured)
-    [   3   1   1   1   2   1   1   3   1   2   3   1 ]
+   elapsed time: 0.217408ms    (CUDA Measured)
+    [   3   3   3   1   2   2   3   2   1   3   2 ]
     passed
 ==== work-efficient compact, non-power-of-two ====
-   elapsed time: 0.099584ms    (CUDA Measured)
-    [   3   1   1   1   2   1   1   3   1   2   3 ]
+   elapsed time: 0.201632ms    (CUDA Measured)
+    [   3   3   3   1   2   2   3   2   1 ]
     passed
 ```
 
 #### Radix Sort
 
 ```
-    [  21  23  29  15  10  21  29  36  13  17  36  14  41  12  31   0 ]
+    [   8  15   7   7  13  12  12   8  14  14   3   2   1   3  10   0 ]
 ==== cpu sort, power-of-two ====
-   elapsed time: 0.000554ms    (std::chrono Measured)
-    [   0  10  12  13  14  15  17  21  21  23  29  29  31  36  36  41 ]
+   elapsed time: 0.00111ms    (std::chrono Measured)
+    [   0   1   2   3   3   7   7   8   8  10  12  12  13  14  14  15 ]
 ==== cpu sort, non-power-of-two ====
    elapsed time: 0.000555ms    (std::chrono Measured)
-    [  10  13  14  15  17  21  21  23  29  29  36  36  41 ]
+    [   1   2   3   7   7   8   8  12  12  13  14  14  15 ]
 ==== radix sort, power-of-two ====
-   elapsed time: 0.099584ms    (CUDA Measured)
-    [   0  10  12  13  14  15  17  21  21  23  29  29  31  36  36  41 ]
+   elapsed time: 0.784896ms    (CUDA Measured)
+    [   0   1   2   3   3   7   7   8   8  10  12  12  13  14  14  15 ]
     passed
 ==== radix sort, non-power-of-two ====
-   elapsed time: 0.099584ms    (CUDA Measured)
-    [  10  13  14  15  17  21  21  23  29  29  36  36  41 ]
+   elapsed time: 0.656448ms    (CUDA Measured)
+    [   1   2   3   7   7   8   8  12  12  13  14  14  15 ]
     passed
  ```
 
 ### Performance Analysis
 
+#### Scan
+
+![](img/scan20k.png) ![](img/scan4k.png)
+
+#### Stream Compaction
+
+![](img/compact20k.png) ![](img/compact4k.png)
+
+#### Radix Sort
+
+![](img/radix20k.png) ![](img/radix4k.png)
+
 ### Q&A
 
 #### Compare GPU Scan implementations to the serial CPU version?
diff --git a/img/compact20k.png b/img/compact20k.png
new file mode 100644
index 0000000000000000000000000000000000000000..2ba058fbe4996d019ddda615c5e35c9972bc1e3e
GIT binary patch
literal 12219
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
G?7sob!agtn

literal 0
HcmV?d00001

diff --git a/img/compact4m.png b/img/compact4m.png
new file mode 100644
index 0000000000000000000000000000000000000000..312d5ebba7e5ab0f23da2535e32b6bd82d1ac9fb
GIT binary patch
literal 9639
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

literal 0
HcmV?d00001

diff --git a/img/radix20k.png b/img/radix20k.png
new file mode 100644
index 0000000000000000000000000000000000000000..6857566adea6d468ca3657f014541284fdbe2aea
GIT binary patch
literal 10029
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
IDq4T|AKIRJ%m4rY

literal 0
HcmV?d00001

diff --git a/img/radix4m.png b/img/radix4m.png
new file mode 100644
index 0000000000000000000000000000000000000000..d01e48e5ea0f75e340be00bf90d1c876d5245040
GIT binary patch
literal 6802
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
Y4#V7~xHd<D??@nZ)fZ1HRLtK054`?V)c^nh

literal 0
HcmV?d00001

diff --git a/img/scan20K.png b/img/scan20K.png
new file mode 100644
index 0000000000000000000000000000000000000000..4192fb3acde059ee354bbd738c9354caeb5d8246
GIT binary patch
literal 12516
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

literal 0
HcmV?d00001

diff --git a/img/scan4m.png b/img/scan4m.png
new file mode 100644
index 0000000000000000000000000000000000000000..e42a7238c15db644237b56da2f837046f875edcc
GIT binary patch
literal 14558
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
Oq#&y*Qz2#Y<$nNl4h<>*

literal 0
HcmV?d00001

diff --git a/src/main.cpp b/src/main.cpp
index e6d611f..053af8c 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -13,7 +13,7 @@
 #include <stream_compaction/thrust.h>
 #include <stream_compaction/radix.h>
 #include "testing_helpers.hpp"
-const int SIZE = 1 << 12; // feel free to change the size of array
+const int SIZE = 1 << 4; // feel free to change the size of array
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 //int a[SIZE], b[SIZE], c[SIZE], d[SIZE];
 
@@ -25,125 +25,125 @@ int main(int argc, char* argv[]) {
 	 int* c = reinterpret_cast<int*>(malloc(SIZE * sizeof(int)));
 	 int* d = reinterpret_cast<int*>(malloc(SIZE * sizeof(int)));
 
- //   printf("\n");
- //   printf("****************\n");
- //   printf("** SCAN TESTS **\n");
- //   printf("****************\n");
-
- //   genArray(SIZE - 1, a, 50);  // Leave a 0 at the end to test that edge case
- //   a[SIZE - 1] = 0;
-
- //   printArray(SIZE, a, true);
-
- //   // initialize b using StreamCompaction::CPU::scan you implement
- //   // We use b for further comparison. Make sure your StreamCompaction::CPU::scan is correct.
- //   // At first all cases passed because b && c are all zeroes.
- //   zeroArray(SIZE, b);
- //   printDesc("cpu scan, power-of-two");
- //   StreamCompaction::CPU::scan(SIZE, b, a);
- //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
- //   printArray(SIZE, b, true);
-
- //   zeroArray(SIZE, c);
- //   printDesc("cpu scan, non-power-of-two");
- //   StreamCompaction::CPU::scan(NPOT, c, a);
- //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
- //   printArray(NPOT, b, true);
- //   printCmpResult(NPOT, b, c);
-
- //   zeroArray(SIZE, c);
- //   printDesc("naive scan, power-of-two");
- //   StreamCompaction::Naive::scan(SIZE, c, a);
- //   printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(SIZE, c, true);
- //   printCmpResult(SIZE, b, c);
-
- //   zeroArray(SIZE, c);
- //   printDesc("naive scan, non-power-of-two");
- //   StreamCompaction::Naive::scan(NPOT, c, a);
- //   printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(NPOT, c, true);
- //   printCmpResult(NPOT, b, c);
-
- //   zeroArray(SIZE, c);
- //   printDesc("work-efficient scan, power-of-two");
- //   StreamCompaction::Efficient::scan(SIZE, c, a);
- //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(SIZE, c, true);
- //   printCmpResult(SIZE, b, c);
-
- //   zeroArray(SIZE, c);
- //   printDesc("work-efficient scan, non-power-of-two");
- //   StreamCompaction::Efficient::scan(NPOT, c, a);
- //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(NPOT, c, true);
- //   printCmpResult(NPOT, b, c);
-
- //   zeroArray(SIZE, c);
- //   printDesc("thrust scan, power-of-two");
- //   StreamCompaction::Thrust::scan(SIZE, c, a);
- //   printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(SIZE, c, true);
- //   printCmpResult(SIZE, b, c);
-
- //   zeroArray(SIZE, c);
- //   printDesc("thrust scan, non-power-of-two");
- //   StreamCompaction::Thrust::scan(NPOT, c, a);
- //   printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(NPOT, c, true);
- //   printCmpResult(NPOT, b, c);
-
- //   printf("\n");
- //   printf("*****************************\n");
- //   printf("** STREAM COMPACTION TESTS **\n");
- //   printf("*****************************\n");
-
- //   // Compaction tests
-
- //   genArray(SIZE - 1, a, 4);  // Leave a 0 at the end to test that edge case
- //   a[SIZE - 1] = 0;
- //   printArray(SIZE, a, true);
-
- //   int countSIZE, countNPOT, expectedSIZE, expectedNPOT;
-
- //   // initialize b using StreamCompaction::CPU::compactWithoutScan you implement
- //   // We use b for further comparison. Make sure your StreamCompaction::CPU::compactWithoutScan is correct.
- //   zeroArray(SIZE, b);
- //   printDesc("cpu compact without scan, power-of-two");
- //   countSIZE = StreamCompaction::CPU::compactWithoutScan(SIZE, b, a);
- //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-	//expectedSIZE = countSIZE;
- //   printArray(expectedSIZE, b, true);
- //   printCmpLenResult(countSIZE, expectedSIZE, b, b);
-
- //   zeroArray(SIZE, c);
- //   printDesc("cpu compact without scan, non-power-of-two");
-	//countNPOT = StreamCompaction::CPU::compactWithoutScan(NPOT, c, a);
- //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
- //   expectedNPOT = countNPOT;
- //   printArray(countNPOT, c, true);
- //   printCmpLenResult(countNPOT, expectedNPOT, b, c);
-
- //   zeroArray(SIZE, c);
- //   printDesc("cpu compact with scan");
-	//countSIZE = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
- //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
- //   printArray(countSIZE, c, true);
- //   printCmpLenResult(countSIZE, expectedSIZE, b, c);
-
- //   zeroArray(SIZE, c);
- //   printDesc("work-efficient compact, power-of-two");
-	//countSIZE = StreamCompaction::Efficient::compact(SIZE, c, a);
- //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(expectedSIZE, c, true);
- //   printCmpLenResult(countSIZE, expectedSIZE, b, c);
-
- //   zeroArray(SIZE, c);
- //   printDesc("work-efficient compact, non-power-of-two");
-	//countNPOT = StreamCompaction::Efficient::compact(NPOT, c, a);
- //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(expectedNPOT, c, true);
- //   printCmpLenResult(countNPOT, expectedNPOT, b, c);
+    printf("\n");
+    printf("****************\n");
+    printf("** SCAN TESTS **\n");
+    printf("****************\n");
+
+    genArray(SIZE - 1, a, 50);  // Leave a 0 at the end to test that edge case
+    a[SIZE - 1] = 0;
+
+    printArray(SIZE, a, true);
+
+    // initialize b using StreamCompaction::CPU::scan you implement
+    // We use b for further comparison. Make sure your StreamCompaction::CPU::scan is correct.
+    // At first all cases passed because b && c are all zeroes.
+    zeroArray(SIZE, b);
+    printDesc("cpu scan, power-of-two");
+    StreamCompaction::CPU::scan(SIZE, b, a);
+    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+    printArray(SIZE, b, true);
+
+    zeroArray(SIZE, c);
+    printDesc("cpu scan, non-power-of-two");
+    StreamCompaction::CPU::scan(NPOT, c, a);
+    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+    printArray(NPOT, b, true);
+    printCmpResult(NPOT, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("naive scan, power-of-two");
+    StreamCompaction::Naive::scan(SIZE, c, a);
+    printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(SIZE, c, true);
+    printCmpResult(SIZE, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("naive scan, non-power-of-two");
+    StreamCompaction::Naive::scan(NPOT, c, a);
+    printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(NPOT, c, true);
+    printCmpResult(NPOT, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("work-efficient scan, power-of-two");
+    StreamCompaction::Efficient::scan(SIZE, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(SIZE, c, true);
+    printCmpResult(SIZE, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("work-efficient scan, non-power-of-two");
+    StreamCompaction::Efficient::scan(NPOT, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(NPOT, c, true);
+    printCmpResult(NPOT, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("thrust scan, power-of-two");
+    StreamCompaction::Thrust::scan(SIZE, c, a);
+    printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(SIZE, c, true);
+    printCmpResult(SIZE, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("thrust scan, non-power-of-two");
+    StreamCompaction::Thrust::scan(NPOT, c, a);
+    printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(NPOT, c, true);
+    printCmpResult(NPOT, b, c);
+
+    printf("\n");
+    printf("*****************************\n");
+    printf("** STREAM COMPACTION TESTS **\n");
+    printf("*****************************\n");
+
+    // Compaction tests
+
+    genArray(SIZE - 1, a, 4);  // Leave a 0 at the end to test that edge case
+    a[SIZE - 1] = 0;
+    printArray(SIZE, a, true);
+
+    int countSIZE, countNPOT, expectedSIZE, expectedNPOT;
+
+    // initialize b using StreamCompaction::CPU::compactWithoutScan you implement
+    // We use b for further comparison. Make sure your StreamCompaction::CPU::compactWithoutScan is correct.
+    zeroArray(SIZE, b);
+    printDesc("cpu compact without scan, power-of-two");
+    countSIZE = StreamCompaction::CPU::compactWithoutScan(SIZE, b, a);
+    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+	expectedSIZE = countSIZE;
+    printArray(expectedSIZE, b, true);
+    printCmpLenResult(countSIZE, expectedSIZE, b, b);
+
+    zeroArray(SIZE, c);
+    printDesc("cpu compact without scan, non-power-of-two");
+	countNPOT = StreamCompaction::CPU::compactWithoutScan(NPOT, c, a);
+    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+    expectedNPOT = countNPOT;
+    printArray(countNPOT, c, true);
+    printCmpLenResult(countNPOT, expectedNPOT, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("cpu compact with scan");
+	countSIZE = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
+    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+    printArray(countSIZE, c, true);
+    printCmpLenResult(countSIZE, expectedSIZE, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("work-efficient compact, power-of-two");
+	countSIZE = StreamCompaction::Efficient::compact(SIZE, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(expectedSIZE, c, true);
+    printCmpLenResult(countSIZE, expectedSIZE, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("work-efficient compact, non-power-of-two");
+	countNPOT = StreamCompaction::Efficient::compact(NPOT, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(expectedNPOT, c, true);
+    printCmpLenResult(countNPOT, expectedNPOT, b, c);
 
     printf("\n");
     printf("*****************************\n");
@@ -152,7 +152,7 @@ int main(int argc, char* argv[]) {
 
     // Radix Tests
 
-	int k = 6;
+	int k = 4;
 	genArray(SIZE - 1, a, 1 << k); 
     printArray(SIZE, a, true);
 

From 213a2a074344216fd2cffff6952b092ec6c6ab5f Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Tue, 19 Sep 2017 16:30:17 -0400
Subject: [PATCH 17/27] rename files

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index edd77c6..d65e04e 100644
--- a/README.md
+++ b/README.md
@@ -100,15 +100,15 @@ Tested on GeForce GTX 1070
 
 #### Scan
 
-![](img/scan20k.png) ![](img/scan4k.png)
+![](img/scan20k.png) ![](img/scan4m.png)
 
 #### Stream Compaction
 
-![](img/compact20k.png) ![](img/compact4k.png)
+![](img/compact20k.png) ![](img/compact4m.png)
 
 #### Radix Sort
 
-![](img/radix20k.png) ![](img/radix4k.png)
+![](img/radix20k.png) ![](img/radix4m.png)
 
 ### Q&A
 

From e516e3ce9b6e867fa76908fb5870d961063dbee8 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Tue, 19 Sep 2017 16:38:09 -0400
Subject: [PATCH 18/27] image format

---
 README.md          |  14 +++++++++++---
 img/compact20k.png | Bin 12219 -> 9919 bytes
 img/compact4m.png  | Bin 9639 -> 10517 bytes
 img/radix20k.png   | Bin 10029 -> 8442 bytes
 img/radix4m.png    | Bin 6802 -> 7287 bytes
 img/scan20K.png    | Bin 12516 -> 16106 bytes
 img/scan4m.png     | Bin 14558 -> 15429 bytes
 7 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index d65e04e..8045131 100644
--- a/README.md
+++ b/README.md
@@ -100,15 +100,23 @@ Tested on GeForce GTX 1070
 
 #### Scan
 
-![](img/scan20k.png) ![](img/scan4m.png)
+| Scan for SIZE < 20K | Scan for SIZE > 4M | 
+| ------------- | ----------- |
+| ![](img/scan20K.png) | ![](img/scan4m.png) |
+
+![](img/scan20k.png) ![](img/scan4K.png)
 
 #### Stream Compaction
 
-![](img/compact20k.png) ![](img/compact4m.png)
+| Compact for SIZE < 20K | Compact for SIZE > 4M | 
+| ------------- | ----------- |
+| ![](img/compact20k.png) | ![](img/compact4m.png) |
 
 #### Radix Sort
 
-![](img/radix20k.png) ![](img/radix4m.png)
+| Radix Sort for SIZE < 20K | Radix Sort for SIZE > 4M | 
+| ------------- | ----------- |
+| ![](img/radix20k.png) | ![](img/radix4m.png) |
 
 ### Q&A
 
diff --git a/img/compact20k.png b/img/compact20k.png
index 2ba058fbe4996d019ddda615c5e35c9972bc1e3e..987cfe68c40f2b062084288d3d768a6567e046e5 100644
GIT binary patch
literal 9919
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
N?t?O@RMI%$e*m9*f6f2^

literal 12219
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
G?7sob!agtn

diff --git a/img/compact4m.png b/img/compact4m.png
index 312d5ebba7e5ab0f23da2535e32b6bd82d1ac9fb..10e04cf1b8df380ad42d8ccfe771ade6b3d574bf 100644
GIT binary patch
literal 10517
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

literal 9639
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

diff --git a/img/radix20k.png b/img/radix20k.png
index 6857566adea6d468ca3657f014541284fdbe2aea..26b65cd550ee38dca04a8e0900551dcab265bd24 100644
GIT binary patch
literal 8442
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
S-T40%0Cg1|<r+mu#Qy@i3IPfL

literal 10029
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
IDq4T|AKIRJ%m4rY

diff --git a/img/radix4m.png b/img/radix4m.png
index d01e48e5ea0f75e340be00bf90d1c876d5245040..9bee8c2bde2c07f0fbec24aa8248da491c506549 100644
GIT binary patch
literal 7287
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

literal 6802
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
Y4#V7~xHd<D??@nZ)fZ1HRLtK054`?V)c^nh

diff --git a/img/scan20K.png b/img/scan20K.png
index 4192fb3acde059ee354bbd738c9354caeb5d8246..e280bc719f02cec4ec0df6f30435bb2b68f8fe83 100644
GIT binary patch
literal 16106
zcmbt*WmFtMvn3%R1b25C+}+*X-Q6`n@DSW3I0FQCcL?q_1b4UK?hNeYd;8A*S~+Kb
z05gZ~>h9{Q>f6<IBUO~7k>K&+p`f6UWMw4OprAe+LOz4Pe1`lE<L)Mc{Q2OnCM^b4
z4I(^(eEDQ8swfHtRTq!&Y6=7S4(B4H>kb8l-1qP20~U?kcPJ>KKv@Y<jc-P0>j-{7
zAN-l$P`ZM856oCTo0^{oh1i?z-~!0Blem(HJQlr`7Vqkv?BUkS;-|1%N*ouQ0IOGP
zZ-?!MzRd>?h63DWCj$U(H?joW!CxZKvZQOVv8@C#lan})!kf7{(ms^(^-%Hwlz|&H
zY2-(V4#Uv5(+>}Rf!&+675J!VXo;4Te-|YrBrMPnt;xyBqfL1*(9m=d`!gaUM$B+Q
zkpE!!yHJsn*W-q<Ls}2&c;+-z<PlmnO`h}LtIbt{+&8)4?g_0u;OGeE6-irgvFx>b
zi#Gv~9(?v%pz6;W^Hv3o#h*Dji)y(S@_LJet-jn7o_#Z{z#cjN1{0+k?Njn19}y8@
z76j;D-v0_U80xav>rKP(nNVr-EAk<)Q`?B?vVw#JE9D!AcU8+&G3cWu06;@aD=t5+
zS7`>Bt}0^Wco>Ved;=e>p&cy#2|j9R&c7L#w<1{EqF0QUsZ5%BSJ<oMX-;eUE9v}O
zUm9erRBfoah5q&7eF=X?m4rinE}~=JNyZHpElmzIh|IcE4Z54JrE5Fzl_?m*)t{5o
zcvV!kh2jY>d0q1Iej^Sc(km5_ljrO7gMpC|5e!sJ1bzROf%m^v9m{{(g>6F?W5N3W
zs%>pLZE@bQ7=MzpqEg-L!!Aekzq~@jUpLMuA%j*<Wo}pAJ35J~PTKADMjj{e?fv!T
z@eR2lY-(}GsvUagK~r@&I&S;1!mU@g+rz8jXWkW%ypsY5Z!%PZRWT?HtsW6KW!-XV
zpA!`4nVQb|1Ph-qY(kZf3&?wYQDk~O+UySBtaR>$eObAarpXz+<F&T-XRMFb3W97&
zoeg*a<8ejUX_(oFC!#ry2~2|o<4Oop;^16K+<egBL`y8<4ETm0sQD!HrhH~ZXx~v7
z2cR+(JFk>ly71OoFL}gn**>)^6|b;f%8D3y7Fybjt2g$Gpw8Wh1xte}%+be|**AJ$
z`O6b??x<EegjI)WyL8!rj@~dLj-6UB@YKilLD1b8!+E(FkM<CC$ozQZe}6Df2EU3=
z@mj*|kIrrkF+R=X@_T>usWDO+wza8+?CO7Pb-hJUJx?RN`6G;vwr9`b7i&(rV>gw$
z)WfXEk@mP2!=di(xfrBX<zwmZdwVzO3F{FPqx`Ox>CU9qF%x~_H(e2{?j&>ZD!=O;
zASO6SZ+rfHmL;u$)7<-IAFkQ4HOdKGx|&?a?)oqxjW;I#1!5I6a(vA9TP*~QDjR>*
z)C(m7^Ird~4cGQGD+r5;!~AQ|H)mkUm;guz{F1zmXc!q=4ynr^vAq~LH~$>Q#tJbX
za+~!7bGs{4^PGC>Wa@xl=UJ0u2Bl#&cw++)Cyj!#y?(xv4;Q>ienHp|KL}7Y#DIgi
z?KIR%`%BDm57z;0Jgx^~#xinD#${f+^N>oh$v+qWXrk>N4sQt&8ge~Qmc_zXaFI{O
z=D^s$h-eA_&tAWNEEG$1AFJOh{>z+PG%b(c6(RO7P#D7Mib#k(%~uW2gH;Q%5;N8#
z8eL!J{n^9V4C((3%*ld{n#kmkK@P|hVD&0!zo(848@c2Z&#1=ww_ZdxVO_1;^1zqU
z_H|>Laki}bHLB@56Nuzc()l`8ZCx>45Mcb$!|oXkjAw*siBAJ@n|#s*XThMrz&c$d
zOL-dkf;0}l3;=a;sY;hK2nTnJ<3CFZD7?`VYug_fOvwA~@J!KajIe);wtHJ3@i7>(
zp28QCK>mQMK2c6VIj!r=^iDk5vXWcrb=<K!>c97W*jCFfo}9@Am0He?wQ2cQ9yu?~
zvX_TEs)lNC54n;|QFq|n$Oz~}mN&_M(WdVaA@vLmwBwGMMN}odLc3`5{*x+kWRS?m
ze^aX`CemSOwD2Q8bN+7@&4Ssa%f0spfXzw5E=jFu?yi`)H=bUU9V+QmWQ2f4b-l(I
zTMQ9h@<q-aO{zUkn_}W(%O!OAxZw!1%P%$I^Xl)0E53mk*Mg?>x+Yy0%rZGTDn9}o
zX_-ns(lE^#uL)pce?%_vQg=hU<z=EKq>&;E&WQMt@VO>x#s6_8esl1=In8C(QFA0`
zeG6j(ePG5L+!_8(LcCCoH=&x3Wu)1(OjA`R8fy?kSJ8&;p|dNbr5<&<LdWqqB=&B=
z)OdhR%KTYMjY5w%Yxv23xd}(;vG#|bUHQx#YRnDv+k@nv!=+=@of~oScLs8NJ`1{J
zg-D;#=_u6<{rTk5LW_sbSYgu?LuGj<mh8lMGeN%#nlO~Pi3dmHoWL@B7RA&BF0xeT
zIqY0pFaE!xbgqkNyD>`<TijAr=jluo9e@WhBKr)?N^o+G@`g&GZ?wY~YKg&oVBUEp
z@c8E>#NfZe6>}RA?e=fqBqgpS!fGtlqnN?1a0CzY<||3LX4kiOLcI)muYdcx2Ofx@
zQPu)yNl>2Tc=dW2_6|p;qA9IC@Cae-&5GY?ptphH^FAz}&mtPC`t-oOi9*Z{<D>J=
zXwxbbtK33Qw@!ZhxyHl#FYg%Y2ijqX`}+;>iOK2t!fcJ}+}!Po&T5<p`bHmA^lMVQ
z-xNYqD?WI{dhQ)AC;VKcE0}-Y=IcaTQlPW)s>9{@$w2dl-)ABOI$+7qlM1WeTnT{h
zUU&JFh7QE#ca`p$q_OBl%|HeqM6e`O4IU<!PNQng6s|i-6a=gpm3P<hS9F%Joek1B
zIR-ga+3KvmwlZNCt4s0#0fZ-aIAcV~Gd4IN1Pm9WOn3`e_}gE|TwaPG-CJ&?=!l(Y
z23&Fiwcj^aMupaLG~Jtre)S0|sZz{vmQh%FAi!|Rm+*%BAE_NGt)5s8*GEOPn>TPa
zG@T<7n7jndxf)rjgn}1e^Z?P`y52f`cOMu=+oXlX>VmfgdVVvPrp~xv$qm|97e_`^
zXDfszP0|>7UtmxccM~+qDUk>vKh0|WGI=g(JLeosj>vVtM`R`FA7|sJYF}=$(+fmK
zQ|0mG^eUzE_8tGMHHx`dxr{0$QTUUQps4p`xy5V8?fT%CrkmcF&KfJ24AKAx63Q%O
z*|^(0#p#=gSH92Htp;n2ax4BudTK+dmn&{Xe{w<oGlX2dA}Jv{!nb(Rd@6S0jn|HB
z0Eky0j<#gi0jR%5iHYktFt8~}1WO-K$p<f<kaUKb763&n_H=ih=f%8XDlDRW6H%<q
z=~4nhB1TB{Ip5B+<7-dmd<vD9h->AD6L~&+fqc?6*^p?_NEVQPNARK{S)R1y^h95D
z|3H9Kgh)EtP2H;2MX8f3CZna>KGm%n4?YA&hT+>@K6ma?IN1BcPz-h9Kx9>Gj<PX(
zKb@vjCfUkF_wia+f0p7%9zDP~Y3_zz4E6e<HQL-L`ORdbL<fLzL~g{}@vycxgdrgw
z$?>goXDt@V_w9QKhjkAfulJJ8o}yu1=(RPZ<x`~Cz5$*I0yDBb#vsMA-wwAk_phQ|
z#~9pBW#MCb_W?11Z#N~iUspPx(a5iHuEsJVb~dB+y-as=JX+Ilognhi3hG>Dz&dS@
zs#>EGrnL?{;SFczTZfODCvAhJTN+IHAE>jGUmy5SYESm`Wt3J6NbWefY=zFVURcgE
zZ@xoR*M}D5avx^?$3JVnYoaMZ=guMBv6$FdG!g$f^#aF)?B}nkX(x9lPSpX2WnZWh
zp>M?2J_H}NM*FJ^&9#OEX}WfADw86s)g|byZ9kthxRszk0~_Ag{))I41q%-kx=`Vp
z)IWu2jIPH0jtiOV(Y%&fi-A4#hkuyxRS_2Z>i--UHCElvw1>l^Qbyv16S(ryITb@n
zJGWyVmH>fA&OAWH{uR**FLL<tcmG|l$IGvb=t+Ec6h_*<vn>8GS^ykOGJ5}d2$~Xo
z*qG#b4=33j(@hJYbVDCnN$|NaHhE0aytZ<}$Kq_2w$K;6I2^LEMbjJGVFzN|p711v
z&vSB?s-~$~ENbPET?e*A?10MR8ouqcb@vXRy)RIwhd+S&ugf<3l;8h)J)U62v#0N>
zH2%;XnQHq57T9*<`@Yi$wQVPzSn_8~ysHzB(e-tMIDFdy`#tcxL}IP&BK9koJ}_=P
zlK+-sg}_D`pY12{P-e#)k}`N&`O;>i1On%Xk&N{UH=~d>Ie$urKoFq~O-;CC6(Z}%
z8QaLwkAUz@=Tb6-K!egl9+e)$x`@7++11cv?toD7?2}sxrz35xt;i`q42tmhKk=xN
zGCch&Ifs~inno~{uHC~OQ<~PpgM9dC$kt~toS6+4#)rjz50PLN5L|lJsDSA?PIFMs
z?pyyf0UXDNj^4=9cyVf!?L&fGF|R%{@RvWU*<qH=&Uug39d{HGiHEZa4jdu2Z6ACo
z@b7kW9y~{}cSrBdFk71c!k9Wl`|+HJRu*v>grb)p*kwjkZlz>1@5~E!|JgwExup<!
zc*?q(+*jT@D8qmV3m(h@hy%FE{Xo1Zp@UVW4AVj|c_V_2r*3^ggi7w@_1~k{v%ekh
zU+m0xYUY@9`EbG=8OCpyO}%3TXV@g@xY1#uNp75*lWc8ry?^v^RT73aI0pXkEfI`k
zUh9+)7Ly1L+E(BgkeOX{Uw!+iuXhYlmZ5d(ZjJUU*1=xPY&`0;Nu&smZ%2LbZncI)
z@V10BLO|OQZKL7+dBxhSAUuXoci6jbE3|Ey?6WF4z5-ee@a6RIv{I_Ag5_3&jvU`5
z3#D3m{hrQ1v?buvUjcR;6p#<0v5t^DWN<Ci?JySVOucAT8>Yk?c-5`aMPjmin}p(;
z<5=My_f>kqUIs;DqH6MFp-YO-?1?atgTiq{l<{~{_Ox;_u2w&b2LC>LEr_J+mh+T<
zy^v(OuiYG8%Il5!_150F_xIXYFb$fnEGB;68hr=u&1jGTru!gMene7nO`6afv%}I$
zWx&AM#5Dg^##3Na{(c)IhSZaLLLv>G?ep_g@p~}E;ctC@x!J|#{=k?Ezisu()JQX^
z{tTKp2ipLoDW`XwTcay3|7`mXIE*WR-$R|`=@3;E8YJf4w3iSA<s>;03Xe|k4uy9M
z3Xs7O9Y-f4UCISC&R9_wQw#Cvstge>JmXIXP#uzJ)87+|Yu;_1S@}9Z$I@$x#@W^6
zel2@U$mSS>zeX+&f%@MCKC@4M|5;pvBkY4e@BALC%#zDzCM^YlT{Z9KFu@r#Qj!6?
z(a^Bv_y*7Z<oI7^ZXq|LXX@_x_|~j0<nvc_V&IMS<JF>fKt>p}Zel$l64S1pupf~{
zZ)FntL(v*^23Dx4;|&L$`1>Ky|K3vT#rxjhbL6nJGuQruIkQbZ51FFzRHtzfopmsW
zzafua2(=ux>GT9EWar_dQ*q`&0+p$iD$CP9@<q?1>#bUvr=l_TetQT{xsJU}^Deu5
zmk(9*gY52mKn*&-Vb&eRMsdyBwAU`bF)%ph788t?uT#{So7R!=(=b}Ev%Vp14E@jB
zU{0M?7@^n2UFA9pBM#&ISFBnoU*xsH%({JXr;&U{nF9&ky(wN}*tFR^&EKKVCD_Xt
z_%1yD;do*~!@6hd!kIM45c^iI@n5G-FFLZ{ysz11kJirLA-KVtz!c83-ySIwQB*{-
zql=o>Tl^(irL{cfzpJJSC7nX}FgD&&P$z4gG_yY!#eU>H)2D^yHngbqt49^f@5|c0
zSOttvQN9ZAOW+EevrGrPy+E$R>qYd|RM5R`8F6#d%G4GW0p_m7-{<-DsYjqb_ROuv
z+kpRLZ`z?dZWei8QRv)4mA>oSt2YEv#^7_pBVaT1#Ne?v`fkWAWn&b-ys5jpN2}H?
zg!xR}bWSzlW&F}yJ1Ae?svf%ICoZ=0O)#hEOKEt`Px&*m^kQ3rS<3JLZe&j|K+<%<
z#Kq!NJ%yjY<vc&OzH$z1NbVH~0rI+kUTt>lCvg6qM-o|S1JjU@OCiim$(vHPBQb?u
zm4Dvx#gX{>EY`-Yoiw-tM(T;4%*ii10PfGwCu@(4R1$jz)?@rD7bnq8!?LKRf<!p$
zr;oN$?v5E9CrU3NMNZo8C=5}IGq;*o2X=&Zt5qbf-2P|l_lka2Wkm1SRiT7K#L#gh
z!qs9Yp*Ti8<ILSL>m6Pd=F=?pT3@~B-L)sdBX>@jlqFo?3e&u>=95NpMI>8$SO+c(
zZvHJVtGRg0BtYqSozh2F$SJUo!z3=Bc%&YMC_lIV%j~Rti(ef{L_EFE)G>-RFSE;s
z&q-a;SpG0>mL%^R<+ktRrD<bx^Uls-^s}n5n%_XpR{si{##wfrd3Yx$Y^YHGidc?u
zq?Y?^+8DykpXSXY&G&6L#lOXMBMp1J)@1IWn8mRh@-iHq7lFcXm!89PRv>K{#I~H9
zs|VZUt#2vLi)$7-D_G2Tz6w00v{k0=CV#4PJvzQtN@SN;RFw4e<SJImj;gF=0MiW8
z+e1<^_+nz5{@FHN1o0c3SeuWhkbpH9?E<ZfU*zWImcVa`IE1na5A?=r{rW|xQ8e)L
zU`0fDgGS4Nt6!6gjJ#@(q+|pHi#<PIJiIL*uGMq+H=Q!|)t+b2(C5Isyk0$1V2=Cv
z`uaobp2M1bx~`PX#$9i~;{ijvoEw5w*WDI0u9*6^PXo_IKJiI$+(MReu~8$|vMFaQ
zeP7)Nq|JCd$8i?Z8gc=nMM<imkqG)UZi)~K`fyk&Oo})?GsPVHz}omqzU-Jk7Z|~M
z0?eoGF$G@7mB3#HD@MZI+Ymy9CXHt(i>JgF;!%+RkSzh_=!8tIJN7RUk4nlV0T#dH
z2gs0S(eIg1COBuhp{dUb4P7cR#(*o#h4s0XFQ=`%Xae{5Jv|h!>|Mf|h+y(Mnj&{J
zN{eeO6n0oVW0I=v+(QW`24XNLvcG-NrM;kN+l~D`Unkx7g>={SYphOOY`0PTg5yTB
zUYPr9w3v9hFJH<unAoX>OI6^g=E%O?F$RAKl#yO8ET%;r#30Hrn<F+U2m<}p2oezL
zjU2dNye$xo0aifc?GmdkW)Gw6#*(D`a(q_;!-<^Nr?g)9PW^qLF_I*MfZ}EqMdQP%
zeY5>~*>Zxc{-p(KdfleR#;uV=3ek_et~%TYmYn8x5Um|~m@Ms!$XousJzn}^9+O@y
z3<X^4#5(EL4yjghPVtl9=5~ECuAIM66^Pd3=>RH`GRKQAb67MQ@*ofQrq#L{`}Y*r
z%<XabRoHw!H%uynOy1(tb#E~2JbGqOjFOuvDCFY^@g16!(Mll+QeO=pvc-k{RL@m|
z+O4Od+5?8V)UT~8xru;FR*&2rV+{~*2M+vn%R^FC$6Wi4z@fsGbXZMGlhd5olVq-(
zZhBUil@i{dsRIJP*Eta00<Rt!b3~0unfUF4RqST`#K1$sny*A4<#*J1S5o}|&A9mE
z!0OG9YBNJ7gYm}+yk2DiAz?otx3d=gRlo~9&e)jI=|b`2Y$eRqLVt~^{<ze9?Aesf
zbGx4_ba)-39CTY-o37zrvv66QBZa5QO1g4F5aaVSX<um^*dyC{m_KDx;^x5P8SPBo
znyCl8Ss|*opaK4ZgarX`aAptp`prIqKwVySU;^q!b?8+wcxv~XbacR+_Dk8*UmigM
z>n3}+-R`$ng-RVh)xhM>SsH_E28^o|&#?8XM9O$iWW|N&17B`8b%~rjPMKA9wLLdJ
z>bwoqB(g>E$0JFq@*JLaH#ZCYp0p^&ZF*@{uShc1zDb@uOhQ^u8_GXhs^alAV{Pw{
zE;DEI1A7@~3_~=>0<9ZX1#XexDBm4*oBqLDcv2eoF>$DdJKzzQDd&nSz3wVHe*skr
zbG)$4-gjJo$?p>2v6>51b`tiE#vW_g78}O&P@uDX`EjMw^-bWA35BgJ3Xp(8#J7hr
zBIUtg%8(~OcUAZ%10`#|P9|XW<e@nnM7X3=5>`JMYm7eTPV!XVt}L#N8P*hgGrsWz
z3hu<hQEjD6D3aSK(i{&OY1?C`#?AxJG5$Tn%Zr;FR~#PuA*;hB{1Jlej&UV(>(myz
z{9jy-=V-xyIkkpuqt`_R-WpbLHu6XaaW4eHl%4`F7~q_aD|ryJvfj56$d=caa)vBh
zbWarf%~eY2*xOg63<$h<rhZ<dp;&T%UYARv`IM2yaF}ShwDLPCO;qd=h&@zd&{FZ4
znU&W36Y<3OfVg}^EAc()&zs>HOU78kA-x4Pv?(QDjJC44%W`w`Qa;P1x1OFvI`3WK
zfXR|8dj$~TeB$I#jlJb9XVr)DHL&8<wI|7w%R;b@{Ly7c(|p$?BaPYzrp*Fm-nYZD
zU_n@<QqKd^CV}NcUWwk&OlV68LdCFFW*BIjb$8vjODd1L&}I8Te@#_xm+?6sQImwn
zMZ|ETe*t}nU8<9)T`bPT<5U?$Ki)@vFjO;&aM9<#85kC8yhpKf2o#*JQeBoaxu30K
zG*%Dg6gqLux`=kk!2nI==P4G8I4(eYcVJKSW_GM7Z~mAacG7GK1qy2&CgQ{#ek~QH
z)U4AORs+a4Ik1%P;Zbm#O7!W1OJy<3cSTl^PY0gg4fkdr0f(sw#1F`hKV9Nm4=fh*
zwMafRr7f6v<Y1ZxWkyd*n!sgV@3&pIdNn6x0yMM`%&VGpa8;Wu#Ft{j8oYF}PQIxd
z6QzM{G_UpT?y6PPe-+A||0%a5iw>*&ZH}JGI3gnD6U8SLEDj=(cTfA&0MzEX)d$F<
zT7&Ue>U4xr1>a(g#l)6pVvXw^_cxrO(vXi}$z?K6+ybE#p6fk_iTbLfzJI2#7Z`Rd
z<yK1ZQOeCk5S`sUXTA+<p5ksyZGBzJZE1(Rx2zPA!+HSrZ7u^!i^&v<MZi`k>W^>o
zfj<ttUh9=vybOU*i*L%iKN*W`o(fS%1#jl=W4qs0^{;A*qUU$W5D$9EvJ_4?Itfk|
zs`{VrPU^fajIbuu0L;WU`hHH=c1!F53*6~NbUDwT5&}_mF0X%my19SXi;h+HpU0S(
zdAutN^qYPrTAqftA`_Ml$O$KslyX~f7;$o%CfB6c)>qr<N~bf8|LwO#kk$BYk$mas
zkI;wx-UGKh&59QK*c$r8p*^cc9RZvjUj<Mzyrk#JJDJMfNMp%AtS<Zq`YA2;onTdO
zV}``_C#_07@F0lDcreFtQ{=F$sMYxj@%8b9d$&cINt52&)#-XG@%Y<pv0`aW&2Y2h
zssKW$Op4z{NMN5eH5g?LxbVm8QLlW@`@O1@mjtG`hA6>Sc~Ootz&7voja~UjdM(zN
zp58b<HtuvZuxv8|U6V7MG{ps=LKm7w*A<mmA-tCo?&nL931n(*&_#J%Gt<B|E-{9_
z#nqRy2y5D(RWwAVn{)Z`L>QEpyKVI(-ns#Ku;MJQ(+k`V_G296v^`H!I(aJ=$rkb?
z0A>G{<n&_9<dov{lnut2qCjDS+fo*Kl28mzidz12(PmMWw2x#YW{KLj6ccOA-RFzE
zoQ?MEj|azz<UC$B!6qG)!(Mz?@oGE&qeCRn$>HETV2U^T`)r;DDZk3E?vbDpg;A1_
zhmS!Wi6Y(Nu9NA|SPuU7%f)rzJ-;TOG=-p~C>>~B&(NLQl3sxLoEl&pXz?CPRq4mX
zi)#Dovl|YulT`{vG#%d|uOInxM=ir+|KNx|l5^DHxuox|vUCWn=l>{hSQ$Eoe8bXu
z_map!0Fu~dS!mht`wJlC?JyQT9#4k`oahtG<`%ZeXa2Tvkxgsj@RCh&n2^P;(*R^~
z@-LX~svF<fzP5vz7k5&nyUR8y;8FTB%x1cN^3O4;<Q0p^hB{O_GtRsAGVZo|)x(Sk
zSd=Az(`GR1v;bM7cE<I`X`=Yusqbes^PjOL7U`h3PYsLNd6Zo9?Wxs&HFMOUv~@Kx
zpqfEe8!8%eGh!g+?t<r@^iP6Rihw%8{&xR!^@!Cx-7=|Wy~59=Bek%`$}+n_W?LwV
zcH&Cl=(UCa2}*qDYRT*hsroMqT1DMWKKEOlsdB^9dSXBH0rU~{i33x6GR^DCTPX{G
z^J4sColA;Cf?&F(DcZ8`7~~A6)q3?OBIy1b#sVBoDr8HQ6f0CiZt7~PTub>1(63s#
z+nP~e$Q<P!=%pfBsE;WQsei9+QUy%O`NGoL%*JQx{FdWFn0w@W=^a+N{08_Zi4{1?
z)~CDq{Mu#!<n5AC3~E0sR#<EJ23;bo8=^5hvu0@|H%qE{4P-^Opz10ixx)CUS)aiX
zFskCIZQT(N5^Ky+`wf)wIUAzeNy7`GjR<+cpb`;T^E8dopHj+NtE_UQ?oHLb)U!D;
zruH{#nPTO8SyJ6aAON+o;F*vOwzy{fvh>tDp?-jF^`<*_z`E|U`yO`XTs-PJj~0l7
zCWcmp;6X4RBfEF8<s1SW;L@Bm?ezlBnFyvR^uHtOkIzx-(hTU-jVnOh5l{agN<kB5
z)dCO{UX4Sr)~Wv)9^}%0b@FzxNNPR=4gNCSW5T1ZG5Wkv@3t66ku~iOc*HEdag<LG
z=3eZ4nS}uM0*-XZnJktXEnJr5O#HxAT;e1#gSF}80FbJ%_(;%Avw{o4be&lP5G^`i
z1frd#DgBl1w1C%m8P#u8=|XB~aMH?N7(cLfd7dRrI@SrRRL&JTYvW=rvP~B%m(?6K
zulZd8QDlK;y{_*#aT8`q+m-#$H92SU<PdXI@<_-{Y;~2Qt0?r-dT@>DR9TOrNE%34
zP4oJ4L;tELsqCALEq2;8;U~6r*{~9RKE63eIP>?LVJk?ao%m{EH<l%HDp*Fs8F@vw
zTsi;5$Mv?W?T_E>^fLBS=P}gz<ROAQIE5XF#@zqp0l7O^UT}k(BbXKDSZtMT>2Ok0
zvz`H4ERi~;Cgd^_gL<yX;B~PM+44U9fyK)JW2WOJU`=c1mmJrP^J@~F_Y=lD2r_5*
zF!ps8+w+wpH<R5Q;T{O|hj^^c=5wm-c&*<RB~t;ODSEpU6oDzBjn0a(Tpvt~ywlL-
zUPXG+#t&7Bp9ukX6o?ms5g|EUC6qg5a$GXIi>byb<`2=`3-PrOOvdcizcS>h`oUF)
zpLhhb6iJWtLZBT^yV~<ax)Wj_w%Qj16y7%)!<;3;NDO!ZsidjfHh8J2sQ1RivkF{^
zxIg_g4C9sD$aE2QC*~+{bH1V3E|mz=Bf9>_Oim_Agu)8=Hx}Y;x{oJd>}WxAuDZ`?
z`6JN^JOr!m%krxIVEo;vO6N14N4kyW7Gk1xf1E5-HW<65!PQ!adp4#5-tRGTOE!O!
z?BDHlpt(8g46|{x(hAj&`4qdm$Xs;*S+cu}1j0TFh6GEGmaI8_%FLGv4`=sMjR)z?
zkukq|R<TejN09A(jam&bjd!IM?I;|ly0U}Bg_hj&ulkTU*<g;F;*E!b*q;$jq!(I*
ze0R7QGJg|3Fy+J*xep)3|7l9%ER7vvD8LsASnHe)N8}|CpBn84nH!9mdN^wIb1Oi9
z+cS9ZI93#y(IIuLd*D+dTD^+Ho&X5N8b_1(Ld$pk6+Bc3R^C|6y6*J7ec2@8sZZC!
zs-+TfvK_Q;Vn?ai|DYMs{EG&fqF0sg@O0x<ud^y#UGe3$@4Crj<O=1%WJ>g_QEQ$^
zu}Ejv35pA`QT%xYL`^KkB9=(qun&{nvEw#Iu)4nOot=i7eQvTsn-TJ9Or~aI!^c-}
z{SOo$4AT?pQ6l@FbNE`V)UNQ;w%fW)85YG8fcl=V6RZA=n)MpvYMisAsu$}`ELL;!
ziJEh22ej>!(sHUt?%m`i$eKC@QFY%#^}k=Vd8Q!D?=$WFLu2no_cQQ&a~WD~h#9(~
z*S1g+on#Y+^I<}V49t~R<go3`ecnox#;xBV=L<iwLr<|_&F<WOHY7QL!(Y60916V_
zcq902YoSaap0F6BTJW#k>JNDw5c$=smO=YcTnyy{s@=k+;qh}=MlcueICspxm=I+$
z1n;{U>0)D>?k<`nJ)BYP`Lgxt53U>sYlCtSN8CTtjQ#MRB5zFA%%8_KO@Y!DmZN|A
zp$W3eIjrdukyiNHxBMCjfYio-U&%jWgV6l8cVZQSd_3(Lk%6vT$F&I0s?4_M$H%RB
z4a0&lef-$w2g$0>6nn~`k6y&Su!1E<(ldh(8YMS>Lq0wiaE}NK0C|RdH@{fIBM@{y
zw|G3@y~?kD_*Y*+5($*Wqqr=gcdIo!l6ZJ&F6-l5lDALToD1ZsnSLW+L4XdJQu{SS
zxFQvS(>L$T6OQ{#424D%oQzXZSojHGiHxZ+_p4Z{LxPc}38z}_rOh69q8H+%IL%<<
zz?T<h^D}$n;kO3oTet%RYirZnePQt{#_m4m_g85e`g-<s#l5x5JpYT`?>C1$t=m&B
z*LP1cw)nvl{q!tPeZpin#{`R*6M_^?EfIAOQ0lpVght+=bS~LyZG!Ka+&=46`^R-T
zcD%ez<U-Bne4-LK4iF0Fb*P_NY<CuhJXyDmYnfT@pCDTO{7;(g<{j+R9iU7h3ET@k
zLjP*PYw+<^Fniw81+y}8sno%uPgkhOCeL6&t+4ycG>KN+EdtJXGqDeja_23DUr8RW
zGto0vyNg2LfZ{?+*UB615<C6nRN%Gx>w50%XoB&kUb(65*h-r_^+w>~`*y+N!dB1t
zc;a<0xdMOvCw5TH&~3=Ogw?e)*%VR>ivEwAQF+$@F+87QzeS=(x3-gf_|3v1{q={E
z8jtWA1>K~}l;d=#bdG?|%g1aXqUHLPMgL9TFrwuE;x>wQ5)G}jYR$<$D{;?;kD#8P
zqR*D&^iXyuP54WDpSw$#%hKglaJE60BZ&5!e+8^LKe=WjnR0n=Q>HH$IW8=C<4<u3
z#tS;?c>r-ue)=kE4~wk<y-|b$hr!}Lc#1dB#3f3N<VQa+%&)raKuJ<nF8B@Y2|>}L
z(SIs5`{3{%Oiwi!Eo@a}P)X*+p5~~P{#|sj@z5Mz>uZJj|C~?!+4%b+d|26e(czo5
zHU+nUdhnL>WOL1nb0)~`INOzLM|b1=1tGyXF&zu@F09ri!`NVox!TA8kK7B^qvufK
zC^Q;tir=^|Rh+<;b^9YYq9#WkBZ2evgP+xCzYd4F4N~l9y`F-TQ{;I(L8Fe5CIwyi
z;n2d+*36vvy%_#PwrwXaW2F4%kNooqcURf5JazW;OgXN~;_N@SPhPs;V^(ydMxr24
z^D9_L$Pc=E^PWM;qchZ07UKKNx|=?GDXT6ojj(lW7x!eW;L*|$FwSKHlWkd85gl>v
zZ|zC4b7g0<Vm@vG1F>(nMCYc~_#A8+{$>waj4_+4SoNxSuoOXlQyAS^@^0w5SpB?8
zjlk9j?v}Pc-!3I%aNnuWe?E7K8g>GM^{IqHq@8_nGt6gi3$6fj(8Tp(scm$r@;ucs
z1`#23<4{#>TA~x>-~Py4%0Z2Hjj7>fWwrm1l_dy{)FZWKY{mGAvoUIyVFumL8zxKY
zycB@$+!+Xule8gb<w=p0G<6c+Zg?asz7WA*=eA9u!{gW-z#;U=yhYZspDtQ%_HRY0
zq{#L#jJCg%?3TWmwPp86<@J)Q=S+ytp^t$R$?V~_;oNT;Pda$4GtAKYd4~v{J1U{Q
zJ8weZ59=_5MYKRvl<}8HIg~L&Rn20r(=+6hfT1^XGBvOq7Q=k4YmQF2MewJZ^02$&
zDwhf~PGv~Ot&KRp!a_Gx!JQ37HLIgMIC0w+Zo3l3Q<E%yG^0RR46_3l#3};acGW*i
zm+(O1svTCqF4Vhsbn+77Cf7&f=ktbRn)@cB5LOR_<;un30%5(dhZV(=9oKSsB*5!H
zf17aA8pJj|FHD8k?Q0XR*NN~>&vgGuOUw#nEUzj+$nt77UGEqc2x6d2rdC=HK`Zb(
zq$;5***@2eH*51uT&)u+H!i^E0%6F*HVNC#ByAs6qIIk<ZZmn%YSy;V#qGutm`U<v
z&%Nyt)_JG%S<c}?-cB9|U7ArT5;mW=Fol*5*NLQK@YiD^+X&{HbnCT<m}krP!Vd(k
zmQ_;ibi|gHZjG7H2YPW2qb!F38Do^Ir1#?nSmR9wtuDjAIu?}dOc7PbJ&LhM3<yKQ
z$ir?(Pkt{2w>0O%<BphFJfkV(yiuvmqChU2F)CewAe;oDKE74<%<%kJmQ)vHsUHv>
zRC*?!xEx|t#M!#zHqa4&JuQr@L@@09w%^Zn%IEW8)1MM@@?1r23w)tW;I@As*&{zp
z`j}{X;(fCz>7}-ro#!;=uTqiR9TAfl>{ZS92b$Q8ACs5c0g_SYcNpR|Gmpr$mqp?8
zRFjtOxDU7rM^Q4L&1s<fH5dqfnmo?j!Rhz@K5}VDBiN~Z^|s;Z_w5qc9&;)b)_9Hq
zNmeiGZ6GVJ#>Z7_fg`lFR#_BqE!8#MdHCYE!{<%J69MZ3N4neEe37*MtlLzxZb7CA
zkoO<_u)yKHiLL`FI>@MtkV2q2XJNSEH_xy37bI4QhmXT9$Xjj9%qFFfVlz**&DMk2
zv|6WOTdc7+x8e96@fM4%bKcXE2rtA#sGK*<4$;WIUZvxphLgYEoPM1JO&3WWH&pRz
zc|dMPLt(M2xNX9oyO5iRGWkEtDG~QK>wi1Z9|1(X0%&+gw7A)+A*y&7E_8Qn$W3Q`
zDfAnI90N;paOr}svbpYKi+o=*_?+_brB0nc#G6>0*8*{JcxFOn%W_R7Y7JM6)5o6+
zzzJcDwlnxmBmP}FPAJpows@g!sfp?1hg12EftyCbDto^#nt1$8VB7g#w5-6U)OS7Z
z#K$WAi)ySdKUq>$QeBGkLbv@s7G{iJZR2?`DjEe%0NLRGCCk7GmIOnPr|G5E3vY)R
zCbw0Gv89Y}Hs|I#Ci=xBZCnTY43mbl+X-0Blo2Iy9%StM<}vN<IFZ`?x6&_Ule*|#
zQVppFJh729l(v^iDyi<{Zx%~F`+Zlnu|)0qEyy0JNY=|)>Ssl?uMe|xFoAKt%7=QG
z1!iY-h<jFvB&W{W_PXPK78z-TGN1vCN`~}3IE(4o)grE<Zyt;6{$jdxd(t>>mP>gK
z4(Bd{^R)?*f)2Lftlk<8dgpF?DS|SmNamr8WO?+W4mo`TAlv*}8S_Pgj+ME~rmv=1
z0BYoZ@C}<r5ildCk_14K!x*&w!he`?z6yCan~cmo3#!5c*=-(RW0oP+THc)eSE1`C
z|G0pTMyNPGlS!x$_f|-J-hpfNk}Ym`Y<4vk+*rF|02y8zeiIkdEtVLaD>aEZ)`sT!
zbASv^Bn9Dl;WsDxvQQl*bdaArO_Q93*VTp_6hcDhL7alb;zW7@1CBXgvZ;j}IdM*I
z9?T6-jI82Jyc%hJc%XU!QVie3`&&;Ubd4PJ0Jm5ENYXX~mMhl6H=z$tn>b)0=|26=
z=0zM(y+v`QB_l$Jfih_{<7AC(%5`Ag*^dkK&;se0et-9_t%f&`(kkTsl%%8|r!h(v
zC1?HVA?vuyO@LQY>>&d)US$T+2}RNfrwCSQ-EzzKBNg<4TwM+$BvW~jpOJK3cBYjf
z3Hk;>`KfHB<ho1ps!?*eFIc=DIf!3)%JH{+s}1+XJlYU=mzzrGyVE)wp?N(lS-RG|
zG`M_lK_6a^gnx&dI|ilU0h3vw#~YQ~+=z8S)UfrlO?XomkCwSAsr#Ik8I$@$%dTCs
zUb5pV6*e$zrhT7chz0R8%B1I*6ev1c{$b}|<6e_zzhbBuDI)g8BtG_e+}CF!0}fNb
zqX`~)_d#7I2e_QcMAhfPN?$KFA~wu(Nx}5pGx1WO^Iau@md^627ahvSIP$T-))?3G
zrKOizb<NLPDGk&guYtv?n&Pz=x*@6ca*gG`7LxjY5_r2D3(sQmtET)i{uvp_B2OB4
z?nLm`^p!Q>W_|TCc1j5acLIG3%ei`}W)qw@W&AfeL}M)}0Ogd{xG#|rr|xZjae8Sf
zBAef<{Fq0BrKGr+oSq&5@=*MJ-D%kRTuyp4JG{>9TG>VVp)=k4{zgXl%AYdlN&M0z
z)o$rtyXVvxN}jOC?d)bLAE{>|*QR?d4R1o?qs3-q^yAS9<73w5*#!n95$Ao^sebuW
zIH#(7|Lw<<oiYy7g&)@8N$x-f3A6O@Y+#UloVA9GwD^Atd!E)`^l;(R5UOk>EM?*3
z<|NCPtQte=2D)5$n;u$s#MD{r#R8Q1qhdZaFDI<8<x4(nne)Jsspn`hWrajJgHZ5B
z%r-}f9*?p%wetM-P6NQDzgr_mjx)laaD<~1sY~*~UpJqkt<d`#tfz+ZC8J&5!4JDP
zx%!cP`(>?x2dg?R`}!k-97sp7S|4D?o4O}!ptPYi9%gD&u2@+7tGFZf^?v9=>;1@#
z_?$eU_!f?nb!E{n%E>vVP%JvCxAd;UBd$4~XTW>XS5(z4KI}|9oI$b?bTgH*dwu`e
zpcC_8BJx9{!*j`<{`B^&?@#@hs7(C1bS7?rdcw#HJW<yrR4X5YSUH1D-b0fKeg-1G
zPK1k=8fpES3$-ltu?#_XmNsjlr0EBP+fvm67OM%|7!qOP-Jw|Z{#iHC_<PxxQ+<&a
zsjan+bNRqRb-l3CBGYl)a;p5&1kK+Tk9<pnmUvyMQM}1H1-ZX`AM}sOTY_bQEJ(CB
z=aSd2STdP@KLa?3VZ5gnL+rks1nThrdAKDx=Q_vf;~eQ<NzIl6Ft@wbZ~E^T`G)>i
zCbj27Zh_I79IiifpOKG$ZbHl;Ka)Z0mhD0k5(yKceK5T@EQs>fP{&N{LSe}V+w^gs
zgOZBM2ZU5oQc^*h`r>BL_H~4)2Ym>A49Bx0KAe1g2EA`cgNn-$O)`bUQ<f$?vw$Iw
z(2h?7Qes9I)6r;OmKrRZlM}wzHm*rS9Ya)@jEi{Oxv}~iAU?(BA?NFUAq;FHWU&^n
z4P$wL6rQX1xELX2-GepM@d)}V&DYyK=#s&P#0!xWqpPlb+rI(^=-Ev_I}yFmD&Pq#
zY7VI3$%meb_i2l@7L58cZm*G)g#bbTF@R*=l5`uD5lkB1ctX3l`me^Y5a;fnK_3wG
zA%!I<Cgvh1qHRbcv(*ZMw`fxq$LQyU;>9tg$~%>NhAKhtJp75|KC~I88QoQ`^>AEp
z<G*Qo?7~+Dh?wl3Gq8=eQISO*f8FEu%!cEW)@6E|%_}57UuhEc&<VHO`In34^*$Gr
zS*VWu1d&Stl#V5eqk!Xgxt!s;HMk<`%1miPrFVX!b7NQNA44BFFg+GQ(tnE~vujH=
zNevZ_u=z8ZaMw;$qS16JEUg<>X$fF1OPw@aJbt|jKhdOl$blDPqdJVy#I;X*6be*W
zjNT^v&QSAokaIXUX0+bfg^-{y+xLjZm~0)JJIfvOLZMmf9iiuhkys?-zF0xh1OqH!
zus0mfTs&YT07UrS^UmF+fM%bkyC7!?ODdhWOtx_GNgo8p@CQEnZ7R|ZDfEl0JN5n8
z>pvGsl@DB!Rm5bs7?*;xd@oZmORY@ncKLDKlL~ddvHBOzA|swKf-g|u!sy}2oH4=s
zExj71pZB}-`<p2kJ0TGmB0bz%yLIddmicm8NEOBV&y>(XZ`f8PWmGl1qtu$DUjD7b
zf{eW_HyVfWmhH1^`{lEle|=bi9}`?aGOZEeQs={G{qcXLKblZ;s!k-C+QaROxF=iI
zB}`cni%X5`(<Q$M1_}g*!dqrUD{!FVf`S|n>nn3UK`?S=_M8Ok;8MM+*m7W;o1GYn
z5Wf#Ie6`>A0r9wm!+62|`4tbbm2Y60=^j%aShJ7@Rtd&M^of5Hg=5>7rQ5kltJ!i{
z1z?TUpEo(knC27!Hz4Jj)sC&~t~gXVZl47M89o37R?ms67plVnZC*bqqA($>f<ZzG
zi=t=2`J=88M_#J<(4={HOavw#*OwwH1^7DD1VmMN)RGam3|<6Cz5jGCgcvcNNY~Qw
z5EbCBsoAXtBhPu-jVeQ`hGy;2k>Im0P~U+<@npwc>~YrLdajPU>8lo~WsKhUPnQCL
z3c-;O!hovfzZBf$P}7$=R-%#QYAeQX%r=^}2n9`~pueu+PJ!De%3&pw{qv9xT96U*
zKkN(dof6xf!`qMOQp%?IdgrzazFafq+Ve8SZ+?L@aTmu)#DXw7{$_q6aJzSIh95H6
zmK&r`snO_BgOisOK(**{-QmfC-wA=6Wl`uzHMP_I5;AV7#t^aUl6uxZ=V@$~(ELhX
z&-PAc@$j@p|17v=<BJ0_x(st{6$dpi9cel(3VBp(gPz9PjCo-h4u8P@01^<Vau7!T
zbee(YR_w?r_`%KU&KF+18~2_wE-vmD*09ntyX2t%X7bT_O%b!=wL-)E%Q7jMy^%qG
z=~risS}A(dkn7lMjTTv2nK4f<S!%@&MML-bs=S`iuxmP#*sC0(GMD>z-UaluZHJAo
z{D1uOdo4I5@FtK{$;&!0N>KbNH{JOIsu9xKJ2k6>cYzMAF?L)Aiz_x*QHadcg~}@8
zQ*h?gzG1+9T>ipvKDY@s+~AyZRpn9_5UrDB)!X;Z#?KXwdT3fGn2ihh*n_1y9q`RU
zqUW78>mrr~e5Iq3PEPEZ{sD1KLXQv&f4p~oxYreoFzdeqw!{>fM8gavG?e=^9jA$d
zzB)o{f>LZ4t6jRo$45#9et#~dbN|(2t-&F~lLnol_!RJAVvP6Li39lXwk|GyJef>m
z0O<{{&-isxe2UO5j=2i7xc#`?GVT3Z3#s~@sV_FWGFLXa501BecqUj_xX|AFr6j0G
zXC<C+xUg3si|{B_WyW+L!rT8JsjFRq6#>yS&()NayJABQ;GES<39uBZAcobhomqWA
zO`u?bV{0b<+sdVO<KexXv3Ria-bmsI2()k^334|!LQOH@qAZT-Ni*W9UXPOCA$ZvL
z9j|R8D&h=vVFeb%Ael-?a9a#F2>1Fb3zuz1|89%-!-9!_m+0`I*gkz}QcF*nx3U*?
z@T<ydX#b@6gf-$C_%Y0#V>H?s_&UW2(nLi|+;0<aS}q}D`0cX5Q=w}1`)M^=b!~;*
z&^*VAP0|_a2F!c#NbKhddEAqbsG}3@hH&o4qyLe2{!jeD|0cnmN@FwA(z+Ut5g0sA
z<5E@>4&GjnA|T-gV(&-H8~49HlokH|P<LZLA}8<vo@+V%dFn#_Y%X3;b8C~V`7IXq
zjVL+&om(l71vuH*eX7WdRa#aiswl|{VO&T`IJhnFtEf0EUJT-Ui<f_rYZ8WiYAB7I
zF4Au5R`#eGELG_i|3^K1PJcuIki?XK&o|pUmc~4LC{vRs8@o`4_chNB73P3>Co((S
z{FbmOinIDYR3?mQ&Av)k$)(m~CC;U{9W{tj1hUh}r}11w_u}3DlVABqui^;lyTRVT
zK&~vY7VM+Q-oH9+F@Ly00ZhB)0~ftJ5}E%w{U;)c%6Ed209Ih|^xI(bKVr?n+qJ!>
zb+*=5J%{Wi`yD$`cX!6InC;o5<0Zo0KR-+qgT&tj$Ns2c7EnN4MZFJ=_CXN5ZQxS{
zA&t&%%P${97fy{{RTB+vRt4;Q?fw!@nkMdiCaI~4Hodjz<Fu8ap>`d<L&A$kXJBP4
z<cw=*S9lrkrutk#hy#qX;#f>=qX&&iJvfeYpNCkD!+jl^d@l4ZR{}ZPVJU4K<7?Px
ze#Of2VhDnae2fbcDnu)j=*$~B!2ZcqsdrM%H7`lOXwjii;TXEWtdHzQkae5q@Q|h2
z%!vIi@cjVW8MlItFKqc5UI9r%X>Ji3hLxLYB5)Uzpw+T4!<$6KP~ifm3M{l=-IxCQ
z{&3nr$I!ZH_l@$)*w(TX7bJ83<~yaA^c7CK@0GdNNblnlMMSp$Oz<mmL{Z>w?>nJ@
z+2bZp=+J*LRUy2F|0f&#zY;N{aF-wR^)?4-)qtf;heFd5S78Lke^9CU-#N&-t?qi9
zjhH)tocq3>bMVatKTmr!LphJTrko5uH__ufpQ>1#E&w)LXg8f($jPH@D}j;Z1Iu$?
ze7kbe^;EQ*u?xgD!&^!RmvENT9Ov~ej5;~7Xh8F9OOM1OlCGgw>7LWGJj|PMLsU-9
z%9zR!c1w`VJfv!(O(UybnNIV@9PlALCELbsLQ*Ng(ep;@!MLmgzg#8Da3xUEVO-S7
zTs<UwDv~A>((%mziKfQkPOA)S(58w(I+(KdUMIT*nkm$<e3`St<Y$elsiV*^5Ge}{
z<XxefX&B9R#=Cz^a3}uaqN0@*tCnlwB;}ZKl_&E4j<$j_y5Nki>IZT3C-<gb%SNBT
z$+a<@1tS}X;q2c^`I;n*3Sc}XUFqk(G>nI8J%|%~R{;Ldt8CHSAT0_3ORF71I_J9E
zxlrtD?%v*MtF9>`X_O#Qp)Z-yvR0#P@*KXkun@g!&|X94plYVv`iz%JKhYPL&xX^!
zzr2Z)1_|vRbS%fQ(vJ(eH!Yuuq&a{bqpxM|tsWa=T4D9EH^U$*#svD?<EEimSH{BG
z_R*4sJFSN6^oQR~2uxL#TBa9MHiR9i7RV|^7^)7t8g%$O7IZ1zQAvnIHG_28oN_VV
z%J{xzLYlH5#<cl9fn{0Zapz-x#WAm_pPN(DC8BUQ|Cqt_@dk{Qiz_N5kj|gly~nW8
z28F`dr#TZYE61-us>paTs_=>+cd95z*vPk^E^%uv;P?wog=VldK!GnD9FZUUUqoPs
sFBJcaUH#wD@&9U>|36)dpx%Y?quBLycfI~V_~}rxl1dWQVkSTS2M@09egFUf

literal 12516
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

diff --git a/img/scan4m.png b/img/scan4m.png
index e42a7238c15db644237b56da2f837046f875edcc..fc4477f31313a494102461f0dd991b54f99aac6f 100644
GIT binary patch
literal 15429
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

literal 14558
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
Oq#&y*Qz2#Y<$nNl4h<>*


From 16dbe99329b6231d57a02988f7701aacbb3465cd Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Tue, 19 Sep 2017 17:54:20 -0400
Subject: [PATCH 19/27] questions

---
 README.md        |  23 +++++--
 img/scan20K.png  | Bin 16106 -> 13545 bytes
 performance.xlsx | Bin 39991 -> 40989 bytes
 src/main.cpp     | 164 +++++++++++++++++++++++------------------------
 4 files changed, 98 insertions(+), 89 deletions(-)

diff --git a/README.md b/README.md
index 8045131..277ba31 100644
--- a/README.md
+++ b/README.md
@@ -6,10 +6,15 @@ CUDA Stream Compaction
 Sarah Forcier
 Tested on GeForce GTX 1070
 
-### Algorithm Descriptions
+### Parallel Algorithm Descriptions
 #### Scan
+Computes a exclusive sum of all integers that came before each element.
+
 #### Stream Compaction
+Removes 0's from an array of integers. 
+
 #### Radix Sort
+Sorts an array of integers from low to high.
 
 ### Test Program Output
 
@@ -98,28 +103,32 @@ Tested on GeForce GTX 1070
 
 ### Performance Analysis
 
-#### Scan
-
 | Scan for SIZE < 20K | Scan for SIZE > 4M | 
 | ------------- | ----------- |
 | ![](img/scan20K.png) | ![](img/scan4m.png) |
 
-![](img/scan20k.png) ![](img/scan4K.png)
-
-#### Stream Compaction
+The CPU method on non-power-of-two arrays is faster than that for power-of-two arrays because the CPU performs serially, and the non-power-of-two arrays have 3 fewer elements, so it finished faster because it has 3 less iterations in for-loops. The difference in performance between these differently sized arrays on the GPU side is the opposite because warps are allocated for 32 threads, so non-power-of-two sized arrays cannot fill an entire warp. Thus not all threads are utilized and the warp has lower occupancy. For an array with 3 less elements than a power-of-two (as was tested here), the different is marginal. But the difference is much more apparent for arrays with 1 more element than a power-of-two. 
 
 | Compact for SIZE < 20K | Compact for SIZE > 4M | 
 | ------------- | ----------- |
 | ![](img/compact20k.png) | ![](img/compact4m.png) |
 
-#### Radix Sort
+The difference in performance between the CPU method, the CPU method with scan, and the GPU efficient method illustrates why different algorithms are required for parallel and serial executes. The CPU method with scan is a CPU version of the GPU efficient method. Without multiple threads running at once, the CPU version must rely on multiple for-loops, more than its compaction implementation without scan. Therefore it is the slowest of the methods.
 
 | Radix Sort for SIZE < 20K | Radix Sort for SIZE > 4M | 
 | ------------- | ----------- |
 | ![](img/radix20k.png) | ![](img/radix4m.png) |
 
+Much like scan and compaction, GPU radix sort performs faster for large array sizes even though parallel radix sort requires more sort passes becauce the GPU works on bits in order to benefit from scan whereas the CPU version works on digits in decimal. The CPU algorithm calculates the maximum value in the array to determine how many sort passes are required. The maximum number of passes the GPU could do on an integer array is 32, but since the CPU version only loops for the maximum number of digits. So for performance comparison sake, the GPU method takes the number of bits in the input array that contain 1s, and the calculation of the CPU maximum is not included in the time.  
+
 ### Q&A
 
 #### Compare GPU Scan implementations to the serial CPU version?
+The GPU version performs better for scan, stream compaction, and radix sort for large arrays (SIZE < 2^[18]). Since the intersection between the CPU and GPU methods occurs at the same sized array, it suggests that the slow GPU performance for small arrays is based on a overhead required for creating and distributing threads. One that is only surpassed with large arrays.  
 
 #### Where are the performance bottlenecks?
+For the work efficient implementation, the upsweep and downsweep kernel functions require a similar amount of time, because they have the same ratio of compute to memory instructions. Most time is spent in memory reads and writes, but since there are not many of either type of instruction, it is not possible to space out the memory instructions with computations. 
+
+#### How does the GPU Scan implementation compare to thrust?
+Thrust exclusive scan on power-of-two sized arrays performs poorly but consistently for most array size except the largest. The consistency indicates that the thrust implementation might have a large overhead. While other implementations' runtimes increase exponentially with array size, thrust with power-of-two arrays remains around 10ms for all array sizes. However, the thrust method on non-power-of-two arrays behaves more closely to the other gpu scan implementations with an exponential increase but with a much better performance. An explanation for the poor performance with power-of-two arrays might be that thrust implementation might allocate and compute on more memory with these sizes but not for non-power-of-two arrays - the opposite of what the work efficient method does. According to the Nsight performance analysis, thrust also has low warp occupancy (25%) and high number of required registers per thread (78), which could also explain the poor perform for these sized arrays. However, thrust makes good use of shared memory.
+
diff --git a/img/scan20K.png b/img/scan20K.png
index e280bc719f02cec4ec0df6f30435bb2b68f8fe83..dc70d2382ab806b872ddad30e24b71c0a73f0b62 100644
GIT binary patch
literal 13545
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

literal 16106
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

diff --git a/performance.xlsx b/performance.xlsx
index 8d322e608c85fbea8ccd90514c552ed1f20c092f..4f17d0f5f429230b5b0e8432f82f3ba0809b688d 100644
GIT binary patch
delta 16174
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
Lxvr$-e_H<s>t(Zz

delta 15326
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
I{Ojre0M?7%lmGw#

diff --git a/src/main.cpp b/src/main.cpp
index 053af8c..9d50934 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -13,7 +13,7 @@
 #include <stream_compaction/thrust.h>
 #include <stream_compaction/radix.h>
 #include "testing_helpers.hpp"
-const int SIZE = 1 << 4; // feel free to change the size of array
+const int SIZE = 1 << 10; // feel free to change the size of array
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 //int a[SIZE], b[SIZE], c[SIZE], d[SIZE];
 
@@ -100,87 +100,87 @@ int main(int argc, char* argv[]) {
 
     // Compaction tests
 
-    genArray(SIZE - 1, a, 4);  // Leave a 0 at the end to test that edge case
-    a[SIZE - 1] = 0;
-    printArray(SIZE, a, true);
-
-    int countSIZE, countNPOT, expectedSIZE, expectedNPOT;
-
-    // initialize b using StreamCompaction::CPU::compactWithoutScan you implement
-    // We use b for further comparison. Make sure your StreamCompaction::CPU::compactWithoutScan is correct.
-    zeroArray(SIZE, b);
-    printDesc("cpu compact without scan, power-of-two");
-    countSIZE = StreamCompaction::CPU::compactWithoutScan(SIZE, b, a);
-    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-	expectedSIZE = countSIZE;
-    printArray(expectedSIZE, b, true);
-    printCmpLenResult(countSIZE, expectedSIZE, b, b);
-
-    zeroArray(SIZE, c);
-    printDesc("cpu compact without scan, non-power-of-two");
-	countNPOT = StreamCompaction::CPU::compactWithoutScan(NPOT, c, a);
-    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    expectedNPOT = countNPOT;
-    printArray(countNPOT, c, true);
-    printCmpLenResult(countNPOT, expectedNPOT, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("cpu compact with scan");
-	countSIZE = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
-    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(countSIZE, c, true);
-    printCmpLenResult(countSIZE, expectedSIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("work-efficient compact, power-of-two");
-	countSIZE = StreamCompaction::Efficient::compact(SIZE, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(expectedSIZE, c, true);
-    printCmpLenResult(countSIZE, expectedSIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("work-efficient compact, non-power-of-two");
-	countNPOT = StreamCompaction::Efficient::compact(NPOT, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(expectedNPOT, c, true);
-    printCmpLenResult(countNPOT, expectedNPOT, b, c);
-
-    printf("\n");
-    printf("*****************************\n");
-    printf("** RADIX SORT TESTS **\n");
-    printf("*****************************\n");
-
-    // Radix Tests
-
-	int k = 4;
-	genArray(SIZE - 1, a, 1 << k); 
-    printArray(SIZE, a, true);
-
-    zeroArray(SIZE, b);
-    printDesc("cpu sort, power-of-two");
-    StreamCompaction::CPU::sort(SIZE, b, a);
-    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(SIZE, b, true);
-
-    zeroArray(SIZE, c);
-    printDesc("cpu sort, non-power-of-two");
-    StreamCompaction::CPU::sort(NPOT, c, a);
-    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(NPOT, c, true);
-
-    zeroArray(SIZE, d);
-    printDesc("radix sort, power-of-two");
-    StreamCompaction::Radix::sort(SIZE, k + 1, d, a);
-    printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, d, true);
-	printCmpResult(SIZE, b, d);
-
-    zeroArray(SIZE, d);
-    printDesc("radix sort, non-power-of-two");
-    StreamCompaction::Radix::sort(NPOT, k + 1, d, a);
-    printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(NPOT, d, true);
-    printCmpResult(NPOT, c, d);
+ //   genArray(SIZE - 1, a, 4);  // Leave a 0 at the end to test that edge case
+ //   a[SIZE - 1] = 0;
+ //   printArray(SIZE, a, true);
+
+ //   int countSIZE, countNPOT, expectedSIZE, expectedNPOT;
+
+ //   // initialize b using StreamCompaction::CPU::compactWithoutScan you implement
+ //   // We use b for further comparison. Make sure your StreamCompaction::CPU::compactWithoutScan is correct.
+ //   zeroArray(SIZE, b);
+ //   printDesc("cpu compact without scan, power-of-two");
+ //   countSIZE = StreamCompaction::CPU::compactWithoutScan(SIZE, b, a);
+ //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+	//expectedSIZE = countSIZE;
+ //   printArray(expectedSIZE, b, true);
+ //   printCmpLenResult(countSIZE, expectedSIZE, b, b);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("cpu compact without scan, non-power-of-two");
+	//countNPOT = StreamCompaction::CPU::compactWithoutScan(NPOT, c, a);
+ //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+ //   expectedNPOT = countNPOT;
+ //   printArray(countNPOT, c, true);
+ //   printCmpLenResult(countNPOT, expectedNPOT, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("cpu compact with scan");
+	//countSIZE = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
+ //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+ //   printArray(countSIZE, c, true);
+ //   printCmpLenResult(countSIZE, expectedSIZE, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("work-efficient compact, power-of-two");
+	//countSIZE = StreamCompaction::Efficient::compact(SIZE, c, a);
+ //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(expectedSIZE, c, true);
+ //   printCmpLenResult(countSIZE, expectedSIZE, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("work-efficient compact, non-power-of-two");
+	//countNPOT = StreamCompaction::Efficient::compact(NPOT, c, a);
+ //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(expectedNPOT, c, true);
+ //   printCmpLenResult(countNPOT, expectedNPOT, b, c);
+
+ //   printf("\n");
+ //   printf("*****************************\n");
+ //   printf("** RADIX SORT TESTS **\n");
+ //   printf("*****************************\n");
+
+ //   // Radix Tests
+
+	//int k = 4;
+	//genArray(SIZE - 1, a, 1 << k); 
+ //   printArray(SIZE, a, true);
+
+ //   zeroArray(SIZE, b);
+ //   printDesc("cpu sort, power-of-two");
+ //   StreamCompaction::CPU::sort(SIZE, b, a);
+ //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+ //   printArray(SIZE, b, true);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("cpu sort, non-power-of-two");
+ //   StreamCompaction::CPU::sort(NPOT, c, a);
+ //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+ //   printArray(NPOT, c, true);
+
+ //   zeroArray(SIZE, d);
+ //   printDesc("radix sort, power-of-two");
+ //   StreamCompaction::Radix::sort(SIZE, k + 1, d, a);
+ //   printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(SIZE, d, true);
+	//printCmpResult(SIZE, b, d);
+
+ //   zeroArray(SIZE, d);
+ //   printDesc("radix sort, non-power-of-two");
+ //   StreamCompaction::Radix::sort(NPOT, k + 1, d, a);
+ //   printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(NPOT, d, true);
+ //   printCmpResult(NPOT, c, d);
 
     system("pause"); // stop Win32 console from closing on exit
 }

From d7cf32edb6a674065592a4d8f2bd847ca171be1e Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Tue, 19 Sep 2017 19:55:51 -0400
Subject: [PATCH 20/27] descriptions

---
 README.md         |  33 +++++++++++++++++++++++++++++----
 img/downsweep.jpg | Bin 0 -> 81397 bytes
 img/naive.jpg     | Bin 0 -> 83463 bytes
 img/upsweep.jpg   | Bin 0 -> 61647 bytes
 performance.xlsx  | Bin 40989 -> 41275 bytes
 src/main.cpp      |   4 ++--
 6 files changed, 31 insertions(+), 6 deletions(-)
 create mode 100644 img/downsweep.jpg
 create mode 100644 img/naive.jpg
 create mode 100644 img/upsweep.jpg

diff --git a/README.md b/README.md
index 277ba31..ac87187 100644
--- a/README.md
+++ b/README.md
@@ -6,15 +6,39 @@ CUDA Stream Compaction
 Sarah Forcier
 Tested on GeForce GTX 1070
 
+### Overview
+This project provides an introduction to parallel algorithms on integer arrays: 
+* Scan : Computes a exclusive sum of all integers that came before each element.
+* Stream Compaction : Removes 0's from an array of integers.
+* Radix Sort : Sorts an array of integers from least to most significant bits 
+
 ### Parallel Algorithm Descriptions
-#### Scan
-Computes a exclusive sum of all integers that came before each element.
+#### Naive Scan
+
+The diagram below illustrates the naive parallel scan algorithm. It starts by adding adjacent values, and then adding those values, and so on. This requires log2n iterations, and also requires additional memory since the algorithm cannot work in place.
+![](img/naive.jpg)
+
+#### Work Efficient Scan
+
+In contrast to the naive scan, the work efficient algorithm works in place. The idea behind this algorithm is to create a balanced binary tree of the input data (up-sweep) computing the partial sums at internal nodes, followed by a root-to-leaves sweep of this tree that builds the sum in place. An actual tree data structure is not required, as the structure can be flattened into an array.   
+
+![](img/upsweep.jpg)
+
+In the down-sweep stage, the root of the tree is replaced with $0$ and at each step, the node of the current level is passed to its left child and the sum of its value and the left child is passed to the right, as seen below.
+
+![](img/downsweep.jpg)
+
+Each pass in up-sweep requires almost $n$ iterations, so n threads must be allocated even if some threads will not be used, so can retire early. However, for down-sweep an additional optimization can be used to only allocated the needed number of threads per level.
+
+Because the up-sweep and down-sweep algorithms rely on the size of the array being a power-of-two, non-power-of-two arrays must be right extended to the next largest power-of-two in order to maintain correct indexing.  
 
 #### Stream Compaction
-Removes 0's from an array of integers. 
+
+The stream compaction algorithm start by creating a temporary boolean array where each element is $1$ if the value at that index in the input array is not zero and $0$ otherwise. Next this boolean array is scanned using the implementation above. The result of the scan is the index into the final array, so if the value of an index in the boolean array is $1$, then the value at that same index in the input array can be placed in the final array at the new index specified by the scanned array.  
 
 #### Radix Sort
-Sorts an array of integers from low to high.
+
+The parallel implementation for radix sort begins similarly to the above stream compaction algorithm. First for bit $k$, a temporary boolean array $b$ is created where is element is $0$ if the $k$-th bit in the input array is $1$ and visa versa. A scan is run on this boolean array. Next the total number of falses (or the number of values whose $k$-th bit is $0$) is calculated by summing the last element in the boolean array and the scanned result of this boolean array. This value is used to create another array $t$ where each value at index $i$ is equal to $ i - s[i] + totalFalses $ where $s$ is the scanned array. The last array to be computed contains the indices of each input element in the array sorted by $k$-th bit. The values in this array are equal to $b[i] ? f[i] : t[i]$. While this algorithm requires multiple passes and new arrays, it is not necessary to allocate space for each step. Some steps can be done in place, and later steps can overwrite previous ones once they are no longer needed. 
 
 ### Test Program Output
 
@@ -132,3 +156,4 @@ For the work efficient implementation, the upsweep and downsweep kernel function
 #### How does the GPU Scan implementation compare to thrust?
 Thrust exclusive scan on power-of-two sized arrays performs poorly but consistently for most array size except the largest. The consistency indicates that the thrust implementation might have a large overhead. While other implementations' runtimes increase exponentially with array size, thrust with power-of-two arrays remains around 10ms for all array sizes. However, the thrust method on non-power-of-two arrays behaves more closely to the other gpu scan implementations with an exponential increase but with a much better performance. An explanation for the poor performance with power-of-two arrays might be that thrust implementation might allocate and compute on more memory with these sizes but not for non-power-of-two arrays - the opposite of what the work efficient method does. According to the Nsight performance analysis, thrust also has low warp occupancy (25%) and high number of required registers per thread (78), which could also explain the poor perform for these sized arrays. However, thrust makes good use of shared memory.
 
+Images taken from GPU Gems 3, Chapter 39
diff --git a/img/downsweep.jpg b/img/downsweep.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..88be7ff7ab58a060c91697d96e6a10b57a35c0cd
GIT binary patch
literal 81397
zcmeEvXH-;6v*?}~a?VkLNRphR<eVf&K_tf+au6g4iXZ}#ksv`b0!j`7f+(Vrb50T^
zD3T=2+o0#@x%b@rzVp3%*LpwfS+jR_b#-@jb#?DORYijwMa}{Qs){O#00asFZh#*E
zIY%<D;Ok%u02&$q8vp<p06K&SfPoMM`~VOt0QDRO080q<pRgl@^#=_Uq~Qg?D?kE%
z-64E`!eRFu0F)nf)4}^&@O$G&{`@Xu?P6&|uVwGz>EdDU;z}>f#RKs1@Cb|X@`~~C
z(DU+%@d=0t2!d4rSQg|bPg&4E+J)?7!TyAq&IrMT27&#cMf;V12-#2mA+*2p56a>P
zpAcr~pKTLYeQyp>2JfIGzTc65m7($(7P$f7oR7s^P6L1-Hvzo!9AF)MRuee^+yQVf
zFfcGNa4<1(2(huS2}$vBaPUbfh>1ywi75zi&eM<E_soC1LU6IMaq(~o@bCyo@bK_R
z&MtT)->VS*D-9rD0)!ZV8W0SFFaS_O2#gSdoC1f9foz9Jfn1_O&J)P+S%QHIf`W>M
zj)94V4XVLk3n2g$_D3NB06~GkpeRsObTkZ97!E&JNC-o@NW_aOqisRV;C7o2jU+bv
zx$GrIQk_;yegXH8J~?!zINi^4U#vU?$#N<}ndRg4tQFdxcnXpC>(AS4SKfIw;I;5o
zktHGbZdGFY;K!Z3>eoYyy9T!2VM+NlZ-$rlgp~~KeC{O|)OL(4?-K%0D9A0!IZx<l
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
RSa;%iyDGbD&HQi6{|f>1<V*kn

literal 0
HcmV?d00001

diff --git a/img/naive.jpg b/img/naive.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..bc9f9da7434ce986e4aa12943aab6f3ea90298d3
GIT binary patch
literal 83463
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
b6Z`(((N{7v*GB)IygPQq>3Qe2{=W$Tq)}g?

literal 0
HcmV?d00001

diff --git a/img/upsweep.jpg b/img/upsweep.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..22c4da0fbc2e363fc48ed254d14bcdabe5107a49
GIT binary patch
literal 61647
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

literal 0
HcmV?d00001

diff --git a/performance.xlsx b/performance.xlsx
index 4f17d0f5f429230b5b0e8432f82f3ba0809b688d..466c3d797fae3e8621d0dfe937749a0408225c1e 100644
GIT binary patch
delta 4835
zcmYkAWmJ@5)5l?HP}(J>kyPoBMY^RyLb^c^SUPV|y5T0I7EzRD=~`I2q$H$6S^??K
z*XQ~0o@c(y@64Q;IoG-VXFg1BI|S7UspMlP+|}mK+a|%lD3u0ZurmTC^E#~J<Uz|(
zw|J4uD9*HP)ew#c^&LbJJ$6m7=6FYXtdDhzi-Omu0ea1;sU_TTj8AB7RaL(p73dU~
ziC?WD8>UB)8+It;Hbx&KQg4aD^PVfm)4R3C>%94~hL-u+z0G~i<LT4uqsHrV`26jc
z^HG5Q*39*80nM9%A_f$Fml=G_y-|r>A3pqDwY?Ns#@$KWkl-BM8J-V}loFL9u4l~N
zxGCN}IrAqCxAZ>{F>m$Rz>mxh>NS*-LP7^S{11;^F45oz=XB)p<Mm~9*~@zW+J>H&
zU9H2Sz}?M7y<uCBMbv)j^v}J0_>Xs6F79G?hv=oDwl=Fp0I2ds|FF&ge7oApq1mV2
zw=G0`3!#*g<{s`^^cDq6V-titq)z+J>7#v%FC})(D_a77NN@{#HW=S68Q<^iZZ6vo
zPH$K>1a>NVNuW;qHjey!ngfF*_m)1(?Dn6ZUTKbbJV20w&VvkADVJ6aS9Pfiw>6wS
z^>+puym#$o0G^%k^|Eo8c2na0k|!d4^f(WR`g3)D2|r!4#WN!Rtx&Xe@MpgRj%r6+
z95JbO7sa0PM6?4Et~}I+lrmMvZ3iU8p$3{LsuQL8^9^rN<LHj&+@8_D?{2-3QC}V4
zsXFZ)fuj45U8dS3DyiIDr8YaSW|&8_y4!EwU&^}yYCj+QG-!<=%>q3Sh)PX46Lg1}
zv8haPYb}-O6l+)FL~<q~_+1(gaMVmXo;hX^xHNu#I9<Eao5${9pE>?aaE@uHOfSEZ
zYBzKi-+6^f1hO#W)P#dG3(1By*M_QFC#%uFkk1f-I}EWSX5|HbH%%m?9`}hP|9EDc
z?mJrzbVsYJEnZg4y>?%$j>(2vetX(EltVCJw=mbekakjG+j*T%z&Q6Luq^Kfznoaw
z?QrF&8l!amjeH%h5p+&U<VLYIe7!)C`^_=adRb-g*a2Nta{l@&2!dV2e$zdHjYGp8
zvDxJ+zbdGrj>T|v=03u1PiEssZakhG9)IcyzzD2en`2dF&YW?uS=UUaxE*xn{l6Mx
zrLVg?A-jaj-*!=10!L1f_$96<B8@05Hbm+~>$Kp6zolbVihAQu_#=f>_qS5f9BmYV
zqpfto?M&BW9W`PRM<L1sk;_r8=#1NM8g2NB+q;;rB2NO6ZtXOrpiz%zHveQUeA)E@
zc20O8)ne4bv&U%JM=}cL9WgjY#svuVQ_VW38eaAy)|fq#2XD7$R8|s8NF!8;@M2#^
zT;W=UD8>g8TJ!d^;#muW+)0+>yw$scVOaTU{L+I*{dmUr=5}A}Y;ffHlTok$mOjZ|
zb9kb=X_P0+oA8aGO$K%juf*y{(5PJCOh{mIl5a35JWfbhZF|9j=hQ^IE9B7#G)2&q
zq?3ZKJG^a_s%{Wf=8~(YdfjbnR(yxKrlOaG@vE6dalN~B3|`0uqZfDhmhur>Wpy`m
zpUB=nf`ynOf-dWhY~TOw8JGPKZEEErLH(A%R6wR{x~8e$&!$+C{f~_yW#83+@9NIi
zvd{v@T?faD_}?q&;F;@-12dAr=GJ1tvIgH>POr3$%GS&YB!1BoSjM^G^AYR7i=v+B
z=GHgW-;*3h=IesZxn}Erpk*ykx*isZ*RxcgKNo~aYF|b>pAysG|By<{p**Wj!%-pY
zO((n3aCZ=UYn7M`WxX6~Ksb&7sr)%QLKPW$Irb_KbVa4Ax2w`OJX|Xqf}fpl<|vOy
zS_FLcO!&o>AaGs8+5xWc7<Ol`1hHOLGg*x^{Zaa+`z3#YV?>Dm)%Z+rEzi$#8rDH0
zk98l88G3t`TfB<TZT?=Lb&%TgdC@nWNCu)tLySL1THb$#$){zKH!!feft8n28jmuI
z`(M2Mgp3Q5HGdm}%SF5pZoeqOHLj`F2(GQm*Y8>S7p8cS^zr@3VZLVTrhA<eZd;I_
zxR$)Wj``eaHC#|Veqtd3tQwnSRMvpvI_e$tTDz9bxLIGb)uObVzJ|5}>t=hy;<MSu
zs&JO6f$%SE8qySB_+qM|00-0Mc*v|lkL<#+L!f0D`&qPLc@5_lzslKylX2V|%=|?H
zV~T}vt$JJhiBE3GzsO(2T?v0@Ot7~ouWj#_c)hC3D?0H4|JvXlY#i~HmSDCB=o9*u
zf2v1?VFk0vv|-$pVN0<_o<=(<vTfplg(<&Hje-Ullt=J?-LR!I08S&E?il+@c&r1N
zshOla3GLyTb_x&dS1o>S!3+i!{MqAGuqCESe!(hK!X28{I-4HKyn`eU#!xgc$mS?p
z(NlW!k`sP;l4FoUF>p%SULQo;(YO+8m|SaNa&*Yl5mc(5t6QVcDCPGZK_lD~{_vH*
z%MWK2`lHQ-;arQi?*TLiPXV)d`t{r$;T73?+A7HSR{ripw(YZpm1?K@l`3xt);Ziu
znA%|e6@NwAD#C)eq=$9kPRak7wmL<2wYcIQNA11=dhlgh4oq22s))|Pin6aB^GZA|
zf73?ADl+-*P$DHqMQhzsJ$OQ^i9&3W$*8<#$W>S=#kvQ&4v2dQAcHG(JtDNXHGQ~>
zl?x*@Xe)46?0T^?4Yt^rP@e4K3Rx^%V(J)r-JOHP3wq=0O?4e^LpBM;G*47~7j_@p
z8E<17Js<4Q)_Yqo^on)9w*O0r#ar3BANj1pCY%ahE&xRv`1K-lAhH^8O-JEBpWbBr
zT?f*HfoWHy!1j6Cm`){~oW-8sYJ2Mi`2rDvPfC=e_OJ}S5}F{#iTeTS_T|f@92jS#
zhsd=XwbMvhzsteTU#4)o(16ymf$Chx5kAkB_`F0310KQ;e9^|TzE5qkfa(LH;Y@k$
zF@F&=)e*5Mzu~7gEX9sVJqg(dHF^I&t1uvk?;7?52tkPiM)eNVFFVjGDd&prSUO$6
zVR}Y;nF~<6Ijt}xo5!LP?dx9U0yu}mu)Wx$5w()V=`#a|tx(ct+*RAcr7}0>XYvgX
z$CU#9Y4ER=U-E|b+XU~rKFYtw1H6MCTTk2hUNqVlp)WhdNzMd(WIVh|9%s;-92#q8
z>-KyHEOSP}`$-OQ?eq}MNc~`Fo0XUBeilbkvehuNw2cIdc}Pu+u=`Ey{^CfT9Vvd;
z$(_V&dHO1@vpVr8bP@GhrNwYu2GknL9O0;%t@(g;^?c!s8+*mz5o`K3Y$ru}nXglk
zNMh(S3AQo24EZ<8{)w2VL2{MYQEnE^qjWyt)9Rog{$fEGDg`+p%p}LVe$3=;zC8Hi
zj=6DqN9JtX^5OcVPsZwUEyK=Msa2p){2j(EdK^#N{=WOS<Gzo?lke}&67M_Au5hv@
zC;p0gcR_h1^#d`YFtWl`t-gMUAuD`Xh$9Y7!>#@j6G2JIvbeo9cb+*+U0+Z?db%nL
zn6MZp30L5D3reQ#bZQ;LqA7MRP6(?D61tcMVtL=0wRdw$$`dX$xA{g*W63^F2w?TA
zddtdUPhS{QilkE*eoy^{bXAW`o2%1p1xc#v{qEaE(&UD39P6yVTpaoNVrJMiySWG2
ztlz##j}di#ipAMoDm=+#_WO_~%3fp@*w86s`t-!nTq;i%HjZmp5oAyj4M}y1nhW*C
zQEp+6dEof<-T8@9=!Ah*f|5duiM)_sB>a1IEx+{C*a(VD%CqD`R?mhhy}A?I>LFH_
zp?sr(aZa~D1l0PwmD;S$cCuxh2TVoOd~%dqQMxbTMSs**3>m=<uY7RfKyKVH5JI+<
zd`m3z%Qv4oxn-z2Y{=U&N=sR-e7s<eu(!#JgJaD!^DwEjhVi?@rWsN|8b>ZFuIW;n
z<I^iv#U{dM&o{R&u?G4E4@TkMZ0UK$e!3s^(v1RZalaoZz{ob#uapKMs^}-vq&QVP
zb-*+V$=JR?EcV%G-Y0-;`vW}&V8&A28rC2!m3(a|Rd+<r<=t!4#MsaDEXkN7__3L6
zeQcp}1NOivxp}F(O-Xb76D)lRIfmtUl&S6u{XqIA_t%C2+u;y6Lad#6xQuD+m@F$X
z(r>UyYWxUCT<wickNqR_uoMx43lH_M^F-q?MjkYuGy~&?W7^7iiCK>!fDO~wt!<`y
z+^-MC+&e7(Dh#<%sUyPg&)RXQ5Mumny$=mGB@+*RY9^BghWknm^rK&$eivX1lKb43
zDZ-N4CZ5<JL}qv>6Fb}#`A@?H_xKWB-4q9CbmDv1cqHk3Oy|w|_kRyf;$TmWD;w~D
zCZ6hMw}&*vp1M|qw7do+)k&$3UHWdO3C}-ri+-Vz`H5ie==M84bT7G}hVgHk&@Em_
zA8&AOb`6?NxC_-@kYBZnjLWV#%M6*SD~3r41|Ap;VKsB7$sRB^(8H{s5<se8PYPGU
zS>VaVYFR%$iZ81L;7%}84&znqp1>wA#xo6oD=^L_x?94xs~89_@5N&DI4(Uo$yj5S
z$4GBwU1pin&hx=Z3iJyrltJ}>bhvv>fP>~6?q~90ucFyviE`vxK_mAom>5@$XzX=r
z{9g9&VYKM_WyDG^nI-4-2bbj;VlrS^6u*x9LxR!H^Pvn@5D*2Fvyqq^rsbnEe(Rn}
zGbfmC1`V=By8~oQ51mcV@Ry|@BD!vJeEhA%yJATG=<yV>*{>@T@t_4NU47Y>#7i&4
zma1uo?@SJ>sOgkq<$GhO*FyTLe*P|bHpHYnUbDF{`E^BZk%P5wzFRrYfzuUjW8#>v
zqesF2Ji=fe!oq?0r8tTxfH8rZJhbW3;7JU=0wm(8Er5!6PUL1XP89Ga^f3!b&hM#b
z$$wj(N1j!hZER^_&g4)BCAEg?7fupWD{=Rkksk6Tp4M;|#O&cKWb=@O>V|*%#&bFC
z^hay&&FZ9DOR=}S8O!O^`iiDLFv;<YtaLUDFD9{1oOdWV)6K{8_d!!_G9vboOe&ci
ztR@Pd%Ms8kH=vQ{g0rZX((K5PGO#()iRfP%CcOWUZgr$4%mDv^iP$S~j5f%jUh!b$
zGRXSa5pVrGtD<O{*!-Bqm6CCUA0vy&$temaCnM5Ge;x-JTk=~`c*#lSz>Df-TmHv1
zeJ9ec);?K!R16~cm0rRu_LLAlQ7V}M`IrvPEFEC+wa&d@WH3#ivTGVf@LIo089R9c
zGf!0|?P2qlgZ>`WHge3~9K#x>@2vay{hqIW{xD*#`20py0S>$5ue*7D>GE$K1pBuB
z<(-o1=^I-Wu`u2cCF9s7UB>wW&8#)AlnWf#X;}W};&@(ml}GG94jKY@IgW=De_q!g
z12KtRJw7v9-xY(4Oz-IO;xo#lq|r#9iyy}Kr|(^lGcGo1%xdQS%#c1;B(GR{bD#Q1
zNxj$^CS3N($eU;Mk($b0v_sE%Nj!JBU#1P4?!ZHDM}2_|yi1<lkGXGZe^*z;>`ZKM
zp&BF@%sqWrn|a@R@A=8vSglL!qWoSI3#;`WtA<gC+X!dg+w)MRMkD?SCSa=B$wwW&
zuYN<Kwyz{AooYuHO<Tdn?~c7@I)Rp6yGpKqadGZVH^gQ3@#LFiq2{RHgtL2+{t3Yp
zK{-4%ft)hbDvPLYaID#+*M}31;MU+NXHrsfbI>+1w;dw=_7wKUrQIL%86n#SzM%MA
zfGd7)!e1F3Q9|NJ-R1QuS3qT*gfnMAp+x%{Tc#xe0=~`lE~M&D^zX3sGNmk%H+2{z
ze0oeWevuQ}F>S33WuAbULt3aVAt01L!L^q(Y{YT4_kp6ds$xf5($PBXhAY@qvb9#<
zIzP*ZUs|D;#u8dIT|a~0<MsD*9ai>A=#K|gpGT0LEe(*1+rx}=9XXPPdPO`uhH#65
zQuo&)U}PUWI>tR^sdoUTVQ-s~<f-xQo9png)Sjpe3d@i1ka4wzUQ^j{VjlDG0jEIV
zp?J)5jGEd+PyGMAwFrEC4UrWFWrWy4<VS9ZnFweq%$}0T4FN<!i!3ToE>j4SAogEO
z`iBVd|Keh%5M~8vo<$9EX9+>j690l~kP+B_bKU<UOOoJKmNWz@3s%Tbfj`qoL8fe4
z$g&&=WXnKE6hLBmC^(bN4f&-4E-OPp+8l1kJ6+I4hYB?PhX_3|I!7AfY6QMBgo4lv
zQqaJf^Z~~Io1G2#FjpSpZV$TIQGrgm+>m?+@RL0hEc=H`?%+)BztP@cg%=d$LvTYv
z0zkkY3Z`e1f-gS&Zy%K~5P^_}aK?kb5FGUX6&fZ6h9d+6gY5rj{Ra#aK-N4-(wQU-
t3>#N#Ex4<j$8$?JH*hSC5{ydu-;N(a@Kc^HL?;bA&11o>PXAB!{{g9MRGk0-

delta 4457
zcmV-v5ti<|!UCPZ0<bV83TL5P`OOXh0N6W|Iwc=}TU}G*Iud=~s{IeCyyIAwKPkx8
zg(Q$7fhA!Rc+3Pdq%IIP$;{llzkZJ_$(CBSC*)y@Q6EX&l8(C7lF$D2*ZW)NXTIBS
zwjbwR=K0-D{;}RZZ$7@CcmMM+I!U{o{bBX-yn5Sy<mcVL^L_VU{eS-B?ALbp=l(U%
z4;{3B@UcJdz8(&rr@h{O{hGh8_TKh0|A6FWyL(?9@Za6{-u`o!ubzua?{B@p_v7CC
zYV*;REu8L-X=D5HvRUVY?fS=i{&A3v?DDtO0s8M>H=ldm+WY#L=H6GkKYx6ltheu<
zXyV)EZFBg$XtdjTU!RV@e{6TFZ*Q>sFBYzU*1GNDKTh-SoAqwH-@Y6?G}n`gx;AIM
ztcRBRXU`j0AcnoO%U{mBf3VXh7I%C7vtoc2oBY?__`7pheVgZR`TCGQW1hO5!}fEM
zzZ@>}w>MFlcRON6zHPUEimGFPd~~ues)$Zj>%-<}F5&lKhFSe@(XaR$o%YIJ&A+vO
z2BTsY|Gn!x=P#=tZ-?3T*LA-6{(68a5k^G}&gt{tgM7cnte|Tzh(xRF?HiiFzn%9D
zmRAs9SXY1H525bn`S6PRDEpT052KA}tlL@t*dMm<OC>B+ldTjA4pxU%|7^GY)xl~3
zdjGi+Ymc3xzXmnXzW`qdv>dtf?jA#b^RpkG^?t(IwL)BKgiu^m8PI|uEf~>)D_U?(
z3&ynI##Jn`6`Rm1Q(ACK3+`yaz1vG-_cEhZ=Ct6!DCl7h%89@feqkbj##GBG$jB6!
zGT)XBOc@Jo;m{J=vXLcYw(!anl18tsirlU^HiblX(_-SJ#l)#8i|zhy+pM^MYq8?K
zMVVQPGIOg#G8qr1Fts&Zv~;*^>F}|w!>9TVt!0Q!<@jaz2QT&jGUXSl)JqcI{ITH)
z-7O@NE>c;VdOl~F@e770WQ`0ZGV*v5naIRJjwBMknaAnyglK#vrLo6--rml&L}p%+
zM!umPF>I{6<B=aa-Q83JWcHSSK{3+Kq;`O&wWYVJ)MHT^#-<(i(z+{g0p=&IW{9x*
zUQdHP3t8l7IXl{(xgHl5$1$0N2d!6@1qnCilkDURfqUuS^B#llXT2BUhEk7c$%iLo
zZ(hoJGpk;JMQY6fmJX@+DC^Cwddw3Rn9I{ya!<0}gH<o{h;dld)tp;@Oboxo#IVjA
zU&vBn<nNd$k(7zD6vie=>@4G<mikHRF7lC<CQ%*ZTBX-Y>U%5;npg5zH^L)xy=0lo
zxLWfjwWZT)(0;?tTUFm<JPI=6YwjvxKsNV#t#=%QOk_`+Nnzwgku_&7?dH0NEc7FW
zqk#SqB0rS#lrm;CN?;3r0edOJir3XHf9}eddJ&#35L0*dn<5&%4^7%JFOEZNl!hl{
z9G3OXF2mEMZkBcXGpkw0c+4neWzlSZZq>^?Iug!a^;ECUQ&^lF3M+$d|AAQPlaVuL
z%_1!#=r6d>s30vFunSr0>`bnAxRgjrT3O1xDDy*O3Bmo+fUiV<);Ot=RwGIR!%6sV
zGglfJGluPq27pqEjV}tZP|F{&daQN%J(rIjpUKh4sYD(@x?45o@Umf$m=1t=*%Ftr
zfH#x#Ug8ojU{<i>hA^{ogi=>H*FryvLz9uVRu5$xNy?fx)`fssTY+Rh4s}2Kb*fU%
z*Vbp^Ao{b<JT44>AXOfVD*bt6Z!g3gaDZ%=PqkeIWmm+`M&gPc?&x#yA8|okvaMgp
z(jykpr9>V<@qtGAEGDruC3A($jOFILj2uZM_jp$0x39D`j8ii-!jw^FOC<BXILLUT
z`xz@3g7n{PBsXeUX)NcuzRA(Z>CwnriA2niiY<@OSqlSyKM0Z*I!j#aG4phgiO`<<
z`Es>{u5hl$EJ%4s&i4;m7AA2<WD6l{BCb%%Tp40%P~z6sSH#7_4oy!WTmfZqQNKTr
zZ59_+xYVuftfX#Xp0TPLshfO>x=BG@Mx5q_Dn>lxhGdsg=$tX!bvcm80Mz<TL^{;S
zAhPJ{y4R6^L`KEY)z|}Y!lB355*b-cbCK7|T%3pFki>ywJrtaWHD_0?cbHjc3g}H1
z_@qMO>_CK5DGa^Lj0t?PBnk3XB9RUCK}&N-A`C5Y0n4HmhDsdwBAi-UhjUg=5l$h_
zV9(283Nw>dH2BuADD-*rVS6E9O~iF{g*N0+ysWK%uZSBUxDXbQI*&!2{yeeCiVde`
z8lGx9D9Kt_*T_(D|8cx?O(jEVR!J6zIC%T!iNoDIFC~(DvF`>-11$`~&|FMzQfR1=
zEQ-v~%yon#iHy7~^=pz#rIcGPyoQy^@*=s=a_m(wFHM=1_HvKC8tDhI+ucM;k<0R}
z97qj+Tgx6Jq`j;?nat9yM2drZlyQ0_u7sI$UcRriNmFBjvB{D?W@R%`#KUH$&$ZT3
z8gOH?q72or*pCBqX_1VqfHg5xjG?79wnNI$+WKWoOiZ!TLd8YOV^P09Pi?jqwz;mg
zwzHD0#8Qhw)^S!`aUD<GOcIymFfUZG7lwg<JDHbSiY3~9S{+Cv_cCsIOm|@qH8ROk
zlSVbnmB_@i4_`GIq$`c|eQV!vb4}OEBH#0)pd~EUO2+AL48PIHC<wAvk2R6V&<lA@
zWIvVC*h@l-@NQ=BRwChZ!-$z)l2GTa#38~Z(|)gI9ARqOJPxxGmm=S9Y_uc-pX-Hx
zB6dB}*MpY9GDhNug^)FSR;rwnFk05uSG?t(P`ZY!MWy~cv&kw{Hy5PK+uF`b-U{;q
zV{dG9xC~DazCc{Si<3FcM5%HF{y6ru?)#St%CWetLxLMP4a!z|Y$xsA1XTsK0@|7+
z)JQ>7C=i$%iL1a>1&yrz!QGv%^~k_~CHwSDI95V9yBPD*9Gc!#z|hZFGjL)6lK{~~
zQ%ZMQ0udFb=B_{(dRqZus&%_X!sil*HI|tH4^3X{A@L$VrbL`oLL5Oz%647}d6c#|
z<O-K2P`YUl76q<}+Q@$j{Tzxd>uVW~7>YZ!9%ZdQY#{#EHpM-^Jk|GCMb5T=jaCDe
zFJ|K9!12x)@PgAcNu|r-^8A(+cByb!+=3(qqsR&yR6y+XoMxpADGdill?*8r#EaFB
zye}|;eoNBzS{vsh6mMb0xM~nLja09jQktew7#Xh1c~c_C*!Q9|OTuOYrsbgfNX{Ck
z0Eex*K@5krHIY2eU8y2xJWU;cippjZFGMRuI8#+|+0AeSuGmFpZmw`hQgU4KkUVlJ
z45B1!&VnxrTyrK_=x1z)F7KB04JfuM8*11p2H*v3WhPstDTV{CNhjC$r`U>vG|V+m
z9L*jWZ!NyUR$MwEHy+Tm6kc`}udF;|!_15l*;+3Z&i4Q_uL6BCtAi4Mm<2dx8K#gK
z9vZ-yg~p(fu16&>OmSt|d~Cg{fS`cs`ALh{3W&sV;v;j>v@MLw1_RCmGe1sfb)$et
z%Oy!fdYhC&3`onfiD@+zjC13JO4_?E+d~%0yo#Y2Wo@O08*U$&-128r?OwMRdTD?I
zK>2fcEtd)}LNH^~BJuElT(uWtNhOJaqt7u)T)-po(n9~}wQ+%KqIlqiw$|=>X<6Su
z8DVool;$4nM2U~G0kAzV+3pzVrYN84yH;$EF*BCsRxn}v=C3`Q!b{VF?KH)u${8}v
zb_{DTiA#m!$lkKdm>b76%YH%+PLmk{m&0|9<9^!WheujJFJ*CmOEUAS!UcFGV=I5H
zh1iXQ7UjnZ=X=OB$EMSy4+Rx4^LQAUiC@QCODi)EXWG~pHA3KNH46xkn%_&@Y8)a>
z=R|r}2|0c(>{c(LeB}2NGA}c2S%OriPsVYs7ZJl5v}N;qsBjp?=5zR>z%}t0VW1y5
z3NGvGDC#092DOcUsK`w;Jjw<@UGgf65t|&+Kh<|#I%;McYn=jZ>VEB=6;rQ+Xp&2n
zC&-y_-n^S%DjdVch!=2;yXrvWQoOyw6;YFS7#g^U-sFt5QrPMd%2u5b<*!N{wjJj1
zwS0_~g)M$ytTn+KoHQiP=|%~;NIpf)!!yyiqzGgho!wM_YaHS2Rcag&9cL_+4>2u)
zxGrsQvUjRI;Fz5<q|R8j2agR(Iv&^%nn9QoSxa0R;10@sen>|CK`8~CA19=dMImga
ztB5ID9(OM5t1IUExW9yJX<nX>vO0KcJ(NmCd~90e=4PMjJ660!12EMH`K$(P-hS<=
z6+W>jT&|OU;!-bSd^kzwe9Rz)Vdf!$X&jXZZlD@ZvC6D_U$Q`k6%L6&Ba|Z^ZKRbI
z&y3CU5jh23RXC3Ol*ZM4t#B;F{Lm)@V<imXj^Sh)cch!L5u}${b5>?j;_w=ek%(kk
zYK+(=Z4T{kwNf$OmM|xBR?`9@CxpM(y+<+kNawSEN(K{XdRYlEkYHQOW6BbjcyMmy
zj;Ii}WTfDKjaeeoxvZ~UWv1}5t2rh3C~Jd~))OjF8Ho_nAhMA>)%U6hDXJrItbI{t
z)A4H$sPOc&prezWQsoGTM1HDizrIxUajlJ8mgYq}P&gi@SV(5-+@83hg|lTN-51Ne
zAR+62?aB}$&ZD8Ow$ck?Bo3Oa8S6&i?4!7ig6hpsio5NWm%J0z9+Ipc?v|=<$>ujL
zl}}wl+-hNhO&N31bpE@uaLq>ED;&HMcuR;gD}@>MD2JNr#S=DHJZfzm#s{qlzT&_$
zdrD3DGzn_hheW7jK4GRG4HRuUj4ty}euh_npp{1Sg@vpQPSOWa<av;-tN4bo=FX~m
z)QBugWuBy={Ps|O+V`ICz87C9?mO%45AiLbIAoNi@?G}@JH=;oc#%oUZ`dh5d~?h1
z*(ttV6JI%2&G*kfSKssLYWIEfvG2U$Q%dpKBHm-|<adq5-}uO~D22cNwmsmxME$>E
zSA58t;}b#bG2PC~c6-qOK_{Z!d4Blu+1c(k_#CqMHub#wx!oOhtIeU?c}4mEwh+7x
zKJhX=3^F8EMHaa$zQjFj)-{6N=?0&4?#9oB9nZVfFMOffDNBp-?Umo;_LCru7PC+_
z7Fh+AtQaOpvulnf0e?|X!ypue-%b1v4eu>&H>V?Qm#Ep3OHAxC;~RmyjaZ-owA;Uz
zwp*>v2Or^_`*F?<+2SCp;1i4$TIDE-VibU4nhUkd(YjoQcPOxqDo!h{AV){AXi;2W
zWvnJl8+bOl2IB<Sz>}0Etj^Kixtd^X*&Zadk#{IBZncrr`G2F?;hM5{x&xfX@eE6F
zlv77>3k>Ulh)zh(24wwVst&*zh6*GoXK@lG_}lBiNc-nNr;MCZxMS@*o#Kw!ob}@1
zK3Fjro2H4HNf*QCPw?yN>7}b03f1n40V*=i2s1#PHpNCLt{WSyEtm|Cgm#G)wQlA2
zy%oUkkH5T^x<co6HF`Mkzy~9JjkB_uJUo_5RHSio8^-f6nU!%&k~z7VzO~Q)m~Vsj
z7xEP1Kg4;N#$=k3$!tVC1Bwh^e2(G^lVD^Nv*wUs2nuJRTlvin007uKlTevf0wpw)
zUNt3?&6z3!K{b<lHYJlDnkoWfHj^=%7n5O{Gy-uqlQEkYldhUH0)aS_F`E~Y`<gTY
zkvWqwn@a(qlQ5eYla-q^0<k-jF`E~Y;+r%A!90@~oInDSL6cgXK?1@;lbxJF0`fzX
z;G94L!$^}Noj?LnQj=tzK>~qOlc$|P0#aC$>776VNn?{Mo<ssvW|MKAK>~zlleC^d
z0>N;T_MSijl68|fpFjd*dXsveKmsg-lf0im0t<|j{+}ltm8=*hNC5x<X#xNM5dZ)H
v00000000000029UlR=<80=kcrfS^1AdXkgApi=@gl#>&oA_kO|00000sx^_x

diff --git a/src/main.cpp b/src/main.cpp
index 9d50934..fcbc299 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -13,8 +13,8 @@
 #include <stream_compaction/thrust.h>
 #include <stream_compaction/radix.h>
 #include "testing_helpers.hpp"
-const int SIZE = 1 << 10; // feel free to change the size of array
-const int NPOT = SIZE - 3; // Non-Power-Of-Two
+const int SIZE = 1 << 4; // feel free to change the size of array
+const int NPOT = SIZE - 12; // Non-Power-Of-Two
 //int a[SIZE], b[SIZE], c[SIZE], d[SIZE];
 
 int main(int argc, char* argv[]) {

From 34075e959218fa1804adf61b1eb748cd7dde1074 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Tue, 19 Sep 2017 20:04:26 -0400
Subject: [PATCH 21/27] final formatting?

---
 README.md | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index ac87187..13c8c0d 100644
--- a/README.md
+++ b/README.md
@@ -4,18 +4,20 @@ CUDA Stream Compaction
 **University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 2**
 
 Sarah Forcier
+
 Tested on GeForce GTX 1070
 
 ### Overview
-This project provides an introduction to parallel algorithms on integer arrays: 
-* Scan : Computes a exclusive sum of all integers that came before each element.
-* Stream Compaction : Removes 0's from an array of integers.
+This project provides an introduction to parallel algorithms on integer arrays
+* Scan : Computes a exclusive sum of all integers that came before each element in the array
+* Stream Compaction : Removes 0's from an array of integers
 * Radix Sort : Sorts an array of integers from least to most significant bits 
 
-### Parallel Algorithm Descriptions
+### Parallel Algorithms
 #### Naive Scan
 
 The diagram below illustrates the naive parallel scan algorithm. It starts by adding adjacent values, and then adding those values, and so on. This requires log2n iterations, and also requires additional memory since the algorithm cannot work in place.
+
 ![](img/naive.jpg)
 
 #### Work Efficient Scan
@@ -24,21 +26,23 @@ In contrast to the naive scan, the work efficient algorithm works in place. The
 
 ![](img/upsweep.jpg)
 
-In the down-sweep stage, the root of the tree is replaced with $0$ and at each step, the node of the current level is passed to its left child and the sum of its value and the left child is passed to the right, as seen below.
+In the down-sweep stage, the root of the tree is replaced with *0* and at each step, the node of the current level is passed to its left child and the sum of its value and the left child is passed to the right, as seen below.
 
 ![](img/downsweep.jpg)
 
-Each pass in up-sweep requires almost $n$ iterations, so n threads must be allocated even if some threads will not be used, so can retire early. However, for down-sweep an additional optimization can be used to only allocated the needed number of threads per level.
+Each pass in up-sweep requires almost *n* iterations, so *n* threads must be allocated even if some threads will not be used, so can retire early. However, for down-sweep an additional optimization can be used to only allocated the needed number of threads per level.
 
 Because the up-sweep and down-sweep algorithms rely on the size of the array being a power-of-two, non-power-of-two arrays must be right extended to the next largest power-of-two in order to maintain correct indexing.  
 
 #### Stream Compaction
 
-The stream compaction algorithm start by creating a temporary boolean array where each element is $1$ if the value at that index in the input array is not zero and $0$ otherwise. Next this boolean array is scanned using the implementation above. The result of the scan is the index into the final array, so if the value of an index in the boolean array is $1$, then the value at that same index in the input array can be placed in the final array at the new index specified by the scanned array.  
+The stream compaction algorithm start by creating a temporary boolean array where each element is *1* if the value at that index in the input array is not zero and *0* otherwise. Next this boolean array is scanned using the implementation above. The result of the scan is the index into the final array, so if the value of an index in the boolean array is *1*, then the value at that same index in the input array can be placed in the final array at the new index specified by the scanned array.  
 
 #### Radix Sort
 
-The parallel implementation for radix sort begins similarly to the above stream compaction algorithm. First for bit $k$, a temporary boolean array $b$ is created where is element is $0$ if the $k$-th bit in the input array is $1$ and visa versa. A scan is run on this boolean array. Next the total number of falses (or the number of values whose $k$-th bit is $0$) is calculated by summing the last element in the boolean array and the scanned result of this boolean array. This value is used to create another array $t$ where each value at index $i$ is equal to $ i - s[i] + totalFalses $ where $s$ is the scanned array. The last array to be computed contains the indices of each input element in the array sorted by $k$-th bit. The values in this array are equal to $b[i] ? f[i] : t[i]$. While this algorithm requires multiple passes and new arrays, it is not necessary to allocate space for each step. Some steps can be done in place, and later steps can overwrite previous ones once they are no longer needed. 
+The parallel implementation for radix sort begins similarly to the above stream compaction algorithm. First for bit *k*, a temporary boolean array *b* is created where is element is *0* if the *k*-th bit in the input array is *1* and visa versa. A scan is run on this boolean array. Next the total number of falses (or the number of values whose *k*-th bit is *0*) is calculated by summing the last element in the boolean array and the scanned result of this boolean array. This value is used to create another array *t* where each value at index *i* is equal to * i - s[i] + totalFalses * where *s* is the scanned array. The last array to be computed contains the indices of each input element in the array sorted by *k*-th bit. The values in this array are equal to *b[i] ? f[i] : t[i]*. While this algorithm requires multiple passes and new arrays, it is not necessary to allocate space for each step. Some steps can be done in place, and later steps can overwrite previous ones once they are no longer needed. 
+
+*Images taken from GPU Gems 3, Chapter 39*
 
 ### Test Program Output
 
@@ -155,5 +159,3 @@ For the work efficient implementation, the upsweep and downsweep kernel function
 
 #### How does the GPU Scan implementation compare to thrust?
 Thrust exclusive scan on power-of-two sized arrays performs poorly but consistently for most array size except the largest. The consistency indicates that the thrust implementation might have a large overhead. While other implementations' runtimes increase exponentially with array size, thrust with power-of-two arrays remains around 10ms for all array sizes. However, the thrust method on non-power-of-two arrays behaves more closely to the other gpu scan implementations with an exponential increase but with a much better performance. An explanation for the poor performance with power-of-two arrays might be that thrust implementation might allocate and compute on more memory with these sizes but not for non-power-of-two arrays - the opposite of what the work efficient method does. According to the Nsight performance analysis, thrust also has low warp occupancy (25%) and high number of required registers per thread (78), which could also explain the poor perform for these sized arrays. However, thrust makes good use of shared memory.
-
-Images taken from GPU Gems 3, Chapter 39

From 160374b19ce00403fa08c430e3335c3a280ef487 Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Tue, 19 Sep 2017 20:05:43 -0400
Subject: [PATCH 22/27] final

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 13c8c0d..3b17394 100644
--- a/README.md
+++ b/README.md
@@ -40,7 +40,7 @@ The stream compaction algorithm start by creating a temporary boolean array wher
 
 #### Radix Sort
 
-The parallel implementation for radix sort begins similarly to the above stream compaction algorithm. First for bit *k*, a temporary boolean array *b* is created where is element is *0* if the *k*-th bit in the input array is *1* and visa versa. A scan is run on this boolean array. Next the total number of falses (or the number of values whose *k*-th bit is *0*) is calculated by summing the last element in the boolean array and the scanned result of this boolean array. This value is used to create another array *t* where each value at index *i* is equal to * i - s[i] + totalFalses * where *s* is the scanned array. The last array to be computed contains the indices of each input element in the array sorted by *k*-th bit. The values in this array are equal to *b[i] ? f[i] : t[i]*. While this algorithm requires multiple passes and new arrays, it is not necessary to allocate space for each step. Some steps can be done in place, and later steps can overwrite previous ones once they are no longer needed. 
+The parallel implementation for radix sort begins similarly to the above stream compaction algorithm. First for bit *k*, a temporary boolean array *b* is created where is element is *0* if the *k*-th bit in the input array is *1* and visa versa. A scan is run on this boolean array. Next the total number of falses (or the number of values whose *k*-th bit is *0*) is calculated by summing the last element in the boolean array and the scanned result of this boolean array. This value is used to create another array *t* where each value at index *i* is equal to *i - s[i] + totalFalses* where *s* is the scanned array. The last array to be computed contains the indices of each input element in the array sorted by *k*-th bit. The values in this array are equal to *b[i] ? f[i] : t[i]*. While this algorithm requires multiple passes and new arrays, it is not necessary to allocate space for each step. Some steps can be done in place, and later steps can overwrite previous ones once they are no longer needed. 
 
 *Images taken from GPU Gems 3, Chapter 39*
 
@@ -152,7 +152,7 @@ Much like scan and compaction, GPU radix sort performs faster for large array si
 ### Q&A
 
 #### Compare GPU Scan implementations to the serial CPU version?
-The GPU version performs better for scan, stream compaction, and radix sort for large arrays (SIZE < 2^[18]). Since the intersection between the CPU and GPU methods occurs at the same sized array, it suggests that the slow GPU performance for small arrays is based on a overhead required for creating and distributing threads. One that is only surpassed with large arrays.  
+The GPU version performs better for scan, stream compaction, and radix sort for large arrays (*SIZE < 2^[18]*). Since the intersection between the CPU and GPU methods occurs at the same sized array, it suggests that the slow GPU performance for small arrays is based on a overhead required for creating and distributing threads. One that is only surpassed with large arrays.  
 
 #### Where are the performance bottlenecks?
 For the work efficient implementation, the upsweep and downsweep kernel functions require a similar amount of time, because they have the same ratio of compute to memory instructions. Most time is spent in memory reads and writes, but since there are not many of either type of instruction, it is not possible to space out the memory instructions with computations. 

From c25edad3837af2dd2dda164bba2bf08cd47946ac Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Tue, 19 Sep 2017 20:12:59 -0400
Subject: [PATCH 23/27] undo testing comments and code

---
 src/main.cpp | 164 +++++++++++++++++++++++++--------------------------
 1 file changed, 82 insertions(+), 82 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index fcbc299..053af8c 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -14,7 +14,7 @@
 #include <stream_compaction/radix.h>
 #include "testing_helpers.hpp"
 const int SIZE = 1 << 4; // feel free to change the size of array
-const int NPOT = SIZE - 12; // Non-Power-Of-Two
+const int NPOT = SIZE - 3; // Non-Power-Of-Two
 //int a[SIZE], b[SIZE], c[SIZE], d[SIZE];
 
 int main(int argc, char* argv[]) {
@@ -100,87 +100,87 @@ int main(int argc, char* argv[]) {
 
     // Compaction tests
 
- //   genArray(SIZE - 1, a, 4);  // Leave a 0 at the end to test that edge case
- //   a[SIZE - 1] = 0;
- //   printArray(SIZE, a, true);
-
- //   int countSIZE, countNPOT, expectedSIZE, expectedNPOT;
-
- //   // initialize b using StreamCompaction::CPU::compactWithoutScan you implement
- //   // We use b for further comparison. Make sure your StreamCompaction::CPU::compactWithoutScan is correct.
- //   zeroArray(SIZE, b);
- //   printDesc("cpu compact without scan, power-of-two");
- //   countSIZE = StreamCompaction::CPU::compactWithoutScan(SIZE, b, a);
- //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-	//expectedSIZE = countSIZE;
- //   printArray(expectedSIZE, b, true);
- //   printCmpLenResult(countSIZE, expectedSIZE, b, b);
-
- //   zeroArray(SIZE, c);
- //   printDesc("cpu compact without scan, non-power-of-two");
-	//countNPOT = StreamCompaction::CPU::compactWithoutScan(NPOT, c, a);
- //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
- //   expectedNPOT = countNPOT;
- //   printArray(countNPOT, c, true);
- //   printCmpLenResult(countNPOT, expectedNPOT, b, c);
-
- //   zeroArray(SIZE, c);
- //   printDesc("cpu compact with scan");
-	//countSIZE = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
- //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
- //   printArray(countSIZE, c, true);
- //   printCmpLenResult(countSIZE, expectedSIZE, b, c);
-
- //   zeroArray(SIZE, c);
- //   printDesc("work-efficient compact, power-of-two");
-	//countSIZE = StreamCompaction::Efficient::compact(SIZE, c, a);
- //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(expectedSIZE, c, true);
- //   printCmpLenResult(countSIZE, expectedSIZE, b, c);
-
- //   zeroArray(SIZE, c);
- //   printDesc("work-efficient compact, non-power-of-two");
-	//countNPOT = StreamCompaction::Efficient::compact(NPOT, c, a);
- //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(expectedNPOT, c, true);
- //   printCmpLenResult(countNPOT, expectedNPOT, b, c);
-
- //   printf("\n");
- //   printf("*****************************\n");
- //   printf("** RADIX SORT TESTS **\n");
- //   printf("*****************************\n");
-
- //   // Radix Tests
-
-	//int k = 4;
-	//genArray(SIZE - 1, a, 1 << k); 
- //   printArray(SIZE, a, true);
-
- //   zeroArray(SIZE, b);
- //   printDesc("cpu sort, power-of-two");
- //   StreamCompaction::CPU::sort(SIZE, b, a);
- //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
- //   printArray(SIZE, b, true);
-
- //   zeroArray(SIZE, c);
- //   printDesc("cpu sort, non-power-of-two");
- //   StreamCompaction::CPU::sort(NPOT, c, a);
- //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
- //   printArray(NPOT, c, true);
-
- //   zeroArray(SIZE, d);
- //   printDesc("radix sort, power-of-two");
- //   StreamCompaction::Radix::sort(SIZE, k + 1, d, a);
- //   printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(SIZE, d, true);
-	//printCmpResult(SIZE, b, d);
-
- //   zeroArray(SIZE, d);
- //   printDesc("radix sort, non-power-of-two");
- //   StreamCompaction::Radix::sort(NPOT, k + 1, d, a);
- //   printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(NPOT, d, true);
- //   printCmpResult(NPOT, c, d);
+    genArray(SIZE - 1, a, 4);  // Leave a 0 at the end to test that edge case
+    a[SIZE - 1] = 0;
+    printArray(SIZE, a, true);
+
+    int countSIZE, countNPOT, expectedSIZE, expectedNPOT;
+
+    // initialize b using StreamCompaction::CPU::compactWithoutScan you implement
+    // We use b for further comparison. Make sure your StreamCompaction::CPU::compactWithoutScan is correct.
+    zeroArray(SIZE, b);
+    printDesc("cpu compact without scan, power-of-two");
+    countSIZE = StreamCompaction::CPU::compactWithoutScan(SIZE, b, a);
+    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+	expectedSIZE = countSIZE;
+    printArray(expectedSIZE, b, true);
+    printCmpLenResult(countSIZE, expectedSIZE, b, b);
+
+    zeroArray(SIZE, c);
+    printDesc("cpu compact without scan, non-power-of-two");
+	countNPOT = StreamCompaction::CPU::compactWithoutScan(NPOT, c, a);
+    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+    expectedNPOT = countNPOT;
+    printArray(countNPOT, c, true);
+    printCmpLenResult(countNPOT, expectedNPOT, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("cpu compact with scan");
+	countSIZE = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
+    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+    printArray(countSIZE, c, true);
+    printCmpLenResult(countSIZE, expectedSIZE, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("work-efficient compact, power-of-two");
+	countSIZE = StreamCompaction::Efficient::compact(SIZE, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(expectedSIZE, c, true);
+    printCmpLenResult(countSIZE, expectedSIZE, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("work-efficient compact, non-power-of-two");
+	countNPOT = StreamCompaction::Efficient::compact(NPOT, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(expectedNPOT, c, true);
+    printCmpLenResult(countNPOT, expectedNPOT, b, c);
+
+    printf("\n");
+    printf("*****************************\n");
+    printf("** RADIX SORT TESTS **\n");
+    printf("*****************************\n");
+
+    // Radix Tests
+
+	int k = 4;
+	genArray(SIZE - 1, a, 1 << k); 
+    printArray(SIZE, a, true);
+
+    zeroArray(SIZE, b);
+    printDesc("cpu sort, power-of-two");
+    StreamCompaction::CPU::sort(SIZE, b, a);
+    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+    printArray(SIZE, b, true);
+
+    zeroArray(SIZE, c);
+    printDesc("cpu sort, non-power-of-two");
+    StreamCompaction::CPU::sort(NPOT, c, a);
+    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+    printArray(NPOT, c, true);
+
+    zeroArray(SIZE, d);
+    printDesc("radix sort, power-of-two");
+    StreamCompaction::Radix::sort(SIZE, k + 1, d, a);
+    printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(SIZE, d, true);
+	printCmpResult(SIZE, b, d);
+
+    zeroArray(SIZE, d);
+    printDesc("radix sort, non-power-of-two");
+    StreamCompaction::Radix::sort(NPOT, k + 1, d, a);
+    printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(NPOT, d, true);
+    printCmpResult(NPOT, c, d);
 
     system("pause"); // stop Win32 console from closing on exit
 }

From 8fdd951f74a8dbce3abc2d6078bacbd6b65d836d Mon Sep 17 00:00:00 2001
From: Sarah Forcier <sforcier@seas.upenn.edu>
Date: Fri, 29 Sep 2017 11:59:28 -0400
Subject: [PATCH 24/27] incorrect thread numbers spawned

---
 performance.xlsx                      | Bin 41275 -> 40989 bytes
 src/main.cpp                          | 229 +++++++++++++++-----------
 stream_compaction/CMakeLists.txt      |   2 +
 stream_compaction/common.h            |   3 +
 stream_compaction/efficient_shared.cu | 202 +++++++++++++++++++++++
 stream_compaction/efficient_shared.h  |  15 ++
 6 files changed, 351 insertions(+), 100 deletions(-)
 create mode 100644 stream_compaction/efficient_shared.cu
 create mode 100644 stream_compaction/efficient_shared.h

diff --git a/performance.xlsx b/performance.xlsx
index 466c3d797fae3e8621d0dfe937749a0408225c1e..010f062410747db2f722cce30cd3bd00d12157bb 100644
GIT binary patch
delta 4430
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
UzMxYAG?bGQp&|y9l>h($0QUHerT_o{

delta 4823
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

diff --git a/src/main.cpp b/src/main.cpp
index 053af8c..a4123d6 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -10,10 +10,11 @@
 #include <stream_compaction/cpu.h>
 #include <stream_compaction/naive.h>
 #include <stream_compaction/efficient.h>
+#include <stream_compaction/efficient_shared.h>
 #include <stream_compaction/thrust.h>
 #include <stream_compaction/radix.h>
 #include "testing_helpers.hpp"
-const int SIZE = 1 << 4; // feel free to change the size of array
+const int SIZE = 1 << 3; // feel free to change the size of array
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 //int a[SIZE], b[SIZE], c[SIZE], d[SIZE];
 
@@ -31,7 +32,7 @@ int main(int argc, char* argv[]) {
     printf("****************\n");
 
     genArray(SIZE - 1, a, 50);  // Leave a 0 at the end to test that edge case
-    a[SIZE - 1] = 0;
+    //a[SIZE - 1] = 0;
 
     printArray(SIZE, a, true);
 
@@ -51,47 +52,61 @@ int main(int argc, char* argv[]) {
     printArray(NPOT, b, true);
     printCmpResult(NPOT, b, c);
 
-    zeroArray(SIZE, c);
-    printDesc("naive scan, power-of-two");
-    StreamCompaction::Naive::scan(SIZE, c, a);
-    printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, c, true);
-    printCmpResult(SIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("naive scan, non-power-of-two");
-    StreamCompaction::Naive::scan(NPOT, c, a);
-    printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(NPOT, c, true);
-    printCmpResult(NPOT, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("work-efficient scan, power-of-two");
-    StreamCompaction::Efficient::scan(SIZE, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, c, true);
-    printCmpResult(SIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("work-efficient scan, non-power-of-two");
-    StreamCompaction::Efficient::scan(NPOT, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(NPOT, c, true);
-    printCmpResult(NPOT, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("thrust scan, power-of-two");
-    StreamCompaction::Thrust::scan(SIZE, c, a);
-    printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, c, true);
-    printCmpResult(SIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("thrust scan, non-power-of-two");
-    StreamCompaction::Thrust::scan(NPOT, c, a);
-    printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(NPOT, c, true);
-    printCmpResult(NPOT, b, c);
+ //   zeroArray(SIZE, c);
+ //   printDesc("naive scan, power-of-two");
+ //   StreamCompaction::Naive::scan(SIZE, c, a);
+ //   printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(SIZE, c, true);
+ //   printCmpResult(SIZE, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("naive scan, non-power-of-two");
+ //   StreamCompaction::Naive::scan(NPOT, c, a);
+ //   printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(NPOT, c, true);
+ //   printCmpResult(NPOT, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("work-efficient scan, power-of-two");
+ //   StreamCompaction::Efficient::scan(SIZE, c, a);
+ //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(SIZE, c, true);
+ //   printCmpResult(SIZE, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("work-efficient scan, non-power-of-two");
+ //   StreamCompaction::Efficient::scan(NPOT, c, a);
+ //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(NPOT, c, true);
+ //   printCmpResult(NPOT, b, c);
+
+	//zeroArray(SIZE, c);
+	//printDesc("shared scan, power-of-two");
+	//StreamCompaction::Efficient_Shared::scan(SIZE, c, a);
+	//printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+	//printArray(SIZE, c, true);
+	//printCmpResult(SIZE, b, c);
+
+	zeroArray(SIZE, c);
+	printDesc("shared scan, non-power-of-two");
+	StreamCompaction::Efficient_Shared::scan(NPOT, c, a);
+	printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+	printArray(NPOT, c, true);
+	printCmpResult(NPOT, b, c);
+
+    //zeroArray(SIZE, c);
+    //printDesc("thrust scan, power-of-two");
+    //StreamCompaction::Thrust::scan(SIZE, c, a);
+    //printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    //printArray(SIZE, c, true);
+    //printCmpResult(SIZE, b, c);
+
+    //zeroArray(SIZE, c);
+    //printDesc("thrust scan, non-power-of-two");
+    //StreamCompaction::Thrust::scan(NPOT, c, a);
+    //printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    //printArray(NPOT, c, true);
+    //printCmpResult(NPOT, b, c);
 
     printf("\n");
     printf("*****************************\n");
@@ -124,63 +139,77 @@ int main(int argc, char* argv[]) {
     printArray(countNPOT, c, true);
     printCmpLenResult(countNPOT, expectedNPOT, b, c);
 
-    zeroArray(SIZE, c);
-    printDesc("cpu compact with scan");
-	countSIZE = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
-    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(countSIZE, c, true);
-    printCmpLenResult(countSIZE, expectedSIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("work-efficient compact, power-of-two");
-	countSIZE = StreamCompaction::Efficient::compact(SIZE, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(expectedSIZE, c, true);
-    printCmpLenResult(countSIZE, expectedSIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("work-efficient compact, non-power-of-two");
-	countNPOT = StreamCompaction::Efficient::compact(NPOT, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(expectedNPOT, c, true);
-    printCmpLenResult(countNPOT, expectedNPOT, b, c);
-
-    printf("\n");
-    printf("*****************************\n");
-    printf("** RADIX SORT TESTS **\n");
-    printf("*****************************\n");
-
-    // Radix Tests
-
-	int k = 4;
-	genArray(SIZE - 1, a, 1 << k); 
-    printArray(SIZE, a, true);
-
-    zeroArray(SIZE, b);
-    printDesc("cpu sort, power-of-two");
-    StreamCompaction::CPU::sort(SIZE, b, a);
-    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(SIZE, b, true);
-
-    zeroArray(SIZE, c);
-    printDesc("cpu sort, non-power-of-two");
-    StreamCompaction::CPU::sort(NPOT, c, a);
-    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(NPOT, c, true);
-
-    zeroArray(SIZE, d);
-    printDesc("radix sort, power-of-two");
-    StreamCompaction::Radix::sort(SIZE, k + 1, d, a);
-    printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, d, true);
-	printCmpResult(SIZE, b, d);
-
-    zeroArray(SIZE, d);
-    printDesc("radix sort, non-power-of-two");
-    StreamCompaction::Radix::sort(NPOT, k + 1, d, a);
-    printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(NPOT, d, true);
-    printCmpResult(NPOT, c, d);
+ //   zeroArray(SIZE, c);
+ //   printDesc("cpu compact with scan");
+	//countSIZE = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
+ //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+ //   printArray(countSIZE, c, true);
+ //   printCmpLenResult(countSIZE, expectedSIZE, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("work-efficient compact, power-of-two");
+	//countSIZE = StreamCompaction::Efficient::compact(SIZE, c, a);
+ //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(expectedSIZE, c, true);
+ //   printCmpLenResult(countSIZE, expectedSIZE, b, c);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("work-efficient compact, non-power-of-two");
+	//countNPOT = StreamCompaction::Efficient::compact(NPOT, c, a);
+ //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(expectedNPOT, c, true);
+ //   printCmpLenResult(countNPOT, expectedNPOT, b, c);
+
+	zeroArray(SIZE, c);
+	printDesc("shared compact, power-of-two");
+	countSIZE = StreamCompaction::Efficient_Shared::compact(SIZE, c, a);
+	printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+	printArray(expectedSIZE, c, true);
+	printCmpLenResult(countSIZE, expectedSIZE, b, c);
+
+	zeroArray(SIZE, c);
+	printDesc("shared compact, non-power-of-two");
+	countNPOT = StreamCompaction::Efficient_Shared::compact(NPOT, c, a);
+	printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+	printArray(expectedNPOT, c, true);
+	printCmpLenResult(countNPOT, expectedNPOT, b, c);
+
+ //   printf("\n");
+ //   printf("*****************************\n");
+ //   printf("** RADIX SORT TESTS **\n");
+ //   printf("*****************************\n");
+
+ //   // Radix Tests
+
+	//int k = 4;
+	//genArray(SIZE - 1, a, 1 << k); 
+ //   printArray(SIZE, a, true);
+
+ //   zeroArray(SIZE, b);
+ //   printDesc("cpu sort, power-of-two");
+ //   StreamCompaction::CPU::sort(SIZE, b, a);
+ //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+ //   printArray(SIZE, b, true);
+
+ //   zeroArray(SIZE, c);
+ //   printDesc("cpu sort, non-power-of-two");
+ //   StreamCompaction::CPU::sort(NPOT, c, a);
+ //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+ //   printArray(NPOT, c, true);
+
+ //   zeroArray(SIZE, d);
+ //   printDesc("radix sort, power-of-two");
+ //   StreamCompaction::Radix::sort(SIZE, k + 1, d, a);
+ //   printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(SIZE, d, true);
+	//printCmpResult(SIZE, b, d);
+
+ //   zeroArray(SIZE, d);
+ //   printDesc("radix sort, non-power-of-two");
+ //   StreamCompaction::Radix::sort(NPOT, k + 1, d, a);
+ //   printElapsedTime(StreamCompaction::Radix::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+ //   printArray(NPOT, d, true);
+ //   printCmpResult(NPOT, c, d);
 
     system("pause"); // stop Win32 console from closing on exit
 }
diff --git a/stream_compaction/CMakeLists.txt b/stream_compaction/CMakeLists.txt
index 68d8d1f..1d1f41d 100644
--- a/stream_compaction/CMakeLists.txt
+++ b/stream_compaction/CMakeLists.txt
@@ -7,6 +7,8 @@ set(SOURCE_FILES
     "naive.cu"
     "efficient.h"
     "efficient.cu"
+	"efficient_shared.h"
+    "efficient_shared.cu"
     "thrust.h"
     "thrust.cu"
     "radix.h"
diff --git a/stream_compaction/common.h b/stream_compaction/common.h
index 6aabc39..b8cc0fe 100644
--- a/stream_compaction/common.h
+++ b/stream_compaction/common.h
@@ -13,6 +13,9 @@
 #define FILENAME (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
 #define checkCUDAError(msg) checkCUDAErrorFn(msg, FILENAME, __LINE__)
 #define blockSize 128
+#define bankSize 16
+#define log_bankSize 4
+#define conflictFreeOffset(n) ((n) >> bankSize + (n) >> (2 * log_bankSize))
 
 /**
  * Check for CUDA errors; print and exit if there was a problem.
diff --git a/stream_compaction/efficient_shared.cu b/stream_compaction/efficient_shared.cu
new file mode 100644
index 0000000..f817418
--- /dev/null
+++ b/stream_compaction/efficient_shared.cu
@@ -0,0 +1,202 @@
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include "common.h"
+#include "efficient.h"
+
+namespace StreamCompaction {
+    namespace Efficient_Shared {
+        using StreamCompaction::Common::PerformanceTimer;
+        PerformanceTimer& timer()
+        {
+            static PerformanceTimer timer;
+            return timer;
+        }
+
+		__global__ void kernScanShared(int n, int *odata, int *sumOfSums)
+		{
+			extern __shared__ int temp[];
+			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+			int offset = 1;
+
+			// load shared memory
+			temp[2 * index] = odata[2 * index];
+			temp[2 * index + 1] = odata[2 * index + 1];
+
+			// upsweep
+			for (int d = n >> 1; d > 0; d >>= 1) {
+				__syncthreads();
+				if (index < d) {
+					int ai = offset * (2 * index + 1) - 1;
+					int bi = offset * (2 * index + 2) - 1;
+
+					temp[bi] += temp[ai];
+				}
+				offset *= 2;
+			}
+
+			if (index == 0) {
+				sumOfSums[blockIdx.x] = temp[n - 1];
+				temp[n - 1] = 0;
+			}
+
+			// downsweep
+			for (int d = 1; d < n; d *= 2) {
+				offset >>= 1;
+				__syncthreads();
+				if (index < d) {
+					int ai = offset * (2 * index + 1) - 1;
+					int bi = offset * (2 * index + 2) - 1;
+
+					int t = temp[ai];
+					temp[ai] = temp[bi];
+					temp[bi] += t;
+				}
+			}
+			
+			__syncthreads();
+
+			odata[2 * index] = temp[2 * index];
+			odata[2 * index + 1] = temp[2 * index + 1];
+		}
+
+		__global__ void kernAddSums(int n, int *odata, int *sumOfSums)
+		{
+			__shared__ int sum;
+			if (threadIdx.x == 0) sum = sumOfSums[blockIdx.x];
+			__syncthreads();
+			
+			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+			if (index >= n) return;
+
+			odata[index] += sum;
+		}
+
+		void scan_implementation(int n, int *dev_out, int *sumOfSums) 
+		{
+			int shMemBytes = sizeof(int) * blockSize;
+			int numBlocks = (n + blockSize - 1) / blockSize;
+
+			kernScanShared << <numBlocks, blockSize, shMemBytes >> > (numBlocks * blockSize, dev_out, sumOfSums);
+			checkCUDAError("kernScanShared 1 failed!");
+			
+			if (n > blockSize) {
+				kernScanShared << <numBlocks, blockSize, shMemBytes >> > (numBlocks, sumOfSums, sumOfSums);
+				checkCUDAError("kernScanShared 2 failed!");
+
+				kernAddSums << <numBlocks, blockSize >> > (pow2n, dev_out, sumOfSums);
+				checkCUDAError("kernAddSums failed!");
+			}
+		}
+
+		/**
+		* Performs prefix-sum (aka scan) on idata, storing the result into odata.
+		*/
+		void scan(int n, int *odata, const int *idata)
+		{
+			int *dev_out;
+			int *sumOfSums;
+			int pow2n = 1 << ilog2ceil(n);
+
+			cudaMalloc((void**)&dev_out, pow2n * sizeof(int));
+			checkCUDAError("cudaMalloc dev_out failed!");
+
+			cudaMalloc((void**)&sumOfSums, pow2n / blockSize * sizeof(int));
+			checkCUDAError("cudaMalloc sumOfSums failed!");
+
+			cudaMemset(dev_out, 0, pow2n * sizeof(int));
+			checkCUDAError("cudaMemset dev_out failed!");
+
+			cudaMemcpy(dev_out, idata, n * sizeof(int), cudaMemcpyHostToDevice);
+			checkCUDAError("cudaMemcpy dev_out failed!");
+
+			timer().startGpuTimer();
+			scan_implementation(pow2n, dev_out, sumOfSums);
+			timer().endGpuTimer();
+			checkCUDAError("scan_implementation failed!");
+
+			cudaMemcpy(odata, dev_out, n * sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+
+			cudaFree(dev_out);
+			cudaFree(sumOfSums);
+		}
+
+        /**
+         * Performs stream compaction on idata, storing the result into odata.
+         * All zeroes are discarded.
+         *
+         * @param n      The number of elements in idata.
+         * @param odata  The array into which to store elements.
+         * @param idata  The array of elements to compact.
+         * @returns      The number of elements remaining after compaction.
+         */
+        int compact(int n, int *odata, const int *idata) 
+		{
+			// TODO
+			int *dbools;
+			int *indices;
+			int *dev_in;
+			int *dev_out;
+			int *sumOfSums;
+
+			int pow2n = 1 << ilog2ceil(n);
+
+			cudaMalloc((void**)&dbools, pow2n * sizeof(int));
+			checkCUDAError("cudaMalloc dbools failed!");
+
+			cudaMalloc((void**)&indices, pow2n * sizeof(int));
+			checkCUDAError("cudaMalloc indices failed!");
+
+			cudaMalloc((void**)&dev_in, n * sizeof(int));
+			checkCUDAError("cudaMalloc dev_in failed!");
+
+			cudaMemcpy(dev_in, idata, n * sizeof(int), cudaMemcpyHostToDevice);
+			checkCUDAError("cudaMemcpy dev_in failed!");
+
+			timer().startGpuTimer();
+
+			dim3 blocksPerGrid1((pow2n + blockSize - 1) / blockSize);
+			StreamCompaction::Common::kernMapToBoolean << <blocksPerGrid1, blockSize >> > (pow2n, n, indices, dev_in);
+			checkCUDAError("kernMapToBoolean failed!");
+
+			cudaMemcpy(dbools, indices, pow2n * sizeof(int), cudaMemcpyDeviceToDevice);
+			checkCUDAError("cudaMemcpyDeviceToDevice failed!");
+
+			int *num = (int *)malloc(sizeof(int));
+			cudaMemcpy(num, dbools + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+
+			int ret = *num;
+
+			cudaMalloc((void**)&sumOfSums, pow2n / blockSize * sizeof(int));
+			checkCUDAError("cudaMalloc sumOfSums failed!");
+		
+			scan_implementation(pow2n, indices, sumOfSums); // requires power of 2
+
+			cudaMemcpy(num, indices + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+			ret += *num;
+			free(num);
+
+			cudaMalloc((void**)&dev_out, ret * sizeof(int));
+			checkCUDAError("cudaMalloc dev_out failed!");
+
+			dim3 blocksPerGrid((n + blockSize - 1) / blockSize);
+			StreamCompaction::Common::kernScatter << <blocksPerGrid, blockSize >> > (n, dev_out, dev_in, dbools, indices);
+			checkCUDAError("kernScatter failed!");
+
+			timer().endGpuTimer();
+
+			cudaMemcpy(odata, dev_out, ret * sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+
+			cudaFree(dbools);
+			cudaFree(dev_in);
+			cudaFree(dev_out);
+			cudaFree(indices);
+			cudaFree(sumOfSums);
+            
+            return ret;
+        }
+    }
+}
diff --git a/stream_compaction/efficient_shared.h b/stream_compaction/efficient_shared.h
new file mode 100644
index 0000000..2a1561c
--- /dev/null
+++ b/stream_compaction/efficient_shared.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "common.h"
+
+namespace StreamCompaction {
+    namespace Efficient_Shared {
+        StreamCompaction::Common::PerformanceTimer& timer();
+
+		void scan_implementation(int n, int *dev_out);
+
+        void scan(int n, int *odata, const int *idata);
+
+        int compact(int n, int *odata, const int *idata);
+    }
+}

From 29a972c4c4db7b250df49689adf9994d4db69f5a Mon Sep 17 00:00:00 2001
From: sarahforcier <sforcier@seas.upenn.edu>
Date: Fri, 29 Sep 2017 18:45:29 -0400
Subject: [PATCH 25/27] shared

---
 stream_compaction/efficient_shared.cu | 28 +++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/stream_compaction/efficient_shared.cu b/stream_compaction/efficient_shared.cu
index f817418..1891ce9 100644
--- a/stream_compaction/efficient_shared.cu
+++ b/stream_compaction/efficient_shared.cu
@@ -16,6 +16,7 @@ namespace StreamCompaction {
 		{
 			extern __shared__ int temp[];
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+			if (index >= n / 2) return;
 			int offset = 1;
 
 			// load shared memory
@@ -71,21 +72,22 @@ namespace StreamCompaction {
 			odata[index] += sum;
 		}
 
-		void scan_implementation(int n, int *dev_out, int *sumOfSums) 
+		/**
+		* invariant: n must be power-of-2
+		*/
+		void scan_implementation(int pow2n, int *dev_out, int *sumOfSums) 
 		{
 			int shMemBytes = sizeof(int) * blockSize;
-			int numBlocks = (n + blockSize - 1) / blockSize;
+			int numBlocks = (pow2n + blockSize - 1) / blockSize;
 
-			kernScanShared << <numBlocks, blockSize, shMemBytes >> > (numBlocks * blockSize, dev_out, sumOfSums);
+			kernScanShared << <numBlocks, blockSize, shMemBytes >> > (pow2n, dev_out, sumOfSums);
 			checkCUDAError("kernScanShared 1 failed!");
-			
-			if (n > blockSize) {
-				kernScanShared << <numBlocks, blockSize, shMemBytes >> > (numBlocks, sumOfSums, sumOfSums);
-				checkCUDAError("kernScanShared 2 failed!");
 
-				kernAddSums << <numBlocks, blockSize >> > (pow2n, dev_out, sumOfSums);
-				checkCUDAError("kernAddSums failed!");
-			}
+			kernScanShared << <numBlocks, blockSize, shMemBytes >> > (pow2n, sumOfSums, sumOfSums);
+			checkCUDAError("kernScanShared 2 failed!");
+
+			kernAddSums << <numBlocks, blockSize >> > (pow2n, dev_out, sumOfSums);
+			checkCUDAError("kernAddSums failed!");
 		}
 
 		/**
@@ -96,11 +98,12 @@ namespace StreamCompaction {
 			int *dev_out;
 			int *sumOfSums;
 			int pow2n = 1 << ilog2ceil(n);
+			int block2n = 1 << ilog2ceil(pow2n / blockSize);
 
 			cudaMalloc((void**)&dev_out, pow2n * sizeof(int));
 			checkCUDAError("cudaMalloc dev_out failed!");
 
-			cudaMalloc((void**)&sumOfSums, pow2n / blockSize * sizeof(int));
+			cudaMalloc((void**)&sumOfSums, block2n * sizeof(int));
 			checkCUDAError("cudaMalloc sumOfSums failed!");
 
 			cudaMemset(dev_out, 0, pow2n * sizeof(int));
@@ -140,6 +143,7 @@ namespace StreamCompaction {
 			int *sumOfSums;
 
 			int pow2n = 1 << ilog2ceil(n);
+			int block2n = 1 << ilog2ceil(pow2n / blockSize);
 
 			cudaMalloc((void**)&dbools, pow2n * sizeof(int));
 			checkCUDAError("cudaMalloc dbools failed!");
@@ -168,7 +172,7 @@ namespace StreamCompaction {
 
 			int ret = *num;
 
-			cudaMalloc((void**)&sumOfSums, pow2n / blockSize * sizeof(int));
+			cudaMalloc((void**)&sumOfSums, block2n * sizeof(int));
 			checkCUDAError("cudaMalloc sumOfSums failed!");
 		
 			scan_implementation(pow2n, indices, sumOfSums); // requires power of 2

From 50282c98ede7631ed1725a1cd79c102514a94ba4 Mon Sep 17 00:00:00 2001
From: Sarah Forcier <sforcier@seas.upenn.edu>
Date: Sat, 30 Sep 2017 12:45:45 -0400
Subject: [PATCH 26/27] shared correct

---
 src/main.cpp                          | 114 +++++++++++++-------------
 stream_compaction/common.h            |   1 +
 stream_compaction/efficient_shared.cu |  48 +++++------
 3 files changed, 83 insertions(+), 80 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index a4123d6..b98bd88 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -14,7 +14,7 @@
 #include <stream_compaction/thrust.h>
 #include <stream_compaction/radix.h>
 #include "testing_helpers.hpp"
-const int SIZE = 1 << 3; // feel free to change the size of array
+const int SIZE = 1 << 14; // feel free to change the size of array
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 //int a[SIZE], b[SIZE], c[SIZE], d[SIZE];
 
@@ -31,7 +31,9 @@ int main(int argc, char* argv[]) {
     printf("** SCAN TESTS **\n");
     printf("****************\n");
 
-    genArray(SIZE - 1, a, 50);  // Leave a 0 at the end to test that edge case
+    //genArray(SIZE - 1, a, 50);  // Leave a 0 at the end to test that edge case
+
+	for (int i = 0; i < SIZE; ++i) a[i] = i;
     //a[SIZE - 1] = 0;
 
     printArray(SIZE, a, true);
@@ -52,40 +54,40 @@ int main(int argc, char* argv[]) {
     printArray(NPOT, b, true);
     printCmpResult(NPOT, b, c);
 
- //   zeroArray(SIZE, c);
- //   printDesc("naive scan, power-of-two");
- //   StreamCompaction::Naive::scan(SIZE, c, a);
- //   printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(SIZE, c, true);
- //   printCmpResult(SIZE, b, c);
+    zeroArray(SIZE, c);
+    printDesc("naive scan, power-of-two");
+    StreamCompaction::Naive::scan(SIZE, c, a);
+    printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(SIZE, c, true);
+    printCmpResult(SIZE, b, c);
 
- //   zeroArray(SIZE, c);
- //   printDesc("naive scan, non-power-of-two");
- //   StreamCompaction::Naive::scan(NPOT, c, a);
- //   printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(NPOT, c, true);
- //   printCmpResult(NPOT, b, c);
+    zeroArray(SIZE, c);
+    printDesc("naive scan, non-power-of-two");
+    StreamCompaction::Naive::scan(NPOT, c, a);
+    printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(NPOT, c, true);
+    printCmpResult(NPOT, b, c);
 
- //   zeroArray(SIZE, c);
- //   printDesc("work-efficient scan, power-of-two");
- //   StreamCompaction::Efficient::scan(SIZE, c, a);
- //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(SIZE, c, true);
- //   printCmpResult(SIZE, b, c);
+    zeroArray(SIZE, c);
+    printDesc("work-efficient scan, power-of-two");
+    StreamCompaction::Efficient::scan(SIZE, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(SIZE, c, true);
+    printCmpResult(SIZE, b, c);
 
- //   zeroArray(SIZE, c);
- //   printDesc("work-efficient scan, non-power-of-two");
- //   StreamCompaction::Efficient::scan(NPOT, c, a);
- //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(NPOT, c, true);
- //   printCmpResult(NPOT, b, c);
+    zeroArray(SIZE, c);
+    printDesc("work-efficient scan, non-power-of-two");
+    StreamCompaction::Efficient::scan(NPOT, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(NPOT, c, true);
+    printCmpResult(NPOT, b, c);
 
-	//zeroArray(SIZE, c);
-	//printDesc("shared scan, power-of-two");
-	//StreamCompaction::Efficient_Shared::scan(SIZE, c, a);
-	//printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-	//printArray(SIZE, c, true);
-	//printCmpResult(SIZE, b, c);
+	zeroArray(SIZE, c);
+	printDesc("shared scan, power-of-two");
+	StreamCompaction::Efficient_Shared::scan(SIZE, c, a);
+	printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+	printArray(SIZE, c, true);
+	printCmpResult(SIZE, b, c);
 
 	zeroArray(SIZE, c);
 	printDesc("shared scan, non-power-of-two");
@@ -94,19 +96,19 @@ int main(int argc, char* argv[]) {
 	printArray(NPOT, c, true);
 	printCmpResult(NPOT, b, c);
 
-    //zeroArray(SIZE, c);
-    //printDesc("thrust scan, power-of-two");
-    //StreamCompaction::Thrust::scan(SIZE, c, a);
-    //printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(SIZE, c, true);
-    //printCmpResult(SIZE, b, c);
+    zeroArray(SIZE, c);
+    printDesc("thrust scan, power-of-two");
+    StreamCompaction::Thrust::scan(SIZE, c, a);
+    printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(SIZE, c, true);
+    printCmpResult(SIZE, b, c);
 
-    //zeroArray(SIZE, c);
-    //printDesc("thrust scan, non-power-of-two");
-    //StreamCompaction::Thrust::scan(NPOT, c, a);
-    //printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(NPOT, c, true);
-    //printCmpResult(NPOT, b, c);
+    zeroArray(SIZE, c);
+    printDesc("thrust scan, non-power-of-two");
+    StreamCompaction::Thrust::scan(NPOT, c, a);
+    printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(NPOT, c, true);
+    printCmpResult(NPOT, b, c);
 
     printf("\n");
     printf("*****************************\n");
@@ -160,19 +162,19 @@ int main(int argc, char* argv[]) {
  //   printArray(expectedNPOT, c, true);
  //   printCmpLenResult(countNPOT, expectedNPOT, b, c);
 
-	zeroArray(SIZE, c);
-	printDesc("shared compact, power-of-two");
-	countSIZE = StreamCompaction::Efficient_Shared::compact(SIZE, c, a);
-	printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-	printArray(expectedSIZE, c, true);
-	printCmpLenResult(countSIZE, expectedSIZE, b, c);
+	//zeroArray(SIZE, c);
+	//printDesc("shared compact, power-of-two");
+	//countSIZE = StreamCompaction::Efficient_Shared::compact(SIZE, c, a);
+	//printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+	//printArray(expectedSIZE, c, true);
+	//printCmpLenResult(countSIZE, expectedSIZE, b, c);
 
-	zeroArray(SIZE, c);
-	printDesc("shared compact, non-power-of-two");
-	countNPOT = StreamCompaction::Efficient_Shared::compact(NPOT, c, a);
-	printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-	printArray(expectedNPOT, c, true);
-	printCmpLenResult(countNPOT, expectedNPOT, b, c);
+	//zeroArray(SIZE, c);
+	//printDesc("shared compact, non-power-of-two");
+	//countNPOT = StreamCompaction::Efficient_Shared::compact(NPOT, c, a);
+	//printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+	//printArray(expectedNPOT, c, true);
+	//printCmpLenResult(countNPOT, expectedNPOT, b, c);
 
  //   printf("\n");
  //   printf("*****************************\n");
diff --git a/stream_compaction/common.h b/stream_compaction/common.h
index b8cc0fe..b848ee1 100644
--- a/stream_compaction/common.h
+++ b/stream_compaction/common.h
@@ -24,6 +24,7 @@ void checkCUDAErrorFn(const char *msg, const char *file = NULL, int line = -1);
 
 inline int ilog2(int x) {
     int lg = 0;
+	x = std::max(0, x);
     while (x >>= 1) {
         ++lg;
     }
diff --git a/stream_compaction/efficient_shared.cu b/stream_compaction/efficient_shared.cu
index 1891ce9..0ecc2ed 100644
--- a/stream_compaction/efficient_shared.cu
+++ b/stream_compaction/efficient_shared.cu
@@ -16,37 +16,37 @@ namespace StreamCompaction {
 		{
 			extern __shared__ int temp[];
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
-			if (index >= n / 2) return;
+			if (index >= n) return;
 			int offset = 1;
 
 			// load shared memory
-			temp[2 * index] = odata[2 * index];
-			temp[2 * index + 1] = odata[2 * index + 1];
+			temp[threadIdx.x] = odata[index];
+			//temp[2 * index + 1] = odata[2 * index + 1];
 
 			// upsweep
-			for (int d = n >> 1; d > 0; d >>= 1) {
+			for (int d = blockSize >> 1; d > 0; d >>= 1) {
 				__syncthreads();
-				if (index < d) {
-					int ai = offset * (2 * index + 1) - 1;
-					int bi = offset * (2 * index + 2) - 1;
+				if (threadIdx.x < d) {
+					int ai = offset * (2 * threadIdx.x + 1) - 1;
+					int bi = offset * (2 * threadIdx.x + 2) - 1;
 
 					temp[bi] += temp[ai];
 				}
 				offset *= 2;
 			}
 
-			if (index == 0) {
-				sumOfSums[blockIdx.x] = temp[n - 1];
-				temp[n - 1] = 0;
+			if (threadIdx.x == 0) {
+				sumOfSums[blockIdx.x] = temp[blockDim.x - 1];
+				temp[blockDim.x - 1] = 0;
 			}
 
 			// downsweep
-			for (int d = 1; d < n; d *= 2) {
+			for (int d = 1; d < blockSize; d *= 2) {
 				offset >>= 1;
 				__syncthreads();
-				if (index < d) {
-					int ai = offset * (2 * index + 1) - 1;
-					int bi = offset * (2 * index + 2) - 1;
+				if (threadIdx.x < d) {
+					int ai = offset * (2 * threadIdx.x + 1) - 1;
+					int bi = offset * (2 * threadIdx.x + 2) - 1;
 
 					int t = temp[ai];
 					temp[ai] = temp[bi];
@@ -56,8 +56,8 @@ namespace StreamCompaction {
 			
 			__syncthreads();
 
-			odata[2 * index] = temp[2 * index];
-			odata[2 * index + 1] = temp[2 * index + 1];
+			odata[index] = temp[threadIdx.x];
+			//odata[2 * index + 1] = temp[2 * index + 1];
 		}
 
 		__global__ void kernAddSums(int n, int *odata, int *sumOfSums)
@@ -75,18 +75,18 @@ namespace StreamCompaction {
 		/**
 		* invariant: n must be power-of-2
 		*/
-		void scan_implementation(int pow2n, int *dev_out, int *sumOfSums) 
+		void scan_implementation(int pow2n, int block2n, int *dev_out, int *sumOfSums) 
 		{
-			int shMemBytes = sizeof(int) * blockSize;
-			int numBlocks = (pow2n + blockSize - 1) / blockSize;
+			int numBlocks1 = (pow2n + blockSize - 1) / blockSize;
+			int numBlocks2 = (block2n + blockSize - 1) / blockSize;
 
-			kernScanShared << <numBlocks, blockSize, shMemBytes >> > (pow2n, dev_out, sumOfSums);
+			kernScanShared << <numBlocks1, blockSize, sizeof(int) * blockSize >> > (pow2n, dev_out, sumOfSums);
 			checkCUDAError("kernScanShared 1 failed!");
 
-			kernScanShared << <numBlocks, blockSize, shMemBytes >> > (pow2n, sumOfSums, sumOfSums);
+			kernScanShared << <numBlocks2, blockSize, sizeof(int) * blockSize >> > (block2n, sumOfSums, sumOfSums);
 			checkCUDAError("kernScanShared 2 failed!");
 
-			kernAddSums << <numBlocks, blockSize >> > (pow2n, dev_out, sumOfSums);
+			kernAddSums << <numBlocks1, blockSize >> > (pow2n, dev_out, sumOfSums);
 			checkCUDAError("kernAddSums failed!");
 		}
 
@@ -113,7 +113,7 @@ namespace StreamCompaction {
 			checkCUDAError("cudaMemcpy dev_out failed!");
 
 			timer().startGpuTimer();
-			scan_implementation(pow2n, dev_out, sumOfSums);
+			scan_implementation(pow2n, block2n, dev_out, sumOfSums);
 			timer().endGpuTimer();
 			checkCUDAError("scan_implementation failed!");
 
@@ -175,7 +175,7 @@ namespace StreamCompaction {
 			cudaMalloc((void**)&sumOfSums, block2n * sizeof(int));
 			checkCUDAError("cudaMalloc sumOfSums failed!");
 		
-			scan_implementation(pow2n, indices, sumOfSums); // requires power of 2
+			scan_implementation(pow2n, block2n, indices, sumOfSums); // requires power of 2
 
 			cudaMemcpy(num, indices + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");

From 2fde8210dd539b31b870cd3a58744604be978a4d Mon Sep 17 00:00:00 2001
From: Sarah Forcier <sforcier@seas.upenn.edu>
Date: Sat, 30 Sep 2017 13:41:04 -0400
Subject: [PATCH 27/27] shared compact

---
 performance.xlsx                      | Bin 40989 -> 40974 bytes
 src/main.cpp                          |  75 ++++++++++++++------------
 stream_compaction/common.cu           |  17 +++---
 stream_compaction/common.h            |   9 ++--
 stream_compaction/efficient.cu        |  42 +++++++--------
 stream_compaction/efficient_shared.cu |  70 ++++++++++++------------
 6 files changed, 106 insertions(+), 107 deletions(-)

diff --git a/performance.xlsx b/performance.xlsx
index 010f062410747db2f722cce30cd3bd00d12157bb..187a6479e340e04ed0b030b320ee76a14d4ab3e7 100644
GIT binary patch
delta 16859
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

delta 16862
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

diff --git a/src/main.cpp b/src/main.cpp
index b98bd88..94fdd03 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -14,7 +14,7 @@
 #include <stream_compaction/thrust.h>
 #include <stream_compaction/radix.h>
 #include "testing_helpers.hpp"
-const int SIZE = 1 << 14; // feel free to change the size of array
+const int SIZE = 1 << 20; // must be <= 20
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 //int a[SIZE], b[SIZE], c[SIZE], d[SIZE];
 
@@ -96,7 +96,14 @@ int main(int argc, char* argv[]) {
 	printArray(NPOT, c, true);
 	printCmpResult(NPOT, b, c);
 
-    zeroArray(SIZE, c);
+	zeroArray(SIZE, c);
+	//printDesc("thrust scan, power-of-two");
+	StreamCompaction::Thrust::scan(SIZE, c, a);
+	//printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+	//printArray(SIZE, c, true);
+	//printCmpResult(SIZE, b, c);
+	
+	zeroArray(SIZE, c);
     printDesc("thrust scan, power-of-two");
     StreamCompaction::Thrust::scan(SIZE, c, a);
     printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
@@ -141,40 +148,40 @@ int main(int argc, char* argv[]) {
     printArray(countNPOT, c, true);
     printCmpLenResult(countNPOT, expectedNPOT, b, c);
 
- //   zeroArray(SIZE, c);
- //   printDesc("cpu compact with scan");
-	//countSIZE = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
- //   printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
- //   printArray(countSIZE, c, true);
- //   printCmpLenResult(countSIZE, expectedSIZE, b, c);
+    zeroArray(SIZE, c);
+    printDesc("cpu compact with scan");
+	countSIZE = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
+    printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+    printArray(countSIZE, c, true);
+    printCmpLenResult(countSIZE, expectedSIZE, b, c);
 
- //   zeroArray(SIZE, c);
- //   printDesc("work-efficient compact, power-of-two");
-	//countSIZE = StreamCompaction::Efficient::compact(SIZE, c, a);
- //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(expectedSIZE, c, true);
- //   printCmpLenResult(countSIZE, expectedSIZE, b, c);
+    zeroArray(SIZE, c);
+    printDesc("work-efficient compact, power-of-two");
+	countSIZE = StreamCompaction::Efficient::compact(SIZE, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(expectedSIZE, c, true);
+    printCmpLenResult(countSIZE, expectedSIZE, b, c);
 
- //   zeroArray(SIZE, c);
- //   printDesc("work-efficient compact, non-power-of-two");
-	//countNPOT = StreamCompaction::Efficient::compact(NPOT, c, a);
- //   printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
- //   printArray(expectedNPOT, c, true);
- //   printCmpLenResult(countNPOT, expectedNPOT, b, c);
-
-	//zeroArray(SIZE, c);
-	//printDesc("shared compact, power-of-two");
-	//countSIZE = StreamCompaction::Efficient_Shared::compact(SIZE, c, a);
-	//printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-	//printArray(expectedSIZE, c, true);
-	//printCmpLenResult(countSIZE, expectedSIZE, b, c);
-
-	//zeroArray(SIZE, c);
-	//printDesc("shared compact, non-power-of-two");
-	//countNPOT = StreamCompaction::Efficient_Shared::compact(NPOT, c, a);
-	//printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-	//printArray(expectedNPOT, c, true);
-	//printCmpLenResult(countNPOT, expectedNPOT, b, c);
+    zeroArray(SIZE, c);
+    printDesc("work-efficient compact, non-power-of-two");
+	countNPOT = StreamCompaction::Efficient::compact(NPOT, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(expectedNPOT, c, true);
+    printCmpLenResult(countNPOT, expectedNPOT, b, c);
+
+	zeroArray(SIZE, c);
+	printDesc("shared compact, power-of-two");
+	countSIZE = StreamCompaction::Efficient_Shared::compact(SIZE, c, a);
+	printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+	printArray(expectedSIZE, c, true);
+	printCmpLenResult(countSIZE, expectedSIZE, b, c);
+
+	zeroArray(SIZE, c);
+	printDesc("shared compact, non-power-of-two");
+	countNPOT = StreamCompaction::Efficient_Shared::compact(NPOT, c, a);
+	printElapsedTime(StreamCompaction::Efficient_Shared::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+	printArray(expectedNPOT, c, true);
+	printCmpLenResult(countNPOT, expectedNPOT, b, c);
 
  //   printf("\n");
  //   printf("*****************************\n");
diff --git a/stream_compaction/common.cu b/stream_compaction/common.cu
index 22be71c..f85eec5 100644
--- a/stream_compaction/common.cu
+++ b/stream_compaction/common.cu
@@ -22,27 +22,24 @@ namespace StreamCompaction {
          * Maps an array to an array of 0s and 1s for stream compaction. Elements
          * which map to 0 will be removed, and elements which map to 1 will be kept.
          */
-        __global__ void kernMapToBoolean(int pos2n, int n, int *bools, const int *idata) {
+        __global__ void kernMapToBoolean(int n, int *bools, const int *idata) {
             // TODO
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
-			if (index >= pos2n) return;
+			if (index >= n || idata[index] == 0) return;
 
-			bools[index] = (index < n && idata[index] != 0) ? 1 : 0;
+			bools[index] = 1;
         }
 
         /**
          * Performs scatter on an array. That is, for each element in idata,
          * if bools[idx] == 1, it copies idata[idx] to odata[indices[idx]].
          */
-        __global__ void kernScatter(int n, int *odata,
-			const int *idata, const int *bools, const int *indices) {
+        __global__ void kernScatter(int n, int *odata, const int *idata, const int *indices) {
             // TODO
 			int index = (blockIdx.x * blockDim.x) + threadIdx.x;
- 			if (index >= n) return;
- 
- 			if (bools[index] == 1) {
- 				odata[indices[index]] = idata[index];
- 			}
+ 			if (index >= n || idata[index] == 0) return;
+
+ 			odata[indices[index]] = idata[index];
         }
     }
 }
\ No newline at end of file
diff --git a/stream_compaction/common.h b/stream_compaction/common.h
index b848ee1..158245d 100644
--- a/stream_compaction/common.h
+++ b/stream_compaction/common.h
@@ -12,10 +12,11 @@
 
 #define FILENAME (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
 #define checkCUDAError(msg) checkCUDAErrorFn(msg, FILENAME, __LINE__)
-#define blockSize 128
+#define blockSize 1024
 #define bankSize 16
 #define log_bankSize 4
-#define conflictFreeOffset(n) ((n) >> bankSize + (n) >> (2 * log_bankSize))
+//#define conflictFreeOffset(n) ((n) >> bankSize + (n) >> (2 * log_bankSize))
+#define conflictFreeOffset(n) 0
 
 /**
  * Check for CUDA errors; print and exit if there was a problem.
@@ -37,10 +38,10 @@ inline int ilog2ceil(int x) {
 
 namespace StreamCompaction {
     namespace Common {
-		__global__ void kernMapToBoolean(int pos2, int n, int *bools, const int *idata);
+		__global__ void kernMapToBoolean(int n, int *bools, const int *idata);
 
         __global__ void kernScatter(int n, int *odata,
-			const int *idata, const int *bools, const int *indices);
+			const int *idata, const int *indices);
 
 	    /**
 	    * This class is used for timing the performance
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index 4698a07..80d8e47 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -105,17 +105,17 @@ namespace StreamCompaction {
 		{
 			// TODO
 			int *dbools;
-			int *indices;
 			int *dev_in;
 			int *dev_out;
 
 			int pow2n = 1 << ilog2ceil(n);
+			int block2n = 1 << ilog2ceil(pow2n / blockSize);
 
 			cudaMalloc((void**)&dbools, pow2n * sizeof(int));
 			checkCUDAError("cudaMalloc dbools failed!");
 
-			cudaMalloc((void**)&indices, pow2n * sizeof(int));
-			checkCUDAError("cudaMalloc indices failed!");
+			cudaMemset(dbools, 0, pow2n * sizeof(int));
+			checkCUDAError("cudaMemset dbools failed!");
 
 			cudaMalloc((void**)&dev_in, n * sizeof(int));
 			checkCUDAError("cudaMalloc dev_in failed!");
@@ -123,33 +123,28 @@ namespace StreamCompaction {
 			cudaMemcpy(dev_in, idata, n * sizeof(int), cudaMemcpyHostToDevice);
 			checkCUDAError("cudaMemcpy dev_in failed!");
 
+			cudaMalloc((void**)&dev_out, n * sizeof(int));
+			checkCUDAError("cudaMalloc dev_out failed!");
+
 			timer().startGpuTimer();
 
-			dim3 blocksPerGrid1((pow2n + blockSize - 1) / blockSize);
-			StreamCompaction::Common::kernMapToBoolean << <blocksPerGrid1, blockSize >> > (pow2n, n, indices, dev_in);
+			dim3 blocksPerGrid((n + blockSize - 1) / blockSize);
+			StreamCompaction::Common::kernMapToBoolean << <blocksPerGrid, blockSize >> > (n, dbools, dev_in);
 			checkCUDAError("kernMapToBoolean failed!");
 
-			cudaMemcpy(dbools, indices, pow2n * sizeof(int), cudaMemcpyDeviceToDevice);
-			checkCUDAError("cudaMemcpyDeviceToDevice failed!");
-
-			int *num = (int *)malloc(sizeof(int));
-			cudaMemcpy(num, dbools + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
+			int num;
+			cudaMemcpyAsync(&num, dbools + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");
 
-			int ret = *num;
-		
-			scan_implementation(pow2n, indices); // requires power of 2
+			int ret = num;
 
-			cudaMemcpy(num, indices + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
-			checkCUDAError("cudaMemcpyDeviceToHost failed!");
-			ret += *num;
-			free(num);
+			scan_implementation(pow2n, dbools); // requires power of 2
 
-			cudaMalloc((void**)&dev_out, ret * sizeof(int));
-			checkCUDAError("cudaMalloc dev_out failed!");
+			cudaMemcpyAsync(&num, dbools + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
+			checkCUDAError("cudaMemcpyDeviceToHost failed!");
+			ret += num;
 
-			dim3 blocksPerGrid((n + blockSize - 1) / blockSize);
-			StreamCompaction::Common::kernScatter << <blocksPerGrid, blockSize >> > (n, dev_out, dev_in, dbools, indices);
+			StreamCompaction::Common::kernScatter << <blocksPerGrid, blockSize >> > (n, dev_out, dev_in, dbools);
 			checkCUDAError("kernScatter failed!");
 
 			timer().endGpuTimer();
@@ -160,9 +155,8 @@ namespace StreamCompaction {
 			cudaFree(dbools);
 			cudaFree(dev_in);
 			cudaFree(dev_out);
-			cudaFree(indices);
-            
-            return ret;
+
+			return ret;
         }
     }
 }
diff --git a/stream_compaction/efficient_shared.cu b/stream_compaction/efficient_shared.cu
index 0ecc2ed..b773f7b 100644
--- a/stream_compaction/efficient_shared.cu
+++ b/stream_compaction/efficient_shared.cu
@@ -20,33 +20,40 @@ namespace StreamCompaction {
 			int offset = 1;
 
 			// load shared memory
-			temp[threadIdx.x] = odata[index];
+			int idx = threadIdx.x;
+			//int bankOffset = conflictFreeOffset(idx);
+			int bankOffset = 0;
+			temp[idx + bankOffset] = odata[index];
 			//temp[2 * index + 1] = odata[2 * index + 1];
 
 			// upsweep
 			for (int d = blockSize >> 1; d > 0; d >>= 1) {
 				__syncthreads();
-				if (threadIdx.x < d) {
-					int ai = offset * (2 * threadIdx.x + 1) - 1;
-					int bi = offset * (2 * threadIdx.x + 2) - 1;
+				if (idx < d) {
+					int ai = offset * (2 * idx + 1) - 1;
+					int bi = offset * (2 * idx + 2) - 1;
+					ai += conflictFreeOffset(ai);
+					bi += conflictFreeOffset(bi);
 
 					temp[bi] += temp[ai];
 				}
 				offset *= 2;
 			}
 
-			if (threadIdx.x == 0) {
-				sumOfSums[blockIdx.x] = temp[blockDim.x - 1];
-				temp[blockDim.x - 1] = 0;
+			if (idx == 0) {
+				sumOfSums[blockIdx.x] = temp[blockDim.x - 1 + conflictFreeOffset(blockDim.x - 1)];
+				temp[blockDim.x - 1 + conflictFreeOffset(blockDim.x - 1)] = 0;
 			}
 
 			// downsweep
 			for (int d = 1; d < blockSize; d *= 2) {
 				offset >>= 1;
 				__syncthreads();
-				if (threadIdx.x < d) {
-					int ai = offset * (2 * threadIdx.x + 1) - 1;
-					int bi = offset * (2 * threadIdx.x + 2) - 1;
+				if (idx < d) {
+					int ai = offset * (2 * idx + 1) - 1;
+					int bi = offset * (2 * idx + 2) - 1;
+					ai += conflictFreeOffset(ai);
+					bi += conflictFreeOffset(bi);
 
 					int t = temp[ai];
 					temp[ai] = temp[bi];
@@ -56,7 +63,7 @@ namespace StreamCompaction {
 			
 			__syncthreads();
 
-			odata[index] = temp[threadIdx.x];
+			odata[index] = temp[idx + bankOffset];
 			//odata[2 * index + 1] = temp[2 * index + 1];
 		}
 
@@ -137,7 +144,6 @@ namespace StreamCompaction {
 		{
 			// TODO
 			int *dbools;
-			int *indices;
 			int *dev_in;
 			int *dev_out;
 			int *sumOfSums;
@@ -148,8 +154,8 @@ namespace StreamCompaction {
 			cudaMalloc((void**)&dbools, pow2n * sizeof(int));
 			checkCUDAError("cudaMalloc dbools failed!");
 
-			cudaMalloc((void**)&indices, pow2n * sizeof(int));
-			checkCUDAError("cudaMalloc indices failed!");
+			cudaMemset(dbools, 0, pow2n * sizeof(int));
+			checkCUDAError("cudaMemset dbools failed!");
 
 			cudaMalloc((void**)&dev_in, n * sizeof(int));
 			checkCUDAError("cudaMalloc dev_in failed!");
@@ -157,36 +163,31 @@ namespace StreamCompaction {
 			cudaMemcpy(dev_in, idata, n * sizeof(int), cudaMemcpyHostToDevice);
 			checkCUDAError("cudaMemcpy dev_in failed!");
 
+			cudaMalloc((void**)&sumOfSums, block2n * sizeof(int));
+			checkCUDAError("cudaMalloc sumOfSums failed!");
+
+			cudaMalloc((void**)&dev_out, n * sizeof(int));
+			checkCUDAError("cudaMalloc dev_out failed!");
+
 			timer().startGpuTimer();
 
-			dim3 blocksPerGrid1((pow2n + blockSize - 1) / blockSize);
-			StreamCompaction::Common::kernMapToBoolean << <blocksPerGrid1, blockSize >> > (pow2n, n, indices, dev_in);
+			dim3 blocksPerGrid((n + blockSize - 1) / blockSize);
+			StreamCompaction::Common::kernMapToBoolean << <blocksPerGrid, blockSize >> > (n, dbools, dev_in);
 			checkCUDAError("kernMapToBoolean failed!");
 
-			cudaMemcpy(dbools, indices, pow2n * sizeof(int), cudaMemcpyDeviceToDevice);
-			checkCUDAError("cudaMemcpyDeviceToDevice failed!");
-
-			int *num = (int *)malloc(sizeof(int));
-			cudaMemcpy(num, dbools + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
+			int num;
+			cudaMemcpyAsync(&num, dbools + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");
 
-			int ret = *num;
+			int ret = num;
 
-			cudaMalloc((void**)&sumOfSums, block2n * sizeof(int));
-			checkCUDAError("cudaMalloc sumOfSums failed!");
-		
-			scan_implementation(pow2n, block2n, indices, sumOfSums); // requires power of 2
+			scan_implementation(pow2n, block2n, dbools, sumOfSums); // requires power of 2
 
-			cudaMemcpy(num, indices + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
+			cudaMemcpyAsync(&num, dbools + n - 1, sizeof(int), cudaMemcpyDeviceToHost);
 			checkCUDAError("cudaMemcpyDeviceToHost failed!");
-			ret += *num;
-			free(num);
+			ret += num;
 
-			cudaMalloc((void**)&dev_out, ret * sizeof(int));
-			checkCUDAError("cudaMalloc dev_out failed!");
-
-			dim3 blocksPerGrid((n + blockSize - 1) / blockSize);
-			StreamCompaction::Common::kernScatter << <blocksPerGrid, blockSize >> > (n, dev_out, dev_in, dbools, indices);
+			StreamCompaction::Common::kernScatter << <blocksPerGrid, blockSize >> > (n, dev_out, dev_in, dbools);
 			checkCUDAError("kernScatter failed!");
 
 			timer().endGpuTimer();
@@ -197,7 +198,6 @@ namespace StreamCompaction {
 			cudaFree(dbools);
 			cudaFree(dev_in);
 			cudaFree(dev_out);
-			cudaFree(indices);
 			cudaFree(sumOfSums);
             
             return ret;