From d846aa980063a78aa099969892215b052f68f099 Mon Sep 17 00:00:00 2001 From: HanmingZhang Date: Sun, 17 Sep 2017 18:18:19 -0400 Subject: [PATCH 1/8] base part finish --- src/main.cpp | 16 +++ stream_compaction/CMakeLists.txt | 2 + stream_compaction/common.cu | 14 +++ stream_compaction/common.h | 202 ++++++++++++++++--------------- stream_compaction/cpu.cu | 89 ++++++++++++-- stream_compaction/cpu.h | 4 + stream_compaction/efficient.cu | 194 ++++++++++++++++++++++++++++- stream_compaction/naive.cu | 77 +++++++++++- stream_compaction/thrust.cu | 22 +++- 9 files changed, 508 insertions(+), 112 deletions(-) diff --git a/src/main.cpp b/src/main.cpp index 7305641..d29232d 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -139,5 +139,21 @@ int main(int argc, char* argv[]) { //printArray(count, c, true); printCmpLenResult(count, expectedNPOT, b, c); + + printf("\n"); + printf("*****************************\n"); + printf("** Radix Sort TEST **\n"); + printf("*****************************\n"); + genArray(15, a, 16); + printf("Randomly Generate Array with maxmium 16.\n"); + printArray(15, a, true); + + zeroArray(15, b); + StreamCompaction::CPU::quickSort(15, b, a); + printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)"); + printf("qosrt Result : \n"); + printArray(15, b, true); + + system("pause"); // stop Win32 console from closing on exit } diff --git a/stream_compaction/CMakeLists.txt b/stream_compaction/CMakeLists.txt index cdbef77..9ea1176 100644 --- a/stream_compaction/CMakeLists.txt +++ b/stream_compaction/CMakeLists.txt @@ -9,6 +9,8 @@ set(SOURCE_FILES "efficient.cu" "thrust.h" "thrust.cu" + "RadixSort.h" + "RadixSort.cu" ) cuda_add_library(stream_compaction diff --git a/stream_compaction/common.cu b/stream_compaction/common.cu index 8fc0211..b469ee8 100644 --- a/stream_compaction/common.cu +++ b/stream_compaction/common.cu @@ -24,6 +24,12 @@ namespace StreamCompaction { */ __global__ void kernMapToBoolean(int n, int *bools, const int *idata) { // TODO + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if(index >= n) { + return; + } + + bools[index] = idata[index] ? 1 : 0; } /** @@ -33,6 +39,14 @@ namespace StreamCompaction { __global__ void kernScatter(int n, int *odata, const int *idata, const int *bools, const int *indices) { // TODO + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if (index >= n) { + return; + } + + if (bools[index]) { + odata[indices[index]] = idata[index]; + } } } diff --git a/stream_compaction/common.h b/stream_compaction/common.h index 55f1b38..b8f71cd 100644 --- a/stream_compaction/common.h +++ b/stream_compaction/common.h @@ -1,18 +1,24 @@ #pragma once -#include -#include - -#include -#include -#include -#include +#include +#include + +#include +#include +#include +#include #include -#include +#include + + +#include + #define FILENAME (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__) #define checkCUDAError(msg) checkCUDAErrorFn(msg, FILENAME, __LINE__) +#define blockSize 64 + /** * Check for CUDA errors; print and exit if there was a problem. */ @@ -37,96 +43,96 @@ namespace StreamCompaction { __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 duro = time_end_cpu - time_start_cpu; - prev_elapsed_time_cpu_milliseconds = - static_cast(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; + /** + * 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 duro = time_end_cpu - time_start_cpu; + prev_elapsed_time_cpu_milliseconds = + static_cast(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 05ce667..f05ecb0 100644 --- a/stream_compaction/cpu.cu +++ b/stream_compaction/cpu.cu @@ -1,15 +1,15 @@ #include #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; } /** @@ -17,9 +17,21 @@ namespace StreamCompaction { * 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 scanImplementation(int n, int *odata, const int *idata) { + // an EXCLUSIVE scan + odata[0] = 0; + for (int k = 1; k < n; k++) { + odata[k] = odata[k - 1] + idata[k - 1]; + } + } + + void scan(int n, int *odata, const int *idata) { timer().startCpuTimer(); - // TODO + // TODO + scanImplementation(n, odata, idata); + timer().endCpuTimer(); } @@ -29,10 +41,19 @@ namespace StreamCompaction { * @returns the number of elements remaining after compaction. */ int compactWithoutScan(int n, int *odata, const int *idata) { - timer().startCpuTimer(); + int count = 0; + + timer().startCpuTimer(); // TODO + + for (int k = 0; k < n; k++) { + if (idata[k] != 0) { + odata[count++] = idata[k]; + } + } + timer().endCpuTimer(); - return -1; + return count; } /** @@ -41,10 +62,56 @@ namespace StreamCompaction { * @returns the number of elements remaining after compaction. */ int compactWithScan(int n, int *odata, const int *idata) { - timer().startCpuTimer(); + + int* tempArray = new int[n]; + int* scanResult = new int[n]; + int count = 0; + + timer().startCpuTimer(); // TODO + + // Step 1 : compute temp array + for (int k = 0; k < n; k++) { + tempArray[k] = idata[k] ? 1 : 0; + } + + // Step 2 : run exclusive on temp array + scanImplementation(n, scanResult, tempArray); + + // Step 3 : scatter + count = tempArray[n - 1] ? (scanResult[n - 1] + 1) : scanResult[n - 1]; + + for (int k = 0; k < n; k++) { + if (tempArray[k]) { + odata[scanResult[k]] = idata[k]; + } + } + timer().endCpuTimer(); - return -1; + + delete[] tempArray; + delete[] scanResult; + + return count; + } + + int compare(const void * a, const void * b) + { + return (*(int*)a - *(int*)b); + } + + void quickSort(int n, int *odata, const int *idata){ + + for (int k = 0; k < n; k++) { + odata[k] = idata[k]; + } + + timer().startCpuTimer(); + + qsort(odata, n, sizeof(int), compare); + + timer().endCpuTimer(); + } } } diff --git a/stream_compaction/cpu.h b/stream_compaction/cpu.h index 236ce11..4123241 100644 --- a/stream_compaction/cpu.h +++ b/stream_compaction/cpu.h @@ -6,10 +6,14 @@ namespace StreamCompaction { namespace CPU { StreamCompaction::Common::PerformanceTimer& timer(); + void scanImplementation(int n, int *odata, const int *idata); + void scan(int n, int *odata, const int *idata); int compactWithoutScan(int n, int *odata, const int *idata); int compactWithScan(int n, int *odata, const int *idata); + + void quickSort(int n, int *odata, const int *idata); } } diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu index 36c5ef2..c12d8ad 100644 --- a/stream_compaction/efficient.cu +++ b/stream_compaction/efficient.cu @@ -12,13 +12,113 @@ namespace StreamCompaction { return timer; } + __global__ void kernSetZero(int N, int* dev_data) { + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if (index >= N) { + return; + } + + dev_data[index] = 0; + } + + __global__ void kernEffcientUpSweep(int N, int offset, int* dev_data) { + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if (index >= N) { + return; + } + + //if ((index + 1) % offset == 0) { + // dev_data[index] += dev_data[index - offset / 2]; + //} + + int targetIndex = (index + 1) * offset - 1; + dev_data[targetIndex] += dev_data[targetIndex - offset / 2]; + } + + __global__ void kernSetRootZero(int N, int* dev_data) { + dev_data[N - 1] = 0; + } + + __global__ void kernEfficientDownSweep(int N, int offset, int* dev_data) { + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if (index >= N) { + return; + } + + //if ((index + 1) % offset == 0) { + // int t = dev_data[index - offset / 2]; + // dev_data[index - offset / 2] = dev_data[index]; + // dev_data[index] += t; + //} + + int targetIndex = (index + 1) * offset - 1; + + int t = dev_data[targetIndex - offset / 2]; + dev_data[targetIndex - offset / 2] = dev_data[targetIndex]; + dev_data[targetIndex] += t; + } + + __global__ void kernSetCompactCount(int N, int* dev_count, int* bools, int* indices) { + dev_count[0] = bools[N - 1] ? (indices[N - 1] + 1) : indices[N - 1]; + } + /** * Performs prefix-sum (aka scan) on idata, storing the result into odata. */ void scan(int n, int *odata, const int *idata) { + + int dMax = ilog2ceil(n); + int size = (int)powf(2.0f, (float)dMax); + + int* dev_data; + + cudaMalloc((void**)&dev_data, size * sizeof(int)); + checkCUDAError("cudaMalloc dev_data failed!"); + cudaDeviceSynchronize(); + + dim3 blockDim(blockSize); + dim3 gridDim((size + blockSize - 1) / blockSize); + + kernSetZero << < gridDim, blockDim >> > (size, dev_data); + checkCUDAError("kernSetZero failed!"); + + cudaMemcpy(dev_data, idata, sizeof(int) * n, cudaMemcpyHostToDevice); + checkCUDAError("efficient cudaMemcpy failed!"); + + timer().startGpuTimer(); // TODO + + // Step 1 : Up-sweep + for (int d = 0; d <= dMax - 1; d++) { + //kernEffcientUpSweep << > > (size, (int)powf(2.0f, (float)d + 1.0f), dev_data); + + //only launch threads that acutally work + int temp_size = (int)powf(2.0f, (float)(dMax - d - 1)); + kernEffcientUpSweep << > > (temp_size, (int)powf(2.0f, (float)d + 1.0f), dev_data); + + } + checkCUDAError("kernEffcientUpSweep failed!"); + + // Step 2 : Down-sweep + kernSetRootZero << < dim3(1), dim3(1) >> > (size, dev_data); + checkCUDAError("kernSetRootZero failed!"); + + for (int d = dMax - 1; d >= 0; d--) { + //kernEfficientDownSweep << > > (size, (int)powf(2.0f, (float)d + 1.0f), dev_data); + + //only launch threads that acutally work + int temp_size = (int)powf(2.0f, (float)(dMax - d - 1)); + kernEfficientDownSweep << > > (temp_size, (int)powf(2.0f, (float)d + 1.0f), dev_data); + } + checkCUDAError("kernEfficientDownSweep failed!"); + timer().endGpuTimer(); + + cudaMemcpy(odata, dev_data, sizeof(int) * n, cudaMemcpyDeviceToHost); + checkCUDAError("efficient cudaMemcpy failed!"); + + cudaFree(dev_data); } /** @@ -31,10 +131,102 @@ namespace StreamCompaction { * @returns The number of elements remaining after compaction. */ int compact(int n, int *odata, const int *idata) { + // compact Set-up + int* dev_idata; + int* dev_odata; + int* bools; + int* indices; + int* dev_count; + int count; + + dim3 blockDim(blockSize); + dim3 gridDim((n + blockSize - 1) / blockSize); + + cudaMalloc((void**)&dev_idata, n * sizeof(int)); + checkCUDAError("cudaMalloc dev_idata failed!"); + cudaMalloc((void**)&dev_odata, n * sizeof(int)); + checkCUDAError("cudaMalloc dev_odata failed!"); + cudaMalloc((void**)&bools, n * sizeof(int)); + checkCUDAError("cudaMalloc bools failed!"); + cudaMalloc((void**)&dev_count, sizeof(int)); + checkCUDAError("cudaMalloc dev_count failed!"); + cudaDeviceSynchronize(); + + cudaMemcpy(dev_idata, idata, sizeof(int) * n, cudaMemcpyHostToDevice); + checkCUDAError("efficient compact cudaMemcpy failed!"); + + + + // scan Set-up + int dMax = ilog2ceil(n); + int size = (int)powf(2.0f, (float)dMax); + + dim3 scan_gridDim((size + blockSize - 1) / blockSize); + + cudaMalloc((void**)&indices, size * sizeof(int)); + checkCUDAError("cudaMalloc indices failed!"); + cudaDeviceSynchronize(); + + kernSetZero << < scan_gridDim, blockDim >> > (size, indices); + checkCUDAError("kernSetZero failed!"); + + timer().startGpuTimer(); // TODO + // Step 1 : compute bools array + StreamCompaction::Common::kernMapToBoolean << > > (n, bools, dev_idata); + checkCUDAError("kernMapToBoolean failed!"); + + cudaMemcpy(indices, bools, sizeof(int) * n, cudaMemcpyDeviceToDevice); + checkCUDAError("cudaMemcpy failed!"); + + // Step 2 : exclusive scan indices + // Up-sweep + for (int d = 0; d <= dMax - 1; d++) { + //kernEffcientUpSweep << > > (size, (int)powf(2.0f, (float)d + 1.0f), indices); + + //only launch threads that acutally work + int temp_size = (int)powf(2.0f, (float)(dMax - d - 1)); + kernEffcientUpSweep << > > (temp_size, (int)powf(2.0f, (float)d + 1.0f), indices); + } + checkCUDAError("kernEffcientUpSweep failed!"); + + // Down-sweep + kernSetRootZero << < dim3(1), dim3(1) >> > (size, indices); + checkCUDAError("kernSetRootZero failed!"); + + for (int d = dMax - 1; d >= 0; d--) { + //kernEfficientDownSweep << > > (size, (int)powf(2.0f, (float)d + 1.0f), indices); + + //only launch threads that acutally work + int temp_size = (int)powf(2.0f, (float)(dMax - d - 1)); + kernEfficientDownSweep << > > (temp_size, (int)powf(2.0f, (float)d + 1.0f), indices); + } + checkCUDAError("kernEfficientDownSweep failed!"); + + // Step 3 : Scatter + StreamCompaction::Common::kernScatter << > > (n, dev_odata, dev_idata, bools, indices); + checkCUDAError("kernScatter failed!"); + + kernSetCompactCount << > > (n, dev_count, bools, indices); + checkCUDAError("kernSetCompactCount failed!"); + timer().endGpuTimer(); - return -1; + + + cudaMemcpy(&count, dev_count, sizeof(int), cudaMemcpyDeviceToHost); + checkCUDAError("cudaMemcpy failed!"); + + cudaMemcpy(odata, dev_odata, sizeof(int) * count, cudaMemcpyDeviceToHost); + checkCUDAError("cudaMemcpy failed!"); + + cudaFree(dev_idata); + cudaFree(dev_odata); + cudaFree(bools); + cudaFree(dev_count); + cudaFree(indices); + + return count; } } } diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu index 9218f8e..853ec4c 100644 --- a/stream_compaction/naive.cu +++ b/stream_compaction/naive.cu @@ -3,6 +3,8 @@ #include "common.h" #include "naive.h" +#define identity 0 + namespace StreamCompaction { namespace Naive { using StreamCompaction::Common::PerformanceTimer; @@ -12,14 +14,87 @@ namespace StreamCompaction { return timer; } // TODO: __global__ + __global__ void kernGenExclusiveScanFromInclusiveScan(int N, int* dev_odata, int* dev_idata) { + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if (index >= N) { + return; + } + + // shift right + if (index == 0) { + dev_odata[index] = identity; + } + else { + dev_odata[index] = dev_idata[index - 1]; + } + } + + __global__ void kernNaiveParallelScan(int N, int d, int* dev_odata, int* dev_idata) { + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if (index >= N) { + return; + } + + int offset = (int)(powf(2.0f, (float)d - 1.0f)); + + if (index >= offset) { + dev_odata[index] = dev_idata[index - offset] + dev_idata[index]; + } + else { + dev_odata[index] = dev_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(); + + int* dev_idata; + int* dev_odata; + int* temp; + + cudaMalloc((void**)&dev_idata, n * sizeof(int)); + checkCUDAError("cudaMalloc dev_idata failed!"); + cudaMalloc((void**)&dev_odata, n * sizeof(int)); + checkCUDAError("cudaMalloc dev_odata failed!"); + cudaDeviceSynchronize(); + + cudaMemcpy(dev_idata, idata, sizeof(int) * n, cudaMemcpyHostToDevice); + cudaMemcpy(dev_odata, odata, sizeof(int) * n, cudaMemcpyHostToDevice); + checkCUDAError("naive cudaMemcpy failed!"); + + dim3 blockDim(blockSize); + dim3 gridDim((n + blockSize- 1) / blockSize); + int dMax = ilog2ceil(n); + + timer().startGpuTimer(); + // TODO + for (int d = 1; d <= dMax; d++) { + // call cuda here + // PAY ATTENTION : this is an inclusive scan + kernNaiveParallelScan << > > (n, d, dev_odata, dev_idata); + checkCUDAError("kernNaiveParallelScan failed!"); + + // swap input & output buffer + temp = dev_idata; + dev_idata = dev_odata; + dev_odata = temp; + } + // generate exclusive result from inclusive + kernGenExclusiveScanFromInclusiveScan << > > (n, dev_odata, dev_idata); + checkCUDAError("kernGenExclusiveScanFromInclusiveScan failed!"); + timer().endGpuTimer(); + + // copy from dev_odata to host odata + cudaMemcpy(odata, dev_odata, sizeof(int) * n, cudaMemcpyDeviceToHost); + checkCUDAError("naive cudaMemcpy failed!"); + + cudaFree(dev_idata); + cudaFree(dev_odata); } } } diff --git a/stream_compaction/thrust.cu b/stream_compaction/thrust.cu index 36b732d..270a525 100644 --- a/stream_compaction/thrust.cu +++ b/stream_compaction/thrust.cu @@ -14,15 +14,35 @@ namespace StreamCompaction { 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) { + + + thrust::host_vector host_idata(idata, idata + n); + //thrust::device_vector dev_idata(n); + thrust::device_vector dev_idata(host_idata); + thrust::device_vector dev_odata(n); + + //thrust::copy(host_idata.begin(), host_idata.end(), dev_idata.begin());//copy to device + + cudaDeviceSynchronize(); + 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_idata.begin(), dev_idata.end(), dev_odata.begin()); + timer().endGpuTimer(); - } + + cudaMemcpy(odata, thrust::raw_pointer_cast(&dev_odata[0]), sizeof(int) * n, cudaMemcpyDeviceToHost); + + + } } } From a51e06da4d7acf48a59e3009410e38d6ef1640cd Mon Sep 17 00:00:00 2001 From: HanmingZhang Date: Sun, 17 Sep 2017 18:26:24 -0400 Subject: [PATCH 2/8] before EC start --- stream_compaction/RadixSort.cu | 17 +++++++++++++++++ stream_compaction/RadixSort.h | 9 +++++++++ 2 files changed, 26 insertions(+) create mode 100644 stream_compaction/RadixSort.cu create mode 100644 stream_compaction/RadixSort.h diff --git a/stream_compaction/RadixSort.cu b/stream_compaction/RadixSort.cu new file mode 100644 index 0000000..51853d3 --- /dev/null +++ b/stream_compaction/RadixSort.cu @@ -0,0 +1,17 @@ +#include +#include +#include "common.h" +#include "RadixSort.h" + +namespace RadixSort { + using StreamCompaction::Common::PerformanceTimer; + PerformanceTimer& timer() + { + static PerformanceTimer timer; + return timer; + } + + void sort(int n, int numOfBits, int *odata, const int *idata) { + + } +} \ No newline at end of file diff --git a/stream_compaction/RadixSort.h b/stream_compaction/RadixSort.h new file mode 100644 index 0000000..d7664d1 --- /dev/null +++ b/stream_compaction/RadixSort.h @@ -0,0 +1,9 @@ +#pragma once + +#include "common.h" + +namespace RadixSort { + StreamCompaction::Common::PerformanceTimer& timer(); + + void sort(int n, int numOfBits, int *odata, const int *idata); +} \ No newline at end of file From 350c27652f89f07c53374266b29a6050f28fca71 Mon Sep 17 00:00:00 2001 From: HanmingZhang Date: Sun, 17 Sep 2017 21:35:25 -0400 Subject: [PATCH 3/8] RadixSort Finished --- src/main.cpp | 28 ++++++++--- stream_compaction/RadixSort.cu | 92 ++++++++++++++++++++++++++++++++++ 2 files changed, 114 insertions(+), 6 deletions(-) diff --git a/src/main.cpp b/src/main.cpp index d29232d..6b49f1c 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -11,6 +11,7 @@ #include #include #include +#include #include "testing_helpers.hpp" const int SIZE = 1 << 8; // feel free to change the size of array @@ -144,16 +145,31 @@ int main(int argc, char* argv[]) { printf("*****************************\n"); printf("** Radix Sort TEST **\n"); printf("*****************************\n"); - genArray(15, a, 16); + + int numberCount = SIZE; // should smaller than SIZE (256 here) + + // These two values must be compatible + int maxValue = 16; + int maxBits = 4; + + genArray(numberCount, a, maxValue); printf("Randomly Generate Array with maxmium 16.\n"); - printArray(15, a, true); + printArray(numberCount, a, true); - zeroArray(15, b); - StreamCompaction::CPU::quickSort(15, b, a); - printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)"); + zeroArray(numberCount, b); + StreamCompaction::CPU::quickSort(numberCount, b, a); printf("qosrt Result : \n"); - printArray(15, b, true); + printArray(numberCount, b, true); + printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)"); + + zeroArray(numberCount, c); + RadixSort::sort(numberCount, maxBits, c, a); + printf("Radix sort Result : \n"); + printArray(numberCount, c, true); + printElapsedTime(RadixSort::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)"); + printf("sort result comparison between qsort and radix sort : \n"); + printCmpLenResult(numberCount, numberCount, b, c); system("pause"); // stop Win32 console from closing on exit } diff --git a/stream_compaction/RadixSort.cu b/stream_compaction/RadixSort.cu index 51853d3..964530b 100644 --- a/stream_compaction/RadixSort.cu +++ b/stream_compaction/RadixSort.cu @@ -1,6 +1,7 @@ #include #include #include "common.h" +#include "efficient.h" #include "RadixSort.h" namespace RadixSort { @@ -11,7 +12,98 @@ namespace RadixSort { return timer; } + __global__ void kernGen_b_e_array(int N, int idxBit, int* b_array, int* e_array, const int *dev_data) { + // TODO + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if (index >= N) { + return; + } + + int temp_result = (dev_data[index] >> idxBit) & 1; + b_array[index] = temp_result; + e_array[index] = 1 - temp_result; + + } + + template + __global__ void kern_Gen_d_array_and_scatter(int N, const int totalFalses, const int* b_array, const int* f_array, int* dev_data) + { + //Allocate appropriate shared memory + __shared__ int tile[BLOCK_SIZE]; + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if (index >= N) { + return; + } + + tile[threadIdx.x] = dev_data[index]; + __syncthreads(); + + int t_array_value = index - f_array[index] + totalFalses; + + int d_array_value = b_array[index] ? t_array_value : f_array[index]; + + dev_data[d_array_value] = tile[threadIdx.x]; + } + + void sort(int n, int numOfBits, int *odata, const int *idata) { + int* dev_data; + int* b_array; + int* e_array; + int* f_array; + + int* host_f_array = new int[n]; + + dim3 blockDim(blockSize); + dim3 gridDim((n + blockSize - 1) / blockSize); + + cudaMalloc((void**)&dev_data, n * sizeof(int)); + checkCUDAError("cudaMalloc dev_data failed!"); + cudaMalloc((void**)&b_array, n * sizeof(int)); + checkCUDAError("cudaMalloc b_array failed!"); + cudaMalloc((void**)&e_array, n * sizeof(int)); + checkCUDAError("cudaMalloc e_array failed!"); + cudaMalloc((void**)&f_array, n * sizeof(int)); + checkCUDAError("cudaMalloc f_array failed!"); + cudaDeviceSynchronize(); + + cudaMemcpy(dev_data, idata, sizeof(int) * n, cudaMemcpyHostToDevice); + checkCUDAError("RadixSort cudaMemcpy failed!"); + + timer().startGpuTimer(); + + for (int k = 0; k <= numOfBits - 1; k++) { + kernGen_b_e_array << > > (n, k, b_array, e_array, dev_data); + + cudaMemcpy(host_f_array, e_array, sizeof(int) * n, cudaMemcpyDeviceToHost); + + int totalFalses = host_f_array[n - 1]; + + // Get Exclusive scan result as a whole + StreamCompaction::Efficient::scan(n, host_f_array, host_f_array); + + totalFalses += host_f_array[n - 1]; + + cudaMemcpy(f_array, host_f_array, sizeof(int) * n, cudaMemcpyHostToDevice); + + // Since here we run exclusive scan as a whole, + // and we don't want each tile to run StreamCompaction::Efficient::scan individually. + // value in d_array here is actually index value in the whole data array, not just index in that tile + // so, there is NO need to merge here + kern_Gen_d_array_and_scatter << > > (n, totalFalses, b_array, f_array, dev_data); + } + + timer().endGpuTimer(); + + cudaMemcpy(odata, dev_data, sizeof(int) * n, cudaMemcpyDeviceToHost); + checkCUDAError("cudaMemcpy failed!"); + + cudaFree(dev_data); + cudaFree(b_array); + cudaFree(e_array); + cudaFree(f_array); + + delete[] host_f_array; } } \ No newline at end of file From ac40ff869aa925bab53c52d79ee4290f6f283417 Mon Sep 17 00:00:00 2001 From: HanmingZhang Date: Mon, 18 Sep 2017 12:30:16 -0400 Subject: [PATCH 4/8] all ec finished shared dynamic memo part finished --- src/main.cpp | 35 +++++++++ stream_compaction/efficient.cu | 128 ++++++++++++++++++++++++++++++++- stream_compaction/efficient.h | 2 + stream_compaction/naive.cu | 109 ++++++++++++++++++++++++++++ stream_compaction/naive.h | 2 + 5 files changed, 274 insertions(+), 2 deletions(-) diff --git a/src/main.cpp b/src/main.cpp index 6b49f1c..7c351e4 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -60,6 +60,23 @@ int main(int argc, char* argv[]) { //printArray(SIZE, c, true); printCmpResult(NPOT, b, c); + + ///------------EC : navie Dynamic Shared Memo Test-------------------- + zeroArray(SIZE, c); + printDesc("naive scan(Dynamic Share Memory), power-of-two"); + StreamCompaction::Naive::scanDynamicShared(SIZE, c, a); + printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)"); + //printArray(SIZE, c, true); + printCmpResult(SIZE, b, c); + + zeroArray(SIZE, c); + printDesc("naive scan(Dynamic Share Memory), non-power-of-two"); + StreamCompaction::Naive::scanDynamicShared(NPOT, c, a); + printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)"); + //printArray(SIZE, c, true); + printCmpResult(NPOT, b, c); + ///------------------------------------------------------------------------- + zeroArray(SIZE, c); printDesc("work-efficient scan, power-of-two"); StreamCompaction::Efficient::scan(SIZE, c, a); @@ -74,6 +91,24 @@ int main(int argc, char* argv[]) { //printArray(NPOT, c, true); printCmpResult(NPOT, b, c); + ///------------EC : efficient Dynamic Shared Memo Test-------------------- + zeroArray(SIZE, c); + printDesc("work-efficient scan(Dynamic Share Memory), power-of-two"); + StreamCompaction::Efficient::scanDynamicShared(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(Dynamic Share Memory), non-power-of-two"); + StreamCompaction::Efficient::scanDynamicShared(NPOT, c, a); + printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)"); + //printArray(SIZE, c, true); + printCmpResult(NPOT, b, c); + ///------------------------------------------------------------------------- + + + zeroArray(SIZE, c); printDesc("thrust scan, power-of-two"); StreamCompaction::Thrust::scan(SIZE, c, a); diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu index c12d8ad..91d3173 100644 --- a/stream_compaction/efficient.cu +++ b/stream_compaction/efficient.cu @@ -27,9 +27,11 @@ namespace StreamCompaction { return; } + // ------------ old branch mehthod---------------- //if ((index + 1) % offset == 0) { // dev_data[index] += dev_data[index - offset / 2]; //} + // ----------------------------------------------- int targetIndex = (index + 1) * offset - 1; dev_data[targetIndex] += dev_data[targetIndex - offset / 2]; @@ -45,11 +47,13 @@ namespace StreamCompaction { return; } + // ------------ old branch mehthod---------------- //if ((index + 1) % offset == 0) { // int t = dev_data[index - offset / 2]; // dev_data[index - offset / 2] = dev_data[index]; // dev_data[index] += t; //} + // ----------------------------------------------- int targetIndex = (index + 1) * offset - 1; @@ -62,6 +66,66 @@ namespace StreamCompaction { dev_count[0] = bools[N - 1] ? (indices[N - 1] + 1) : indices[N - 1]; } + /// ------------------- EX : Dynamic Shared Memo ---------------------- + __global__ void kernScanDynamicShared(int N, int n, int *g_odata, int *g_idata, int *OriRoot) { + extern __shared__ int temp[]; + + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if (index >= N) { + return; + } + + int thid = threadIdx.x; + // assume it's always a 1D block + int blockOffset = blockDim.x * blockIdx.x; + int offset = 1; + + temp[thid] = g_idata[blockOffset + thid]; + + // UP-sweep + for (int d = n >> 1; d > 0; d >>= 1) { + __syncthreads(); + if (thid < d) { + int ai = offset * (2 * thid + 1) - 1; + int bi = offset * (2 * thid + 2) - 1; + temp[bi] += temp[ai]; + } + offset *= 2; + } + + __syncthreads(); + // save origin root and set it to zero + if (thid == 0) { + OriRoot[blockIdx.x] = temp[n - 1]; + temp[n - 1] = 0; + } + + for (int d = 1; d < n; d *= 2) { + offset >>= 1; + __syncthreads(); + if (thid < d) { + int ai = offset * (2 * thid + 1) - 1; + int bi = offset * (2 * thid + 2) - 1; + + int t = temp[ai]; + temp[ai] = temp[bi]; + temp[bi] += t; + } + } + __syncthreads(); + g_odata[blockOffset + thid] = temp[thid]; + } + + __global__ void kernAddOriRoot(int N, int* OriRoot, int* dev_odata) { + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if (index >= N) { + return; + } + dev_odata[index] += OriRoot[blockIdx.x]; + } + + /// ------------------------------------------------------------------- + /** * Performs prefix-sum (aka scan) on idata, storing the result into odata. */ @@ -91,8 +155,10 @@ namespace StreamCompaction { // Step 1 : Up-sweep for (int d = 0; d <= dMax - 1; d++) { + // ------------ old branch mehthod---------------- //kernEffcientUpSweep << > > (size, (int)powf(2.0f, (float)d + 1.0f), dev_data); - + // ----------------------------------------------- + //only launch threads that acutally work int temp_size = (int)powf(2.0f, (float)(dMax - d - 1)); kernEffcientUpSweep << > > (temp_size, (int)powf(2.0f, (float)d + 1.0f), dev_data); @@ -105,8 +171,10 @@ namespace StreamCompaction { checkCUDAError("kernSetRootZero failed!"); for (int d = dMax - 1; d >= 0; d--) { + // ------------ old branch mehthod---------------- //kernEfficientDownSweep << > > (size, (int)powf(2.0f, (float)d + 1.0f), dev_data); - + // ----------------------------------------------- + //only launch threads that acutally work int temp_size = (int)powf(2.0f, (float)(dMax - d - 1)); kernEfficientDownSweep << > > (temp_size, (int)powf(2.0f, (float)d + 1.0f), dev_data); @@ -228,5 +296,61 @@ namespace StreamCompaction { return count; } + + + void scanDynamicShared(int n, int *odata, const int *idata) { + int dMax = ilog2ceil(n); + int size = (int)powf(2.0f, (float)dMax); + + int* dev_idata; + int* dev_odata; + int* ori_root; + + int dynamicMemoBlockSize = 64; + + dim3 blockDim(dynamicMemoBlockSize); + dim3 gridDim((size + dynamicMemoBlockSize - 1) / dynamicMemoBlockSize); + + int ori_root_size = (int)powf(2.0f, (float)ilog2ceil(gridDim.x)); + + cudaMalloc((void**)&dev_idata, sizeof(int) * size); + checkCUDAError("cudaMalloc dev_idata failed!"); + cudaMalloc((void**)&dev_odata, sizeof(int) * size); + checkCUDAError("cudaMalloc dev_odata failed!"); + cudaMalloc((void**)&ori_root, sizeof(int) * ori_root_size); + checkCUDAError("cudaMalloc ori_root failed!"); + cudaDeviceSynchronize(); + + kernSetZero << < gridDim, blockDim >> > (size, dev_idata); + checkCUDAError("kernSetZero failed!"); + kernSetZero << < dim3((ori_root_size + dynamicMemoBlockSize - 1) / dynamicMemoBlockSize), blockDim >> > (ori_root_size, ori_root); + checkCUDAError("kernSetZero failed!"); + + cudaMemcpy(dev_idata, idata, sizeof(int) * n, cudaMemcpyHostToDevice); + checkCUDAError("naive cudaMemcpy failed!"); + + int sharedMemoryPerBlockInBytes = dynamicMemoBlockSize * sizeof(int); // Compute This + + timer().startGpuTimer(); + + kernScanDynamicShared << > > (size, dynamicMemoBlockSize, dev_odata, dev_idata, ori_root); + + // TODO : + // Only support maximum size blockSize * blockSize = 64 * 64 = 4096 number support now + // and we only scan origin root one time here. + + sharedMemoryPerBlockInBytes = ori_root_size * sizeof(int); + kernScanDynamicShared << < dim3(1), dim3(ori_root_size), sharedMemoryPerBlockInBytes >> > (ori_root_size, ori_root_size, ori_root, ori_root, ori_root); + kernAddOriRoot << > > (size, ori_root, dev_odata); + + timer().endGpuTimer(); + + cudaMemcpy(odata, dev_odata, sizeof(int) * n, cudaMemcpyDeviceToHost); + checkCUDAError("cudaMemcpy failed!"); + + cudaFree(dev_idata); + cudaFree(dev_odata); + cudaFree(ori_root); + } } } diff --git a/stream_compaction/efficient.h b/stream_compaction/efficient.h index 803cb4f..45647a0 100644 --- a/stream_compaction/efficient.h +++ b/stream_compaction/efficient.h @@ -8,6 +8,8 @@ namespace StreamCompaction { void scan(int n, int *odata, const int *idata); + void scanDynamicShared(int n, int *odata, const int *idata); + int compact(int n, int *odata, const int *idata); } } diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu index 853ec4c..699ea22 100644 --- a/stream_compaction/naive.cu +++ b/stream_compaction/naive.cu @@ -45,6 +45,61 @@ namespace StreamCompaction { } } + /// ------------------- EX : Dynamic Shared Memo ---------------------- + __global__ void kernScanDynamicShared(int N, int n, int *g_odata, int *g_idata, int *OriRoot) { + extern __shared__ int temp[]; + + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if (index >= N) { + return; + } + + int thid = threadIdx.x; + int pout = 0, pin = 1; + // assume it's always a 1D block + int blockOffset = blockDim.x * blockIdx.x; + + temp[pout * n + thid] = (thid > 0) ? g_idata[blockOffset + thid - 1] : 0; + + __syncthreads(); + + for (int offset = 1; offset < n; offset *= 2) { + pout = 1 - pout; + pin = 1 - pin; + if (thid >= offset) { + temp[pout*n + thid] = temp[pin*n + thid] + temp[pin*n + thid - offset]; + } + else { + temp[pout*n + thid] = temp[pin*n + thid]; + } + __syncthreads(); + } + + if (thid == blockDim.x - 1) { + OriRoot[blockIdx.x] = g_idata[blockOffset + thid] + temp[pout*n + thid]; + } + + g_odata[blockOffset + thid] = temp[pout*n + thid]; + } + + __global__ void kernAddOriRoot(int N, int* OriRoot, int* dev_odata) { + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if (index >= N) { + return; + } + dev_odata[index] += OriRoot[blockIdx.x]; + } + + __global__ void kernSetZero(int N, int* dev_data) { + int index = threadIdx.x + (blockIdx.x * blockDim.x); + if (index >= N) { + return; + } + + dev_data[index] = 0; + } + + /// ------------------------------------------------------------------- /** * Performs prefix-sum (aka scan) on idata, storing the result into odata. @@ -96,5 +151,59 @@ namespace StreamCompaction { cudaFree(dev_idata); cudaFree(dev_odata); } + + void scanDynamicShared(int n, int *odata, const int *idata) { + + int dMax = ilog2ceil(n); + int size = (int)powf(2.0f, (float)dMax); + + int* dev_idata; + int* dev_odata; + int* ori_root; + + int dynamicMemoBlockSize = 64; + + dim3 blockDim(dynamicMemoBlockSize); + dim3 gridDim((size + dynamicMemoBlockSize - 1) / dynamicMemoBlockSize); + + + cudaMalloc((void**)&dev_idata, sizeof(int) * size); + checkCUDAError("cudaMalloc dev_idata failed!"); + cudaMalloc((void**)&dev_odata, sizeof(int) * size); + checkCUDAError("cudaMalloc dev_odata failed!"); + cudaMalloc((void**)&ori_root, sizeof(int) * gridDim.x); + checkCUDAError("cudaMalloc ori_root failed!"); + cudaDeviceSynchronize(); + + kernSetZero << < gridDim, blockDim >> > (size, dev_idata); + checkCUDAError("kernSetZero failed!"); + kernSetZero << < dim3((gridDim.x + dynamicMemoBlockSize - 1) / dynamicMemoBlockSize), blockDim >> > (gridDim.x, ori_root); + checkCUDAError("kernSetZero failed!"); + + cudaMemcpy(dev_idata, idata, sizeof(int) * n, cudaMemcpyHostToDevice); + checkCUDAError("naive cudaMemcpy failed!"); + + int sharedMemoryPerBlockInBytes = 2 * dynamicMemoBlockSize * sizeof(int); // Compute This + + timer().startGpuTimer(); + + kernScanDynamicShared << > > (size, dynamicMemoBlockSize, dev_odata, dev_idata, ori_root); + + // TODO : + // Only support maximum size blockSize * blockSize = 64 * 64 = 4096 number support now + // and we only scan origin root one time. + sharedMemoryPerBlockInBytes = 2 * gridDim.x * sizeof(int); + kernScanDynamicShared << < dim3(1), gridDim, sharedMemoryPerBlockInBytes >> > (gridDim.x, gridDim.x, ori_root, ori_root, ori_root); + kernAddOriRoot << > > (size, ori_root, dev_odata); + + timer().endGpuTimer(); + + cudaMemcpy(odata, dev_odata, sizeof(int) * n, cudaMemcpyDeviceToHost); + checkCUDAError("cudaMemcpy failed!"); + + cudaFree(dev_idata); + cudaFree(dev_odata); + cudaFree(ori_root); + } } } diff --git a/stream_compaction/naive.h b/stream_compaction/naive.h index 37dcb06..4f6d839 100644 --- a/stream_compaction/naive.h +++ b/stream_compaction/naive.h @@ -7,5 +7,7 @@ namespace StreamCompaction { StreamCompaction::Common::PerformanceTimer& timer(); void scan(int n, int *odata, const int *idata); + + void scanDynamicShared(int n, int *odata, const int *idata); } } From 0f716aff659184e5bbb0f41d0551b183a1b34199 Mon Sep 17 00:00:00 2001 From: HanmingZhang Date: Tue, 19 Sep 2017 19:45:10 -0400 Subject: [PATCH 5/8] Project2 Submit --- README.md | 183 ++++++++++++++++++++++++++++++++- img/1TotalNumberAnalysis.jpg | Bin 0 -> 193112 bytes img/2BlockSizeAnalysis.jpg | Bin 0 -> 250921 bytes img/3WorkEfficientAnalysis.jpg | Bin 0 -> 144331 bytes img/4GlobalVSShared.jpg | Bin 0 -> 132922 bytes img/5DifferentScan.jpg | Bin 0 -> 162278 bytes src/main.cpp | 2 +- stream_compaction/efficient.cu | 24 +++-- 8 files changed, 193 insertions(+), 16 deletions(-) create mode 100644 img/1TotalNumberAnalysis.jpg create mode 100644 img/2BlockSizeAnalysis.jpg create mode 100644 img/3WorkEfficientAnalysis.jpg create mode 100644 img/4GlobalVSShared.jpg create mode 100644 img/5DifferentScan.jpg diff --git a/README.md b/README.md index b71c458..755a75b 100644 --- a/README.md +++ b/README.md @@ -3,11 +3,184 @@ 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) +* Hanming Zhang +* Tested on: Windows 10 Education, i7-6700K @ 4.00GHz 16.0GB, GTX 980 4096MB (Personal Desktop) -### (TODO: Your README) +### Project Features +##### (All scans are exclusive. To make inclusive scan result become exclusive, just shift the result right by one element and insert the identity on the head. I implemented a kernel to realize this on naive.cu. On the other hand, to make a exclusive scan result become inclusive, shift the result left by one element and insert the sum of previous elements on the last place) -Include analysis, etc. (Remember, this is public, so don't put -anything here that you don't want to share with the world.) +- CPU Scan +- CPU Compaction without Scan +- CPU Compaction with Scan +- Naive GPU Scan +- Work-Efficient GPU Scan +- Work-Efficient GPU Stream Compaction +- Thrust's Scan +#### Extra Credits implemented: +- Work-Efficient GPU Scan Optimization(Why-is-my-GPU-approach-so-slow Optimization) : All old branches in the kernel are removed, and all threads launched do work now. See **kernEffcientUpSweep** and **kernEffcientUpSweep** in **efficient.cu** for details. +- Radix Sort : see the last part of **main** function(**line 179 - 207**) for test and **RadixSort.h** and **RadixSort.cu** for details. Call **RadixSort::sort** to use it. +- GPU Scan using shared memory & hardware Optimization : see **StreamCompaction::Efficient::scanDynamicShared** and **StreamCompaction::Naive::scanDynamicShared** for details + +### Project Analysis (Under x64 Release mode) + +- #### Total number size performance analysis + ###### in this SCAN analysis, all GPU block sizes are temporarily set *64*, and Efficient Scan method is *optimized(branches in the kernel is removed)*. *No shared memory* so far. No Power Of Two = Power Of Two - 3 + + ![](img/1TotalNumberAnalysis.jpg) + + ###### Analysis: + First of all, in case of POT and NPOT, Naive's and Thrust's POT always consume more time bsed on the data we get. This is understandable because there is just less operations needed. However, in case of Work-Efficient method, we fill our NPOT array zeroes in this case to make it a POT array (power + 1) so that we can use efficient algorithm. As a result, there is no clear time-consuming difference between POT and NPOT. + + Besides that, navie and Work-Efficient method all appear some sudden consuming time increasing conditions, like from size 512 to 1024 for Work-Efficient and from 1024 to 2048 for naive. I think this can be explained as since there are always limited numbe of blocks can be processed at one time, when that limitation is passed, there will be a relatively huge consuming time increase. + + Finally, Thrust scan method appears pretty stable under different size conditions. + +- #### Block Size performance analysis + ###### in this SCAN analysis, the total number size is set *2048*, and Efficient Scan method is *optimized(branches in the kernel is removed)*. *No shared memory* so far. No Power Of Two = Power Of Two - 3 + + ![](img/2BlockSizeAnalysis.jpg) + + ###### Analysis: + Based on the data we got, apparently, there is no clear time-consuming difference between different block sizes, except that the time size 64 used is very slightly smaller than others. I think it's just a choice between more blocks with smaller single block size OR less block with larger block size and it won't influence a SM so much in terms of the total time to process them. Besides that, no matter naive or Work-Efficient, we all use **global memory** here, so both methods spend a lot of time on that. + + +- #### Efficient-working GPU kernel Optimization analysis(before and after branches are removed in kernel, EC 1) + ###### in this analysis, all GPU block sizes are set *64*, total number size *2048*. No Power Of Two = Power Of Two - 3 + + ![](img/3WorkEfficientAnalysis.jpg) + + ###### Analysis: + As we can see on the data, after I optimized the code, removed the if statement in the kernel and only launch threads that actually do the work, our performance improve slightly. This is understandable because **the number of threads actually do the work doesn't change at all**. Since we use global memory here and for loop happens on the host side, the only difference is that we launch 2048 threads 11 times(since 2^11 = 2048), most of which actually doesn't do any work, and launch (2^10 + 2^9 + 2^8 + ... + 2^0) threads that all do the work. However, we have to notice, the luck thing is that **there is not so much to do in the if statement in the kernel, so the stall time is no so long**, if there is much more work to do in the if statement, the performance will improve further. + + +- #### Global memory VS (Shared memory + Hardware Optimization) (EC 3) + ###### in this SCAN analysis, all GPU block sizes are set *64*, total number size *2048*. Efficient Scan method is *optimized(branches in the kernel is removed)*. No Power Of Two = Power Of Two - 3 + + ![](img/4GlobalVSShared.jpg) + + ###### Analysis: + Result is pretty clear, Naive method improves about **300%** and Work-Efficient improves about **450%** in performance. **K.O.** + + First of all, the loop times of global memory method and shared memory method are different. For the **global**, in our case, since 2^11 = 2048, we have to run kernel **11 times** in the host side. However, for the **shared memory**, since block size is 64 (2^6), we run for loop 6 + 1 = **7 times** in each kernel. + + We also largely reduce our global memory access, for the **global**, we have to access global memory (1 read + 1 write) x 11 = **22 times**. However, in the **shared memory**, we only need to access global memory 1 read + 1 write = **2 times** for each kernel. + + Hardware optimization also works well here. Just like the difference between stride = 1, 2, 4 .... and stride = 4, 2, 1 ... In our case, it's **stride = 64, 32, 16, 8, 4, 2, 1**, which means, instead of just waiting for certain threads in the block to finish its tasks, most blocks just finish their tasks earlier and leave rest tasks only certain small amount of blocks to finish. + + + +- #### Scan Methods Comparsion & Analysis + ###### in this SCAN analysis, all GPU block sizes are set *64*, total number size *2048*. Efficient Scan method is *optimized(branches in the kernel is removed)*. No Power Of Two = Power Of Two - 3 + + ![](img/5DifferentScan.jpg) + + ###### Analysis: + + Work-Efficient is not so efficient in our case, although I tried to optimize it and remove the branch(if statement) in the kernel and only launch threads that do the work. + + Global memory access is still where our performance bottlenecks are. If we use global memory, we have to access it so many times, which really take "long" time here. The result(such huge performance improvement) we get about shared memory tell everything about it. + + Naive method has a better performance than Work-Efficient in this case and the reason of which might be our number size is still limited here, only 2048, if we have millions of numbers, Work-Efficient method will definitely have a better performance. + + Thrust keep very stable and always have a relatively good performance. + + +- #### Radix Sort analysis and comparison with build-in qsort + ###### in this analysis, all GPU block sizes are set *64*, total number size *2048*. I use global memory efficient Scan method is *optimized(branches in the kernel is removed)*. No Power Of Two = Power Of Two - 3 + +qsort | Radix Sort +------------ | ------------- +0.0539 ms | 1.0717 ms + + + ###### Analysis: + I think the main responsibility for such a long Radix Sort time is that I use global memory (because is before Shared Memory & hardware optimization part in EC list, so I implemented it First). There is so many global memory accesses, especially when we generate the arrays we need. Besides that, the Efficient-working scan method I use here is actually the most inefficient one. + + Qsort runs pretty well, and take less than 0.1 ms to finish sorting. + + + + + +- #### Output of the test Programming + ``` + **************** + ** SCAN TESTS ** + **************** + [ 13 35 38 24 16 12 38 34 30 23 43 19 30 ... 22 0 ] + ==== cpu scan, power-of-two ==== + elapsed time: 0.002811ms (std::chrono Measured) + [ 0 13 48 86 110 126 138 176 210 240 263 306 325 ... 50256 50278 ] + ==== cpu scan, non-power-of-two ==== + elapsed time: 0.002811ms (std::chrono Measured) + [ 0 13 48 86 110 126 138 176 210 240 263 306 325 ... 50217 50240 ] + passed + ==== naive scan, power-of-two ==== + elapsed time: 0.061728ms (CUDA Measured) + passed + ==== naive scan, non-power-of-two ==== + elapsed time: 0.059904ms (CUDA Measured) + passed + ==== naive scan(Dynamic Share Memory), power-of-two ==== + elapsed time: 0.01408ms (CUDA Measured) + passed + ==== naive scan(Dynamic Share Memory), non-power-of-two ==== + elapsed time: 0.014048ms (CUDA Measured) + passed + ==== work-efficient scan, power-of-two ==== + elapsed time: 0.093376ms (CUDA Measured) + passed + ==== work-efficient scan, non-power-of-two ==== + elapsed time: 0.093536ms (CUDA Measured) + passed + ==== work-efficient scan(Dynamic Share Memory), power-of-two ==== + elapsed time: 0.016832ms (CUDA Measured) + passed + ==== work-efficient scan(Dynamic Share Memory), non-power-of-two ==== + elapsed time: 0.0168ms (CUDA Measured) + passed + ==== thrust scan, power-of-two ==== + elapsed time: 0.023744ms (CUDA Measured) + passed + ==== thrust scan, non-power-of-two ==== + elapsed time: 0.014848ms (CUDA Measured) + passed + + ***************************** + ** STREAM COMPACTION TESTS ** + ***************************** + [ 1 1 2 0 2 0 0 2 2 3 3 3 0 ... 2 0 ] + ==== cpu compact without scan, power-of-two ==== + elapsed time: 0.004344ms (std::chrono Measured) + [ 1 1 2 2 2 2 3 3 3 3 2 3 3 ... 1 2 ] + passed + ==== cpu compact without scan, non-power-of-two ==== + elapsed time: 0.004343ms (std::chrono Measured) + [ 1 1 2 2 2 2 3 3 3 3 2 3 3 ... 1 1 ] + passed + ==== cpu compact with scan ==== + elapsed time: 0.008431ms (std::chrono Measured) + [ 1 1 2 2 2 2 3 3 3 3 2 3 3 ... 1 2 ] + passed + ==== work-efficient compact, power-of-two ==== + elapsed time: 0.1088ms (CUDA Measured) + passed + ==== work-efficient compact, non-power-of-two ==== + elapsed time: 0.108832ms (CUDA Measured) + passed + + ***************************** + ** Radix Sort TEST ** + ***************************** + Randomly Generate Array with maxmium 16. + [ 13 1 14 8 10 4 8 10 6 7 7 15 12 ... 14 13 ] + qosrt Result : + [ 0 0 0 0 0 0 0 0 0 0 0 0 0 ... 15 15 ] + elapsed time: 0.053908ms (std::chrono Measured) + Radix sort Result : + [ 0 0 0 0 0 0 0 0 0 0 0 0 0 ... 15 15 ] + elapsed time: 1.07917ms (CUDA Measured) + sort result comparison between qsort and radix sort : + passed + ``` diff --git a/img/1TotalNumberAnalysis.jpg b/img/1TotalNumberAnalysis.jpg new file mode 100644 index 0000000000000000000000000000000000000000..33a3fe2e772e24d444d8dce8d6d1637c2babf6c3 GIT binary patch literal 193112 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 f*xQJiwUP%2j%Od**v%N!w@DKcc1 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≧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 #include "testing_helpers.hpp" -const int SIZE = 1 << 8; // feel free to change the size of array +const int SIZE = 2048; //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/efficient.cu b/stream_compaction/efficient.cu index 91d3173..889e28c 100644 --- a/stream_compaction/efficient.cu +++ b/stream_compaction/efficient.cu @@ -28,9 +28,9 @@ namespace StreamCompaction { } // ------------ old branch mehthod---------------- - //if ((index + 1) % offset == 0) { - // dev_data[index] += dev_data[index - offset / 2]; - //} + /*if ((index + 1) % offset == 0) { + dev_data[index] += dev_data[index - offset / 2]; + }*/ // ----------------------------------------------- int targetIndex = (index + 1) * offset - 1; @@ -48,11 +48,11 @@ namespace StreamCompaction { } // ------------ old branch mehthod---------------- - //if ((index + 1) % offset == 0) { - // int t = dev_data[index - offset / 2]; - // dev_data[index - offset / 2] = dev_data[index]; - // dev_data[index] += t; - //} + /*if ((index + 1) % offset == 0) { + int t = dev_data[index - offset / 2]; + dev_data[index - offset / 2] = dev_data[index]; + dev_data[index] += t; + }*/ // ----------------------------------------------- int targetIndex = (index + 1) * offset - 1; @@ -251,8 +251,10 @@ namespace StreamCompaction { // Step 2 : exclusive scan indices // Up-sweep for (int d = 0; d <= dMax - 1; d++) { + // ------------ old branch mehthod---------------- //kernEffcientUpSweep << > > (size, (int)powf(2.0f, (float)d + 1.0f), indices); - + // ----------------------------------------------- + //only launch threads that acutally work int temp_size = (int)powf(2.0f, (float)(dMax - d - 1)); kernEffcientUpSweep << > > (temp_size, (int)powf(2.0f, (float)d + 1.0f), indices); @@ -264,8 +266,10 @@ namespace StreamCompaction { checkCUDAError("kernSetRootZero failed!"); for (int d = dMax - 1; d >= 0; d--) { + // ------------ old branch mehthod---------------- //kernEfficientDownSweep << > > (size, (int)powf(2.0f, (float)d + 1.0f), indices); - + // ----------------------------------------------- + //only launch threads that acutally work int temp_size = (int)powf(2.0f, (float)(dMax - d - 1)); kernEfficientDownSweep << > > (temp_size, (int)powf(2.0f, (float)d + 1.0f), indices); From 6f042f0a7cc581541c534d73216ab590de2ca81a Mon Sep 17 00:00:00 2001 From: HanmingZhang Date: Thu, 21 Sep 2017 00:22:18 -0400 Subject: [PATCH 6/8] bug fix 1. naive shared memory bug fix 2. work efficient compaction shared memory added --- src/main.cpp | 14 ++++ stream_compaction/RadixSort.cu | 6 +- stream_compaction/efficient.cu | 119 ++++++++++++++++++++++++++++----- stream_compaction/efficient.h | 2 + stream_compaction/naive.cu | 5 +- 5 files changed, 127 insertions(+), 19 deletions(-) diff --git a/src/main.cpp b/src/main.cpp index d9962e5..5af01c0 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -175,6 +175,20 @@ int main(int argc, char* argv[]) { //printArray(count, c, true); printCmpLenResult(count, expectedNPOT, b, c); + zeroArray(SIZE, c); + printDesc("work-efficient compact(Dynammic Shared), power-of-two"); + count = StreamCompaction::Efficient::compactDynamicShared(SIZE, c, a); + printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)"); + //printArray(count, c, true); + printCmpLenResult(count, expectedCount, b, c); + + zeroArray(SIZE, c); + printDesc("work-efficient compact(Dynammic Shared), non-power-of-two"); + count = StreamCompaction::Efficient::compactDynamicShared(NPOT, c, a); + printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)"); + //printArray(count, c, true); + printCmpLenResult(count, expectedNPOT, b, c); + printf("\n"); printf("*****************************\n"); diff --git a/stream_compaction/RadixSort.cu b/stream_compaction/RadixSort.cu index 964530b..3fee797 100644 --- a/stream_compaction/RadixSort.cu +++ b/stream_compaction/RadixSort.cu @@ -4,6 +4,7 @@ #include "efficient.h" #include "RadixSort.h" + namespace RadixSort { using StreamCompaction::Common::PerformanceTimer; PerformanceTimer& timer() @@ -72,16 +73,17 @@ namespace RadixSort { checkCUDAError("RadixSort cudaMemcpy failed!"); timer().startGpuTimer(); - + for (int k = 0; k <= numOfBits - 1; k++) { kernGen_b_e_array << > > (n, k, b_array, e_array, dev_data); cudaMemcpy(host_f_array, e_array, sizeof(int) * n, cudaMemcpyDeviceToHost); int totalFalses = host_f_array[n - 1]; - + // Get Exclusive scan result as a whole StreamCompaction::Efficient::scan(n, host_f_array, host_f_array); + //StreamCompaction::Efficient::scanDynamicShared(n, host_f_array, host_f_array); totalFalses += host_f_array[n - 1]; diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu index 889e28c..77c8e87 100644 --- a/stream_compaction/efficient.cu +++ b/stream_compaction/efficient.cu @@ -306,8 +306,7 @@ namespace StreamCompaction { int dMax = ilog2ceil(n); int size = (int)powf(2.0f, (float)dMax); - int* dev_idata; - int* dev_odata; + int* dev_data; int* ori_root; int dynamicMemoBlockSize = 64; @@ -315,46 +314,134 @@ namespace StreamCompaction { dim3 blockDim(dynamicMemoBlockSize); dim3 gridDim((size + dynamicMemoBlockSize - 1) / dynamicMemoBlockSize); - int ori_root_size = (int)powf(2.0f, (float)ilog2ceil(gridDim.x)); - - cudaMalloc((void**)&dev_idata, sizeof(int) * size); + + cudaMalloc((void**)&dev_data, sizeof(int) * size); checkCUDAError("cudaMalloc dev_idata failed!"); - cudaMalloc((void**)&dev_odata, sizeof(int) * size); - checkCUDAError("cudaMalloc dev_odata failed!"); - cudaMalloc((void**)&ori_root, sizeof(int) * ori_root_size); + cudaMalloc((void**)&ori_root, sizeof(int) * gridDim.x); checkCUDAError("cudaMalloc ori_root failed!"); cudaDeviceSynchronize(); - kernSetZero << < gridDim, blockDim >> > (size, dev_idata); + kernSetZero << < gridDim, blockDim >> > (size, dev_data); checkCUDAError("kernSetZero failed!"); - kernSetZero << < dim3((ori_root_size + dynamicMemoBlockSize - 1) / dynamicMemoBlockSize), blockDim >> > (ori_root_size, ori_root); + kernSetZero << < dim3((gridDim.x + dynamicMemoBlockSize - 1) / dynamicMemoBlockSize), blockDim >> > (gridDim.x, ori_root); checkCUDAError("kernSetZero failed!"); - cudaMemcpy(dev_idata, idata, sizeof(int) * n, cudaMemcpyHostToDevice); + cudaMemcpy(dev_data, idata, sizeof(int) * n, cudaMemcpyHostToDevice); checkCUDAError("naive cudaMemcpy failed!"); int sharedMemoryPerBlockInBytes = dynamicMemoBlockSize * sizeof(int); // Compute This timer().startGpuTimer(); - kernScanDynamicShared << > > (size, dynamicMemoBlockSize, dev_odata, dev_idata, ori_root); + kernScanDynamicShared << > > (size, dynamicMemoBlockSize, dev_data, dev_data, ori_root); // TODO : // Only support maximum size blockSize * blockSize = 64 * 64 = 4096 number support now // and we only scan origin root one time here. - sharedMemoryPerBlockInBytes = ori_root_size * sizeof(int); - kernScanDynamicShared << < dim3(1), dim3(ori_root_size), sharedMemoryPerBlockInBytes >> > (ori_root_size, ori_root_size, ori_root, ori_root, ori_root); - kernAddOriRoot << > > (size, ori_root, dev_odata); + sharedMemoryPerBlockInBytes = gridDim.x * sizeof(int); + kernScanDynamicShared << < dim3(1), dim3(gridDim.x), sharedMemoryPerBlockInBytes >> > (gridDim.x, gridDim.x, ori_root, ori_root, ori_root); + kernAddOriRoot << > > (size, ori_root, dev_data); timer().endGpuTimer(); - cudaMemcpy(odata, dev_odata, sizeof(int) * n, cudaMemcpyDeviceToHost); + cudaMemcpy(odata, dev_data, sizeof(int) * n, cudaMemcpyDeviceToHost); + checkCUDAError("cudaMemcpy failed!"); + + cudaFree(dev_data); + cudaFree(ori_root); + } + + + int compactDynamicShared(int n, int *odata, const int *idata) { + // compact Set-up + int* dev_idata; + int* dev_odata; + int* bools; + int* indices; + int* dev_count; + int count; + + dim3 blockDim(blockSize); + dim3 gridDim((n + blockSize - 1) / blockSize); + + cudaMalloc((void**)&dev_idata, n * sizeof(int)); + checkCUDAError("cudaMalloc dev_idata failed!"); + cudaMalloc((void**)&dev_odata, n * sizeof(int)); + checkCUDAError("cudaMalloc dev_odata failed!"); + cudaMalloc((void**)&bools, n * sizeof(int)); + checkCUDAError("cudaMalloc bools failed!"); + cudaMalloc((void**)&dev_count, sizeof(int)); + checkCUDAError("cudaMalloc dev_count failed!"); + cudaDeviceSynchronize(); + + cudaMemcpy(dev_idata, idata, sizeof(int) * n, cudaMemcpyHostToDevice); + checkCUDAError("efficient compact cudaMemcpy failed!"); + + + + // scan Set-up + int dMax = ilog2ceil(n); + int size = (int)powf(2.0f, (float)dMax); + + int* ori_root; + + dim3 scan_gridDim((size + blockSize - 1) / blockSize); + + cudaMalloc((void**)&indices, size * sizeof(int)); + checkCUDAError("cudaMalloc indices failed!"); + cudaMalloc((void**)&ori_root, sizeof(int) * gridDim.x); + checkCUDAError("cudaMalloc ori_root failed!"); + cudaDeviceSynchronize(); + + kernSetZero << < scan_gridDim, blockDim >> > (size, indices); + checkCUDAError("kernSetZero failed!"); + kernSetZero << < dim3((scan_gridDim.x + gridDim.x - 1) / gridDim.x), blockDim >> > (gridDim.x, ori_root); + checkCUDAError("kernSetZero failed!"); + + int sharedMemoryPerBlockInBytes = blockDim.x * sizeof(int); // Compute This + + timer().startGpuTimer(); + + // Step 1 : compute bools array + StreamCompaction::Common::kernMapToBoolean << > > (n, bools, dev_idata); + checkCUDAError("kernMapToBoolean failed!"); + + cudaMemcpy(indices, bools, sizeof(int) * n, cudaMemcpyDeviceToDevice); + checkCUDAError("cudaMemcpy failed!"); + + // Step 2 : exclusive scan indices + kernScanDynamicShared << > > (size, blockDim.x, indices, indices, ori_root); + + sharedMemoryPerBlockInBytes = gridDim.x * sizeof(int); + kernScanDynamicShared << < dim3(1), dim3(gridDim.x), sharedMemoryPerBlockInBytes >> > (scan_gridDim.x, scan_gridDim.x, ori_root, ori_root, ori_root); + kernAddOriRoot << > > (size, ori_root, indices); + + + // Step 3 : Scatter + StreamCompaction::Common::kernScatter << > > (n, dev_odata, dev_idata, bools, indices); + checkCUDAError("kernScatter failed!"); + + kernSetCompactCount << > > (n, dev_count, bools, indices); + checkCUDAError("kernSetCompactCount failed!"); + + timer().endGpuTimer(); + + + cudaMemcpy(&count, dev_count, sizeof(int), cudaMemcpyDeviceToHost); + checkCUDAError("cudaMemcpy failed!"); + + cudaMemcpy(odata, dev_odata, sizeof(int) * count, cudaMemcpyDeviceToHost); checkCUDAError("cudaMemcpy failed!"); cudaFree(dev_idata); cudaFree(dev_odata); + cudaFree(bools); + cudaFree(dev_count); + cudaFree(indices); cudaFree(ori_root); + + return count; } } } diff --git a/stream_compaction/efficient.h b/stream_compaction/efficient.h index 45647a0..42f8b95 100644 --- a/stream_compaction/efficient.h +++ b/stream_compaction/efficient.h @@ -11,5 +11,7 @@ namespace StreamCompaction { void scanDynamicShared(int n, int *odata, const int *idata); int compact(int n, int *odata, const int *idata); + + int compactDynamicShared(int n, int *odata, const int *idata); } } diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu index 699ea22..1b896aa 100644 --- a/stream_compaction/naive.cu +++ b/stream_compaction/naive.cu @@ -75,8 +75,11 @@ namespace StreamCompaction { __syncthreads(); } - if (thid == blockDim.x - 1) { + /*if (thid == blockDim.x - 1) { OriRoot[blockIdx.x] = g_idata[blockOffset + thid] + temp[pout*n + thid]; + }*/ + if (thid == 0) { + OriRoot[blockIdx.x] = g_idata[blockOffset + n - 1] + temp[pout*n + n - 1]; } g_odata[blockOffset + thid] = temp[pout*n + thid]; From d4e2bbac89a2bec6085b9fa3ae4b96afce84c4ca Mon Sep 17 00:00:00 2001 From: HanmingZhang Date: Thu, 21 Sep 2017 00:45:22 -0400 Subject: [PATCH 7/8] code optimization --- stream_compaction/efficient.cu | 14 ++++++-------- stream_compaction/naive.cu | 8 +++----- 2 files changed, 9 insertions(+), 13 deletions(-) diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu index 77c8e87..4774ea2 100644 --- a/stream_compaction/efficient.cu +++ b/stream_compaction/efficient.cu @@ -151,7 +151,6 @@ namespace StreamCompaction { timer().startGpuTimer(); - // TODO // Step 1 : Up-sweep for (int d = 0; d <= dMax - 1; d++) { @@ -240,7 +239,6 @@ namespace StreamCompaction { timer().startGpuTimer(); - // TODO // Step 1 : compute bools array StreamCompaction::Common::kernMapToBoolean << > > (n, bools, dev_idata); checkCUDAError("kernMapToBoolean failed!"); @@ -335,11 +333,10 @@ namespace StreamCompaction { kernScanDynamicShared << > > (size, dynamicMemoBlockSize, dev_data, dev_data, ori_root); - // TODO : - // Only support maximum size blockSize * blockSize = 64 * 64 = 4096 number support now - // and we only scan origin root one time here. - sharedMemoryPerBlockInBytes = gridDim.x * sizeof(int); + // We only do scan of scan ONE time here + // Actually, it should be a while loop here + // This process should happen until root number we get < blockDim.x kernScanDynamicShared << < dim3(1), dim3(gridDim.x), sharedMemoryPerBlockInBytes >> > (gridDim.x, gridDim.x, ori_root, ori_root, ori_root); kernAddOriRoot << > > (size, ori_root, dev_data); @@ -379,7 +376,6 @@ namespace StreamCompaction { checkCUDAError("efficient compact cudaMemcpy failed!"); - // scan Set-up int dMax = ilog2ceil(n); int size = (int)powf(2.0f, (float)dMax); @@ -414,6 +410,9 @@ namespace StreamCompaction { kernScanDynamicShared << > > (size, blockDim.x, indices, indices, ori_root); sharedMemoryPerBlockInBytes = gridDim.x * sizeof(int); + // We only do scan of scan ONE time here + // Actually, it should be a while loop here + // This process should happen until root number we get < blockDim.x kernScanDynamicShared << < dim3(1), dim3(gridDim.x), sharedMemoryPerBlockInBytes >> > (scan_gridDim.x, scan_gridDim.x, ori_root, ori_root, ori_root); kernAddOriRoot << > > (size, ori_root, indices); @@ -430,7 +429,6 @@ namespace StreamCompaction { cudaMemcpy(&count, dev_count, sizeof(int), cudaMemcpyDeviceToHost); checkCUDAError("cudaMemcpy failed!"); - cudaMemcpy(odata, dev_odata, sizeof(int) * count, cudaMemcpyDeviceToHost); checkCUDAError("cudaMemcpy failed!"); diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu index 1b896aa..117799e 100644 --- a/stream_compaction/naive.cu +++ b/stream_compaction/naive.cu @@ -13,7 +13,6 @@ namespace StreamCompaction { static PerformanceTimer timer; return timer; } - // TODO: __global__ __global__ void kernGenExclusiveScanFromInclusiveScan(int N, int* dev_odata, int* dev_idata) { int index = threadIdx.x + (blockIdx.x * blockDim.x); if (index >= N) { @@ -129,7 +128,6 @@ namespace StreamCompaction { timer().startGpuTimer(); - // TODO for (int d = 1; d <= dMax; d++) { // call cuda here // PAY ATTENTION : this is an inclusive scan @@ -192,9 +190,9 @@ namespace StreamCompaction { kernScanDynamicShared << > > (size, dynamicMemoBlockSize, dev_odata, dev_idata, ori_root); - // TODO : - // Only support maximum size blockSize * blockSize = 64 * 64 = 4096 number support now - // and we only scan origin root one time. + // We only do scan of scan ONE time here + // Actually, it should be a while loop here + // This process should happen until root number we get < blockDim.x sharedMemoryPerBlockInBytes = 2 * gridDim.x * sizeof(int); kernScanDynamicShared << < dim3(1), gridDim, sharedMemoryPerBlockInBytes >> > (gridDim.x, gridDim.x, ori_root, ori_root, ori_root); kernAddOriRoot << > > (size, ori_root, dev_odata); From 57b9ad94adfb9159a1fb5e74424cea451d02fa77 Mon Sep 17 00:00:00 2001 From: HanmingZhang Date: Sun, 24 Sep 2017 22:33:51 -0400 Subject: [PATCH 8/8] efficient method revise --- stream_compaction/efficient.cu | 63 ++++++++++++++++++++++++++-------- 1 file changed, 49 insertions(+), 14 deletions(-) diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu index 4774ea2..9a25b41 100644 --- a/stream_compaction/efficient.cu +++ b/stream_compaction/efficient.cu @@ -3,6 +3,12 @@ #include "common.h" #include "efficient.h" +#define NUM_BANKS 32 +#define LOG_NUM_BANKS 5 +#define CONFLICT_FREE_OFFSET(n) \ + ((n) >> NUM_BANKS + (n) >> (2 * LOG_NUM_BANKS)) + + namespace StreamCompaction { namespace Efficient { using StreamCompaction::Common::PerformanceTimer; @@ -67,27 +73,42 @@ namespace StreamCompaction { } /// ------------------- EX : Dynamic Shared Memo ---------------------- - __global__ void kernScanDynamicShared(int N, int n, int *g_odata, int *g_idata, int *OriRoot) { + __global__ void kernScanDynamicShared(int n, int *g_odata, int *g_idata, int *OriRoot) { extern __shared__ int temp[]; - int index = threadIdx.x + (blockIdx.x * blockDim.x); - if (index >= N) { - return; - } + //int index = threadIdx.x + (blockIdx.x * blockDim.x); + //if (index >= N) { + // return; + //} int thid = threadIdx.x; // assume it's always a 1D block - int blockOffset = blockDim.x * blockIdx.x; + int blockOffset = 2 * blockDim.x * blockIdx.x; int offset = 1; - temp[thid] = g_idata[blockOffset + thid]; + //temp[2 * thid] = g_idata[blockOffset + 2 * thid]; + //temp[2 * thid + 1] = g_idata[blockOffset + 2 * thid + 1]; + int ai = thid; + int bi = thid + (n / 2); + int bankOffsetA = CONFLICT_FREE_OFFSET(ai); + int bankOffsetB = CONFLICT_FREE_OFFSET(bi); + temp[ai + bankOffsetA] = g_idata[blockOffset + ai]; + temp[bi + bankOffsetB] = g_idata[blockOffset + bi]; + + // UP-sweep for (int d = n >> 1; d > 0; d >>= 1) { __syncthreads(); if (thid < d) { + //int ai = offset * (2 * thid + 1) - 1; + //int bi = offset * (2 * thid + 2) - 1; int ai = offset * (2 * thid + 1) - 1; - int bi = offset * (2 * thid + 2) - 1; + int bi = offset * (2 * thid + 2) - 1; + ai += CONFLICT_FREE_OFFSET(ai); + bi += CONFLICT_FREE_OFFSET(bi); + + temp[bi] += temp[ai]; } offset *= 2; @@ -97,15 +118,20 @@ namespace StreamCompaction { // save origin root and set it to zero if (thid == 0) { OriRoot[blockIdx.x] = temp[n - 1]; - temp[n - 1] = 0; + //temp[n - 1] = 0; + temp[n - 1 + CONFLICT_FREE_OFFSET(n - 1)] = 0; } for (int d = 1; d < n; d *= 2) { offset >>= 1; __syncthreads(); if (thid < d) { + //int ai = offset * (2 * thid + 1) - 1; + //int bi = offset * (2 * thid + 2) - 1; int ai = offset * (2 * thid + 1) - 1; int bi = offset * (2 * thid + 2) - 1; + ai += CONFLICT_FREE_OFFSET(ai); + bi += CONFLICT_FREE_OFFSET(bi); int t = temp[ai]; temp[ai] = temp[bi]; @@ -113,7 +139,10 @@ namespace StreamCompaction { } } __syncthreads(); - g_odata[blockOffset + thid] = temp[thid]; + //g_odata[blockOffset + 2 * thid] = temp[2 * thid]; + //g_odata[blockOffset + 2 * thid + 1] = temp[2 * thid + 1]; + g_odata[blockOffset + ai] = temp[ai + bankOffsetA]; + g_odata[blockOffset + bi] = temp[bi + bankOffsetB]; } __global__ void kernAddOriRoot(int N, int* OriRoot, int* dev_odata) { @@ -331,13 +360,17 @@ namespace StreamCompaction { timer().startGpuTimer(); - kernScanDynamicShared << > > (size, dynamicMemoBlockSize, dev_data, dev_data, ori_root); + //kernScanDynamicShared << > > (size, dynamicMemoBlockSize, dev_data, dev_data, ori_root); + kernScanDynamicShared << > > (dynamicMemoBlockSize, dev_data, dev_data, ori_root); + sharedMemoryPerBlockInBytes = gridDim.x * sizeof(int); // We only do scan of scan ONE time here // Actually, it should be a while loop here // This process should happen until root number we get < blockDim.x - kernScanDynamicShared << < dim3(1), dim3(gridDim.x), sharedMemoryPerBlockInBytes >> > (gridDim.x, gridDim.x, ori_root, ori_root, ori_root); + //kernScanDynamicShared << < dim3(1), dim3(gridDim.x), sharedMemoryPerBlockInBytes >> > (gridDim.x, gridDim.x, ori_root, ori_root, ori_root); + kernScanDynamicShared << < dim3(1), dim3(gridDim.x / 2), sharedMemoryPerBlockInBytes >> > (gridDim.x, ori_root, ori_root, ori_root); + kernAddOriRoot << > > (size, ori_root, dev_data); timer().endGpuTimer(); @@ -407,13 +440,15 @@ namespace StreamCompaction { checkCUDAError("cudaMemcpy failed!"); // Step 2 : exclusive scan indices - kernScanDynamicShared << > > (size, blockDim.x, indices, indices, ori_root); + //kernScanDynamicShared << > > (size, blockDim.x, indices, indices, ori_root); + kernScanDynamicShared << > > (blockDim.x, indices, indices, ori_root); sharedMemoryPerBlockInBytes = gridDim.x * sizeof(int); // We only do scan of scan ONE time here // Actually, it should be a while loop here // This process should happen until root number we get < blockDim.x - kernScanDynamicShared << < dim3(1), dim3(gridDim.x), sharedMemoryPerBlockInBytes >> > (scan_gridDim.x, scan_gridDim.x, ori_root, ori_root, ori_root); + //kernScanDynamicShared << < dim3(1), dim3(gridDim.x), sharedMemoryPerBlockInBytes >> > (scan_gridDim.x, scan_gridDim.x, ori_root, ori_root, ori_root); + kernScanDynamicShared << < dim3(1), dim3(gridDim.x / 2), sharedMemoryPerBlockInBytes >> > (scan_gridDim.x, ori_root, ori_root, ori_root); kernAddOriRoot << > > (size, ori_root, indices);