From e4944ab55877847cf9077a8049acd12c6581c8f8 Mon Sep 17 00:00:00 2001 From: Rudraksha20 Date: Sat, 16 Sep 2017 10:43:55 -0400 Subject: [PATCH 1/7] CPU Implementation Complete --- stream_compaction/common.h | 196 ++++++++++++++++----------------- stream_compaction/cpu.cu | 84 ++++++++++++-- stream_compaction/cpu.h | 6 + stream_compaction/efficient.cu | 10 +- stream_compaction/naive.cu | 10 +- stream_compaction/thrust.cu | 10 +- 6 files changed, 193 insertions(+), 123 deletions(-) diff --git a/stream_compaction/common.h b/stream_compaction/common.h index 55f1b38..8014d1a 100644 --- a/stream_compaction/common.h +++ b/stream_compaction/common.h @@ -1,14 +1,14 @@ #pragma once -#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__) @@ -37,96 +37,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..b660d1f 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; } /** @@ -20,9 +20,19 @@ namespace StreamCompaction { void scan(int n, int *odata, const int *idata) { timer().startCpuTimer(); // TODO + // Exclusive scan, first element is 0 + scanExclusivePrefixSum(n, odata, idata); timer().endCpuTimer(); } + // Scan implementation to avoid the CPU timer error + void scanExclusivePrefixSum(int n, int *odata, const int *idata) { + odata[0] = 0; + for (int i = 1; i < n; ++i) { + odata[i] = odata[i - 1] + idata[i - 1]; + } + } + /** * CPU stream compaction without using the scan function. * @@ -31,8 +41,15 @@ namespace StreamCompaction { int compactWithoutScan(int n, int *odata, const int *idata) { timer().startCpuTimer(); // TODO + int count = 0; + for (int i = 0; i < n; ++i) { + if (idata[i] != 0) { + odata[count] = idata[i]; + count++; + } + } timer().endCpuTimer(); - return -1; + return count; } /** @@ -43,8 +60,55 @@ namespace StreamCompaction { int compactWithScan(int n, int *odata, const int *idata) { timer().startCpuTimer(); // TODO - timer().endCpuTimer(); - return -1; + int count = 0; + int *mappedArray = new int[n]; + int *scannedArray = new int[n]; + + // Map the data + map(n, mappedArray, idata); + + // Scan the mapped data + scanExclusivePrefixSum(n, scannedArray, mappedArray); + + // Scatter + count = scatter(n, mappedArray, scannedArray, idata, odata); + + timer().endCpuTimer(); + return count; } - } + + /** + * CPU stream compaction part: Mapping + * + * @based on the defined rules (here we map non zero values) assigns 1 or 0 for a given element in the idata array. + */ + void map(int n, int *mapped, const int *idata) { + for (int i = 0; i < n; ++i) { + if (idata[i] != 0) { + mapped[i] = 1; + } + else { + mapped[i] = 0; + } + } + } + + /** + * CPU stream compaction part: Scatter + * + * @scatters the input elements to the output vector using the addresses generated by the scan. + * returns the number of elements remaining after the scan. + */ + int scatter(int n, int *mapped, int *scanned, const int *idata, int *odata) { + int count = 0; + for (int i = 0; i < n; ++i) { + if (mapped[i] == 1) { + odata[scanned[i]] = idata[i]; + count++; + } + } + return count; + } + + } } diff --git a/stream_compaction/cpu.h b/stream_compaction/cpu.h index 236ce11..fe14ab2 100644 --- a/stream_compaction/cpu.h +++ b/stream_compaction/cpu.h @@ -8,8 +8,14 @@ namespace StreamCompaction { void scan(int n, int *odata, const int *idata); + void scanExclusivePrefixSum(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); + + int scatter(int n, int *mapped, int *scanned, const int *idata, int *odata); + + void map(int n, int *mapped, const int *idata); } } diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu index 36c5ef2..fd1d622 100644 --- a/stream_compaction/efficient.cu +++ b/stream_compaction/efficient.cu @@ -5,11 +5,11 @@ 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; } /** diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu index 9218f8e..dde09d0 100644 --- a/stream_compaction/naive.cu +++ b/stream_compaction/naive.cu @@ -5,11 +5,11 @@ 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__ diff --git a/stream_compaction/thrust.cu b/stream_compaction/thrust.cu index 36b732d..e3b3268 100644 --- a/stream_compaction/thrust.cu +++ b/stream_compaction/thrust.cu @@ -8,11 +8,11 @@ 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. From a0920f2a49dc9f38d8a2a7eda4cce3281b7a0f49 Mon Sep 17 00:00:00 2001 From: Rudraksha20 Date: Sat, 16 Sep 2017 23:47:55 -0400 Subject: [PATCH 2/7] GPU Naive Scan Implemented --- src/main.cpp | 4 +-- stream_compaction/common.h | 1 + stream_compaction/naive.cu | 61 +++++++++++++++++++++++++++++++++++--- 3 files changed, 60 insertions(+), 6 deletions(-) diff --git a/src/main.cpp b/src/main.cpp index 7305641..4f417bd 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -49,14 +49,14 @@ 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, 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(SIZE, c, true); printCmpResult(NPOT, b, c); zeroArray(SIZE, c); diff --git a/stream_compaction/common.h b/stream_compaction/common.h index 8014d1a..4b7142e 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/naive.cu b/stream_compaction/naive.cu index dde09d0..2aca802 100644 --- a/stream_compaction/naive.cu +++ b/stream_compaction/naive.cu @@ -3,6 +3,8 @@ #include "common.h" #include "naive.h" + + namespace StreamCompaction { namespace Naive { using StreamCompaction::Common::PerformanceTimer; @@ -12,14 +14,65 @@ namespace StreamCompaction { return timer; } // TODO: __global__ + __global__ void scan(int N, int power, int *dev_oDataArray, int *dev_iDataArray) { + int index = (blockIdx.x * blockDim.x) + threadIdx.x; + if (index >= N) return; + + dev_oDataArray[index] = (index >= power) ? dev_iDataArray[index - power] + dev_iDataArray[index] : dev_iDataArray[index]; + } + + __global__ void kernExclusiveFromInclusive(int N, int *dev_oDataArray, int *dev_iDataArray) { + int index = (blockIdx.x * blockDim.x) + threadIdx.x; + if (index >= N) return; + dev_oDataArray[index] = (index == 0) ? 0 : dev_iDataArray[index - 1]; + } /** * 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(); + // Defining the configuration of the kernel + dim3 fullBlocksPerGrid((n + blockSize - 1) / blockSize); + dim3 threadsPerBlock(blockSize); + + int size = n * sizeof(int); + + // Creating array buffers on the device memory + int *dev_oDataArray, *dev_iDataArray; + cudaMalloc((void**)&dev_oDataArray, size); + checkCUDAError("cudaMalloc dev_oDataArray failed!"); + cudaMalloc((void**)&dev_iDataArray, size); + checkCUDAError("cudaMalloc dev_iDataArray failed!"); + + // Copying array buffers from Host to Device + cudaMemcpy(dev_iDataArray, idata, size, cudaMemcpyHostToDevice); + checkCUDAError("cudaMemcpy dev_iDataArray failed!"); + + //cudaMemcpy(dev_oDataArray, odata, size, cudaMemcpyHostToDevice); + //checkCUDAError("cudaMemcpy dev_oDataArray failed!"); + + timer().startGpuTimer(); + // TODO + int dimension = ilog2ceil(n); + for (int d = 1; d <= dimension; ++d) { + // Power of 2^(d-1) + int power = 1 << (d - 1); + scan <<>> (n, power, dev_oDataArray, dev_iDataArray); + checkCUDAError("scan kernel failed!"); + + std::swap(dev_oDataArray, dev_iDataArray); + } + // Convert the output data array from inclusve to exclusive + kernExclusiveFromInclusive << > > (n, dev_oDataArray, dev_iDataArray); + timer().endGpuTimer(); + + //Copying array buffers from Device to Host + cudaMemcpy(odata, dev_oDataArray, size, cudaMemcpyDeviceToHost); + checkCUDAError("cudaMemcpy odata failed!"); + + // Freeing the device memory + cudaFree(dev_oDataArray); + cudaFree(dev_iDataArray); } - } + } } From 690ac226a5be056c05e0625a3728a79cd3119391 Mon Sep 17 00:00:00 2001 From: Rudraksha20 Date: Sun, 17 Sep 2017 17:03:47 -0400 Subject: [PATCH 3/7] GPU Efficient Scan and Compact Implemented --- src/main.cpp | 14 +-- stream_compaction/common.cu | 24 ++++- stream_compaction/cpu.cu | 35 +++++-- stream_compaction/efficient.cu | 183 +++++++++++++++++++++++++++++++-- stream_compaction/efficient.h | 2 + stream_compaction/naive.cu | 49 +++++---- 6 files changed, 256 insertions(+), 51 deletions(-) diff --git a/src/main.cpp b/src/main.cpp index 4f417bd..1cc633c 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -13,7 +13,7 @@ #include #include "testing_helpers.hpp" -const int SIZE = 1 << 8; // 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]; @@ -63,28 +63,28 @@ int main(int argc, char* argv[]) { 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"); @@ -129,14 +129,14 @@ 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); 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..0a0731d 100644 --- a/stream_compaction/common.cu +++ b/stream_compaction/common.cu @@ -22,18 +22,32 @@ 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) { - // TODO - } + + __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) ? 1 : 0; + + } /** * 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, 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/cpu.cu b/stream_compaction/cpu.cu index b660d1f..27f9896 100644 --- a/stream_compaction/cpu.cu +++ b/stream_compaction/cpu.cu @@ -17,20 +17,25 @@ 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 scan(int n, int *odata, const int *idata) { - timer().startCpuTimer(); + + void scan(int n, int *odata, const int *idata) { + + timer().startCpuTimer(); // TODO // Exclusive scan, first element is 0 scanExclusivePrefixSum(n, odata, idata); timer().endCpuTimer(); - } + + } // Scan implementation to avoid the CPU timer error void scanExclusivePrefixSum(int n, int *odata, const int *idata) { + odata[0] = 0; for (int i = 1; i < n; ++i) { odata[i] = odata[i - 1] + idata[i - 1]; } + } /** @@ -38,8 +43,10 @@ namespace StreamCompaction { * * @returns the number of elements remaining after compaction. */ - int compactWithoutScan(int n, int *odata, const int *idata) { - timer().startCpuTimer(); + + int compactWithoutScan(int n, int *odata, const int *idata) { + + timer().startCpuTimer(); // TODO int count = 0; for (int i = 0; i < n; ++i) { @@ -50,15 +57,18 @@ namespace StreamCompaction { } timer().endCpuTimer(); return count; - } + + } /** * CPU stream compaction using scan and scatter, like the parallel version. * * @returns the number of elements remaining after compaction. */ - int compactWithScan(int n, int *odata, const int *idata) { - timer().startCpuTimer(); + + int compactWithScan(int n, int *odata, const int *idata) { + + timer().startCpuTimer(); // TODO int count = 0; int *mappedArray = new int[n]; @@ -75,14 +85,17 @@ namespace StreamCompaction { timer().endCpuTimer(); return count; - } + + } /** * CPU stream compaction part: Mapping * * @based on the defined rules (here we map non zero values) assigns 1 or 0 for a given element in the idata array. */ + void map(int n, int *mapped, const int *idata) { + for (int i = 0; i < n; ++i) { if (idata[i] != 0) { mapped[i] = 1; @@ -91,6 +104,7 @@ namespace StreamCompaction { mapped[i] = 0; } } + } /** @@ -99,7 +113,9 @@ namespace StreamCompaction { * @scatters the input elements to the output vector using the addresses generated by the scan. * returns the number of elements remaining after the scan. */ + int scatter(int n, int *mapped, int *scanned, const int *idata, int *odata) { + int count = 0; for (int i = 0; i < n; ++i) { if (mapped[i] == 1) { @@ -111,4 +127,5 @@ namespace StreamCompaction { } } + } diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu index fd1d622..c633eca 100644 --- a/stream_compaction/efficient.cu +++ b/stream_compaction/efficient.cu @@ -11,15 +11,105 @@ namespace StreamCompaction { static PerformanceTimer timer; return timer; } + + void __global__ kernScanUpSweep (const int N, const int powerv1, const int powerv2, int *dev_oDataArray) { + + int index = (blockIdx.x * blockDim.x) + threadIdx.x; + if (index >= N) return; + + if (index % powerv1 != powerv1 - 1) return; + dev_oDataArray[index] += dev_oDataArray[index - powerv2]; + + // After UpSweep is over the last value in the array is given value 0 which will be useful in the DownSweep step + if (index == N - 1) { + dev_oDataArray[index] = 0; + } + + } + + void __global__ kernScanDownSweep (const int N, const int powerv1, const int powerv2, int *dev_oDataArray) { + + int index = (blockIdx.x * blockDim.x) + threadIdx.x; + if (index >= N) return; + + if (index % powerv1 != powerv1 - 1) return; + int temp = dev_oDataArray[index - powerv2]; + dev_oDataArray[index - powerv2] = dev_oDataArray[index]; + dev_oDataArray[index] += temp; + + } + + void __global__ kernPaddArrayWithZero(const int N, const int paddedArrayLength, int *dev_oDataArray) { + + int index = (blockIdx.x * blockDim.x) + threadIdx.x; + if (index < N || index >= paddedArrayLength) return; + + dev_oDataArray[index] = 0; + + } + + void scanExcusivePrefixSum(int N, int dimension, dim3 fullBlocksPerGrid, dim3 threadsPerBlock, int *dev_oDataArray) { + + // Up Sweep Scan + int powerv1, powerv2; + for (int d = 0; d < dimension; ++d) { + powerv1 = 1 << (d + 1); + powerv2 = 1 << d; + kernScanUpSweep << > > (N, powerv1, powerv2, dev_oDataArray); + } + + // Down Sweep Scans + for (int i = dimension - 1; i >= 0; --i) { + powerv1 = 1 << (i + 1); + powerv2 = 1 << i; + kernScanDownSweep << > > (N, powerv1, powerv2, dev_oDataArray); + } + + } /** * Performs prefix-sum (aka scan) on idata, storing the result into odata. */ - void scan(int n, int *odata, const int *idata) { + + void scan(int n, int *odata, const int *idata) { + + // Defining the configuration of the kernel + int dimension = ilog2ceil(n); + int paddedArrayLength = 1 << (dimension); + int paddedArraySize = paddedArrayLength * sizeof(int); + dim3 fullBlocksPerGrid((paddedArrayLength + blockSize - 1) / blockSize); + dim3 threadsPerBlock(blockSize); + int size = n * sizeof(int); + + // Creating array buffers on the device memory + int *dev_oDataArray; + cudaMalloc((void**)&dev_oDataArray, paddedArraySize); + checkCUDAError("cudaMalloc for dev_oDataArray failed!"); + + // Copying array buffers (Host to Device) + cudaMemcpy(dev_oDataArray, idata, size, cudaMemcpyHostToDevice); + checkCUDAError("cudaMemcpy into dev_oDataArray failed!"); + + // For the extra space in the padded array fill it with 0 + kernPaddArrayWithZero <<>> (n, paddedArrayLength, dev_oDataArray); + timer().startGpuTimer(); - // TODO - timer().endGpuTimer(); - } + + // TODO + scanExcusivePrefixSum(paddedArrayLength, dimension, fullBlocksPerGrid, threadsPerBlock, dev_oDataArray); + checkCUDAError("scanExcusivePrefixSum failed!"); + + timer().endGpuTimer(); + + //Copying array buffers (Device to Host) + cudaMemcpy(odata, dev_oDataArray, size, cudaMemcpyDeviceToHost); + checkCUDAError("cudaMemcpy into odata failed!"); + + // Freeing the data buffer stored in device memory + cudaFree(dev_oDataArray); + checkCUDAError("cudaFree on dev_oDataArray failed!"); + + } /** * Performs stream compaction on idata, storing the result into odata. @@ -30,11 +120,82 @@ 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(); - return -1; - } - } + + int compact(int n, int *odata, const int *idata) { + + // Defining the configuration of the kernel + int dimension = ilog2ceil(n); + int paddedArrayLength = 1 << (dimension); + int paddedArraySize = paddedArrayLength * sizeof(int); + dim3 fullBlocksPerGridPadded((paddedArrayLength + blockSize - 1) / blockSize); + dim3 threadsPerBlock(blockSize); + int size = n * sizeof(int); + int fullBlocksPerGrid((n + blockSize - 1) / blockSize); + + // Creating buffers on the device memory + int *dev_oScanDataArray; + cudaMalloc((void**)&dev_oScanDataArray, paddedArraySize); + checkCUDAError("cudaMalloc for dev_oScanDataArray failed!"); + + int *dev_oData; + cudaMalloc((void**)&dev_oData, size); + checkCUDAError("cudaMalloc for dev_oData failed!"); + + int *dev_iData; + cudaMalloc((void**)&dev_iData, size); + checkCUDAError("cudaMalloc for dev_iData failed!"); + + int *dev_boolIndexArray; + cudaMalloc((void**)&dev_boolIndexArray, size); + checkCUDAError("cudaMalloc for dev_boolIndexArray failed!"); + + // Copying array buffers idata to dev_iData (Host to Device) + cudaMemcpy(dev_iData, idata, size, cudaMemcpyHostToDevice); + checkCUDAError("cudaMemcpy into dev_iData failed!"); + + // Initialize the bool array: For each index fill 1 in dev_boolIndexArray[index] if corrosponding value in dev_iData is non-zero otherwise fill 0 + StreamCompaction::Common::kernMapToBoolean <<>> (n, dev_boolIndexArray, dev_iData); + checkCUDAError("kernMapToBoolean failed!"); + + // Copy buffer dev_boolIndexArray to buffer dev_oScanDataArray (Device to Device) + cudaMemcpy(dev_oScanDataArray, dev_boolIndexArray, size, cudaMemcpyDeviceToDevice); + checkCUDAError("cudaMemcpy into dev_oScanDataArray failed!"); + + // Padd the dev_oScanDataArray with zero's at the end + kernPaddArrayWithZero << > > (n, paddedArrayLength, dev_oScanDataArray); + checkCUDAError("kernPaddArrayWithZero failed!"); + + timer().startGpuTimer(); + + // TODO + scanExcusivePrefixSum(paddedArrayLength, dimension, fullBlocksPerGridPadded, threadsPerBlock, dev_oScanDataArray); + checkCUDAError("scanExcusivePrefixSum failed!"); + StreamCompaction::Common::kernScatter << > > (n, dev_oData, dev_iData, dev_boolIndexArray, dev_oScanDataArray); + checkCUDAError("kernScatter failed!"); + + timer().endGpuTimer(); + + // Copying the data from dev_oData to odata (Device To Host) + cudaMemcpy(odata, dev_oData, size, cudaMemcpyDeviceToHost); + checkCUDAError("cudaMemcpy into odata failed!"); + + // Getting the size of the number of elements that were filled (Device To Host) + int valueAtIndexArrayEnd, valueAtBoolArrayEnd, totalSize; + cudaMemcpy(&valueAtIndexArrayEnd, dev_oScanDataArray + n - 1, sizeof(int), cudaMemcpyDeviceToHost); + cudaMemcpy(&valueAtBoolArrayEnd, dev_boolIndexArray + n - 1, sizeof(int), cudaMemcpyDeviceToHost); + totalSize = valueAtBoolArrayEnd + valueAtIndexArrayEnd; + + // Freeing Cuda Memory + cudaFree(dev_boolIndexArray); + cudaFree(dev_iData); + cudaFree(dev_oData); + cudaFree(dev_oScanDataArray); + checkCUDAError("cudaFree failed!"); + + return totalSize; + + } + + } + } diff --git a/stream_compaction/efficient.h b/stream_compaction/efficient.h index 803cb4f..da397a2 100644 --- a/stream_compaction/efficient.h +++ b/stream_compaction/efficient.h @@ -9,5 +9,7 @@ namespace StreamCompaction { void scan(int n, int *odata, const int *idata); int compact(int n, int *odata, const int *idata); + + void scanExcusivePrefixSum(int N, int dimension, dim3 fullBlocksPerGrid, dim3 threadsPerBlock, int *dev_oDataArray); } } diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu index 2aca802..fdbd927 100644 --- a/stream_compaction/naive.cu +++ b/stream_compaction/naive.cu @@ -13,24 +13,32 @@ namespace StreamCompaction { static PerformanceTimer timer; return timer; } - // TODO: __global__ + + // TODO: __global__ __global__ void scan(int N, int power, int *dev_oDataArray, int *dev_iDataArray) { + int index = (blockIdx.x * blockDim.x) + threadIdx.x; if (index >= N) return; dev_oDataArray[index] = (index >= power) ? dev_iDataArray[index - power] + dev_iDataArray[index] : dev_iDataArray[index]; + } __global__ void kernExclusiveFromInclusive(int N, int *dev_oDataArray, int *dev_iDataArray) { + int index = (blockIdx.x * blockDim.x) + threadIdx.x; if (index >= N) return; dev_oDataArray[index] = (index == 0) ? 0 : dev_iDataArray[index - 1]; + } - /** + + /** * Performs prefix-sum (aka scan) on idata, storing the result into odata. */ - void scan(int n, int *odata, const int *idata) { + + void scan(int n, int *odata, const int *idata) { + // Defining the configuration of the kernel dim3 fullBlocksPerGrid((n + blockSize - 1) / blockSize); dim3 threadsPerBlock(blockSize); @@ -48,22 +56,22 @@ namespace StreamCompaction { cudaMemcpy(dev_iDataArray, idata, size, cudaMemcpyHostToDevice); checkCUDAError("cudaMemcpy dev_iDataArray failed!"); - //cudaMemcpy(dev_oDataArray, odata, size, cudaMemcpyHostToDevice); - //checkCUDAError("cudaMemcpy dev_oDataArray failed!"); - timer().startGpuTimer(); - // TODO - int dimension = ilog2ceil(n); - for (int d = 1; d <= dimension; ++d) { - // Power of 2^(d-1) - int power = 1 << (d - 1); - scan <<>> (n, power, dev_oDataArray, dev_iDataArray); - checkCUDAError("scan kernel failed!"); - - std::swap(dev_oDataArray, dev_iDataArray); - } - // Convert the output data array from inclusve to exclusive - kernExclusiveFromInclusive << > > (n, dev_oDataArray, dev_iDataArray); + + // TODO + int dimension = ilog2ceil(n); + for (int d = 1; d <= dimension; ++d) { + // Power of 2^(d-1) + int power = 1 << (d - 1); + scan <<>> (n, power, dev_oDataArray, dev_iDataArray); + checkCUDAError("scan kernel failed!"); + + std::swap(dev_oDataArray, dev_iDataArray); + } + + // Convert the output data array from inclusve to exclusive + kernExclusiveFromInclusive << > > (n, dev_oDataArray, dev_iDataArray); + timer().endGpuTimer(); //Copying array buffers from Device to Host @@ -73,6 +81,9 @@ namespace StreamCompaction { // Freeing the device memory cudaFree(dev_oDataArray); cudaFree(dev_iDataArray); - } + + } + } + } From 8a45196b580970fa312df9163ebaa07b08b00643 Mon Sep 17 00:00:00 2001 From: Rudraksha20 Date: Sun, 17 Sep 2017 18:10:53 -0400 Subject: [PATCH 4/7] Thrust Scan Implemented --- stream_compaction/thrust.cu | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/stream_compaction/thrust.cu b/stream_compaction/thrust.cu index e3b3268..54d1c60 100644 --- a/stream_compaction/thrust.cu +++ b/stream_compaction/thrust.cu @@ -14,15 +14,28 @@ 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) { - timer().startGpuTimer(); + + void scan(int n, int *odata, const int *idata) { + + int size = n * sizeof(int); + + // Wrap device buffers into thrust pointers + thrust::device_vector iThrustVector(idata, idata + n); + thrust::device_vector oThrustVector(odata, odata + n); + + 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(iThrustVector.begin(), iThrustVector.end(), oThrustVector.begin()); timer().endGpuTimer(); - } - } + + thrust::copy(oThrustVector.begin(), oThrustVector.end(), odata); + } + + } + } From eea2048a0472470ac0b1f1ee48dcd693237b84f0 Mon Sep 17 00:00:00 2001 From: Rudraksha20 Date: Tue, 19 Sep 2017 21:44:27 -0400 Subject: [PATCH 5/7] Readme.md --- README.md | 138 ++++++++++++++++++++++++- img/{figure-39-4.jpg => DownSweep.jpg} | Bin img/Scatter.PNG | Bin 0 -> 14705 bytes img/Table.PNG | Bin 0 -> 14113 bytes img/TableChart.png | Bin 0 -> 20052 bytes img/UpSweep.PNG | Bin 0 -> 98886 bytes src/main.cpp | 2 +- 7 files changed, 134 insertions(+), 6 deletions(-) rename img/{figure-39-4.jpg => DownSweep.jpg} (100%) create mode 100644 img/Scatter.PNG create mode 100644 img/Table.PNG create mode 100644 img/TableChart.png create mode 100644 img/UpSweep.PNG diff --git a/README.md b/README.md index b71c458..20a391d 100644 --- a/README.md +++ b/README.md @@ -3,11 +3,139 @@ 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) +* Rudraksha D. Shah +* Tested on: Windows 10, i7-7700HQ @ 2.80GHz 16GB, GTX 1050 4096MB (Personal Computer) -### (TODO: Your README) -Include analysis, etc. (Remember, this is public, so don't put -anything here that you don't want to share with the world.) +## Overview +------------------- + +__Scan:__ In scan we iterates through an input array and based on a given operator (which could be any mathematical operator) produce a new array as output where each value at a given index `i` in the output array is a result of performing the operator on every preceeding value. + +There are two types of scan: +- Inclusive Scan: The operator is applied on every preceeding value and the value at the index `i` as well to produce the output. + +- Exclusive Scan: The operator is applied on every preceeding value excluding the value at the index `i` to produce the output. + +I implemented the scan algorithm on the CPU and the GPU. The scan operator is `+` (addition) so we will be performing inclusive and exclusive sum. + +- CPU: The CPU implementation of the scan is straightforward the scan iteration is a simple for loop that goes through every element and keeps the accumulated sum of all the previous iterations in a variable adding it to each new element and placing it in the second array. + + The algorithm performs `N` additions and has a time complexity of `O(n)`, where N,n - No of elements in the array. + +- GPU Naive: The Naive GPU implentation is based on the scan algorithm presented by Hillis and Steele [1986](http://www.umiacs.umd.edu/~ramani/cmsc828e_gpusci/ScanTalk.pdf). The figure below shows the iteration steps for the algorythm. We iterate over each element and take the addition of the next element basd on the depth where with each depth we skip 2^depth values and add. + + The drawback of this method is that it performs `n*log(n)` addition operations as compared to `N` operations in case of the CPU implementation. + + ![Naive GPU Scan](img/figure-39-2.jpg) + +- GPU Work-Efficient: This algorithm performs with the efficiency of the secquential algorithm on the CPU with only `N` addition operations. This algorithm is based on the one presented by Blelloch [1990](https://www.mimuw.edu.pl/~ps209291/kgkp/slides/scan.pdf). For this method we will create a psudo balanced tree structure inplace in the array we are performing the scan on. For an array of size `n` the number of levels will be `log(n)` and for each level `l` there will be `2^l` nodes. If we perform one addition per node we will perform a total of `n` additions making the complexity of this algorithm as `O(n)`. + + There are essentially two steps in this algorithm: + - Up-Sweep or parallel reduction: During this step we start from the leaf nodes i.e. the original array and travel up the tree calculating the partial sums at each level. The root node contains the sum of all the elements of the array. + + ![Up-Sweep](img/UpSweep.PNG) + + - Down-Sweep: During this step we start from the root node and replace it with `0`. For each level each node's current value is stored in the left child and the addition of it's value and the former left child's value is placed in the current node's right child. This produces an exclusive sum scan array. + + ![Down Sweep](img/DownSweep.jpg) + +- Thrust: Thrust is a librray that poduces the scan output for any input array that is wrapped in the `thrust::Device_Vector` using the function `thrust::exclusive_scan(first, last, result)`. + +__Scatter:__ This is the final process for string compaction. In the current implementation we want to remove the elements that are `0` from the input array. For this we produce a boolean index array where for each position we store either `0` or `1` based on the value at that position is non-zero or not. We perform scan on this boolean indexed array and use the scanned result array to determine the position/index of the non-zero elements to be placed in the new array. + +![Scatter](img/Scatter.PNG) + + +#### Performance Analysis +---------------------------- + +For the performance analysis I have used a block size of 128 and logged the execution times for the scan with incrementing array sizes. + +* Table: + + ![Table](img/Table.PNG) + +* Chart: + + ![Performance Chart](img/TableChart.PNG) + + +- Analysis: + + From the performance data and the chart we can see that through all the implementtaions CPU implementation is the fastest. This is to be expected as the CPU implementation even though is synchronous and serial the operation is highly sequential which leads to very low cache misses in the RAM as well as the CPU is highly optimised for such sequential memory fuctions. + + On the other hand the GPU Naive implementation performs `n*log(n)` more computations as compared to the CPU implementation and is expectantly slow compared to the CPU despite being massively parallel. Similarly for the GPU Work-Efficient implemetation, even though it performs the same number of additions as the CPU it is also slower than the CPU version. + + Bottle Neck: The primary bottle neck for the GPU implementation is global memory access. For each thread is relatively light for each thread we do a minimum of two memory calls to the global memory to fetch the two values to be added. The second bottle neck I think is due to the inefficient use of the GPU threads. For each subsequent level the number of threads working per wrap reduces. These inactive threads stay there doing nothing and utilizing the resources of the GPU. Thus the overhead of these threads also slows down the GPU implementation. + + Unexpected Result: Wait... in the GPU implementation the efficient implementation should be faster as compared to the inefficient implementation!!! But for my analysis I find that the GPU Work-Efficient implementation is nearly as fast as the inefficient implementation and even slower as the number of elements in the array increases. This is a very confusing result to me that i am not able to explain. I tried debugging my code and going through it to make sure I was not doning anything wrong but I could not find anything. If anyone can explain a probable reason to me I would love to hear it! + + Thrust Implementation: Thrust performed more or less consistantly throughout the increasing array sizes. Over the final array size values `2^20 - 2^22` the speed reduces as expected. The implementation overall was the slpwest of them all for all the array sizes which is rather expected as the library would be doing lot many things that may not be necessary for the scan. A proper analysis would be possible with a more clear understanding of the base code. + +``` + +**************** +** SCAN TESTS ** +**************** + [ 30 31 46 44 34 30 14 45 47 29 37 0 38 ... 48 0 ] +==== cpu scan, power-of-two ==== + elapsed time: 1.67895ms (std::chrono Measured) + [ 0 30 61 107 151 185 215 229 274 321 350 387 387 ... 25684633 25684681 ] +==== cpu scan, non-power-of-two ==== + elapsed time: 1.74022ms (std::chrono Measured) + [ 0 30 61 107 151 185 215 229 274 321 350 387 387 ... 25684565 25684600 ] + passed +==== naive scan, power-of-two ==== + elapsed time: 2.16678ms (CUDA Measured) + [ 0 30 61 107 151 185 215 229 274 321 350 387 387 ... 25684633 25684681 ] + passed +==== naive scan, non-power-of-two ==== + elapsed time: 2.16525ms (CUDA Measured) + [ 0 30 61 107 151 185 215 229 274 321 350 387 387 ... 0 0 ] + passed +==== work-efficient scan, power-of-two ==== + elapsed time: 3.21434ms (CUDA Measured) + [ 0 30 61 107 151 185 215 229 274 321 350 387 387 ... 25684633 25684681 ] + passed +==== work-efficient scan, non-power-of-two ==== + elapsed time: 3.2415ms (CUDA Measured) + [ 0 30 61 107 151 185 215 229 274 321 350 387 387 ... 25684565 25684600 ] + passed +==== thrust scan, power-of-two ==== + elapsed time: 4.51072ms (CUDA Measured) + [ 0 30 61 107 151 185 215 229 274 321 350 387 387 ... 25684633 25684681 ] + passed +==== thrust scan, non-power-of-two ==== + elapsed time: 0.342016ms (CUDA Measured) + [ 0 30 61 107 151 185 215 229 274 321 350 387 387 ... 25684565 25684600 ] + passed + +***************************** +** STREAM COMPACTION TESTS ** +***************************** + [ 1 3 2 3 1 2 0 2 2 3 3 0 3 ... 3 0 ] +==== cpu compact without scan, power-of-two ==== + elapsed time: 2.93525ms (std::chrono Measured) + [ 1 3 2 3 1 2 2 2 3 3 3 3 1 ... 2 3 ] + passed +==== cpu compact without scan, non-power-of-two ==== + elapsed time: 2.90024ms (std::chrono Measured) + [ 1 3 2 3 1 2 2 2 3 3 3 3 1 ... 3 3 ] + passed +==== cpu compact with scan ==== + elapsed time: 10.3574ms (std::chrono Measured) + [ 1 3 2 3 1 2 2 2 3 3 3 3 1 ... 2 3 ] + passed +==== work-efficient compact, power-of-two ==== + elapsed time: 3.39251ms (CUDA Measured) + [ 1 3 2 3 1 2 2 2 3 3 3 3 1 ... 2 3 ] + passed +==== work-efficient compact, non-power-of-two ==== + elapsed time: 3.42634ms (CUDA Measured) + [ 1 3 2 3 1 2 2 2 3 3 3 3 1 ... 3 3 ] + passed + +``` + diff --git a/img/figure-39-4.jpg b/img/DownSweep.jpg similarity index 100% rename from img/figure-39-4.jpg rename to img/DownSweep.jpg diff --git a/img/Scatter.PNG b/img/Scatter.PNG new file mode 100644 index 0000000000000000000000000000000000000000..827d32da197e547bb4977e6c77e03ee4a908813e GIT binary patch literal 14705 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 HTlfDLC!~3U literal 0 HcmV?d00001 diff --git a/img/Table.PNG b/img/Table.PNG new file mode 100644 index 0000000000000000000000000000000000000000..460ec0ec3cb163beba8479a7c72efd7f9335407e GIT binary patch literal 14113 zcmdVB2{hYn_xIcBrh`^nZ7E7yN>yu~r|3jg(4w?zj(IFmgd{p@%_T~RNNb)IMGc{M z4UtBYRuF2)T|*+2lpu`=C%vEZ-0NNMf35RB?{nUD&N^#d;mVTOzg*Y8K70SZdne(R zwfVvQlKXe;*m2O}#x>g=J9hE~^P#;$f}bwelzauhc7koquk5HHNizjc_V`}5y1ZjY zUD|<7k3R&@_dU3A54>Z?p|0PLow(34uN^ydnk=qewvTpQM0ZwR8Vh5PW!2(HMF^wh z;}X)&(cfq4yX6n{>#fcrZ+ktE&odIHcU*G^`5f*O(OYRbasFhlL`06);TxZGAWC)+q~^-dy+c07COyN zAKtsiGy8OHX>_aASp+wGdoAwp<0q&2bLN06zyCI6bs28EhaxJe2HUgivFVQ^YWxFx zfU=KGPalrm1Ki%VlVUD-S+~qiN~h_^)gycN?5Z>WxT<n*Pn~rsQeHc8#r{? ze0y!Zha%q0V8!B=j>U1Sna;FU*lh6FVK*3?xnAA5+B|WJ7S{n=HY7L8MvonSdHVnS zm&uSag$jG9j(B5v+zYT$sm^KRcI;?#WF6%aQH z`A<`yGv%HL{c9h()8qims4LRCq*d=Cx9fd%F^ub{Nr#YIf9xtrdns#}+rdYhu-aHu zUc1%SB&>mn3M6nY{ZH4nuEnp1are8VC{MpGAx{&6QC4wII@FSb9q_%Tr_c7hE!noA zaeHkg&Tjpx-Q<&#(wbRYHSN8j;~l&xA57;)*LqVYuVIWu#91#dvY3mZB1n^6by2VM zlU}4^pUCd*?%KWU$i-A$K8@cn2EeZc<)?<_pP;qzm%Ro%Ip{P(YtR&-b@kSp^&GiV zoko3n(^z%)jlJDFFJtIYTax)5NBrQ*k4^WyTrQz$e_3AUhw7T-u)FZGlO1FNGq)Lj z^{X`d^>4RK-M8`jV~AVNnA^$Ihj+?7V>Va}P^XUdT*OE8)J0x&RpC|CQhS>Bwr`1s z#^vE^t;XOtIZZjWTe?X7e|h*3P&*S<%ULs7sSMj_`C;D6OBrKX)m;>C(CNJdci5MtdYcm|!`$v#BzNkcWb1BEt=kTJBQPnL?CrnS8QXc;`djPk<`k38 z?eDVDCrh@QZj=D z;*nd{BI|p98>wP$^D#iox9ypAEsyK0yVF!znn13G+s)tp$$MrP~Ks;vAH zD5D>Y7r$g<#ib19d6QgGU0AEQ4x!kI>0Kq;@sF5tO9^Eqo%l?TjThz`d^eiwFR@NF z$-uio*OKV9RoAapNWSrRU^nkCq9VUP4pS9trOpQO;yU?x;B2DXWNn`?qqMJTdsY>$ zIU8_v_IeInBS63 z?9sjt9>)vc_JVTnsh=AancYyzs#^#ien3iX%jw(vLgu=TeC(kzir-c`&zRM8_=vaM z3-?Bj+!DGtEqx`Rv#@Xku|rEfc>myzS@P%hUmtqBej9(ePzvqm zm_b0`Lg!3gCGkETt8q=|z=rOwQ(dJao<=hqN>2NC{dpnl&}W`3FP;H>Nu5 zjmyVvz7lV5Kwdwd(9v_>5PxaD8RHhep}XU(`^MN6?Q*3L31902ewMe0F9Yr>6Z^H~ zWzwV^gJT*!wKNiWIbV#wu4Qj$t#Lb)RKZ*CciL8=I`9qR_xs%u%!RcJ-TJ?BPc4TH zHO|GxGi~ZJ3hRw3liQxN-~5h%HS40>!3{^$R&VH0>%_hifNp`?UP?33Qe`Z@n?TX| zX0CNLAa%l~S`inB{9?@C6q~i2DKQe+T-BX|2im#l^0j=Z7n_lfJ*gUe5@bf-@1nNj zHGAqVO6|PQIr9tAwD#(-CCyzWagX-~ZcJ|1`@-EidsYdxJ2L-dKkfP)rf3#K!8}0? z$q%*Pq*(NR)#5|i{B28iu0Xu68tJ?Cc(p2S2}k$#&rQzRwFc1*$mOH4bi&*4MjsJn zpEtb$s1Cx58b@@Ovn3VjzM)f^75im!Hub z(;g0YtXYl##_cC6%7VDLU=qibxSRdx)j<+UygJ&5qN`8Zp6~p8dsw43YXikGR{Fh< zb0ypQW@SF{fBg%(zgOWA6L&zX;WvVRgYoa^{6Apwz~2%1f28f-i2=a%O-|2m_6iu7 z$&A}rO|X(ZqTIK7r0&UnVL`rCBQdjfY|{b*f8@CjIQ7r4(0I%gK91}b`}aV2?V^ZY zP)kt!XW;jg$lALfwfSdc>;nSIKFa6+GvpC3)cF_~e`$SnHFJs}+Kic9a~zUTP;F*p zG?X&@%L_5k57HH!i)V*93NVzSz0+7?f{B;s)l zBcbbxfOd=txx}epx*|B2*;boY`zde;e>Q)Ng-y3Tlx=WEzp)_oHPtt5G1$a^&^r63nd7Fr>&!NzuDn5)&Fo;tjN5yBe%Pn9@6_&%;2R9DQjpG(@lp&hdmT5yxBVdDjMx&wK1 z#HSYPWMWpz-N%Uiym*RzYh5w4rcHE@JU+5mwmi%_!)xUoW|eHca{r;8m|?SWe;~eSc+g|3Hog!j#oHNMYl7|yv0V=Ap>=TAQj7{_T0O0x1OdEflDop#h zYcvpt^p_^661)uwKc%|oqycZ+tvJKe(>KE30SCj=su9#;*%ZhZC&3ozZNEzMuz9sh zK3X)z-zU6aVCILG=IGs-x`{AbO1e>&=izT(l0WPqXnPH_^`2vc3WNpgpLo+XFZT^} z#XyyVo=$Y8V6xo&U?xpd&_^{r&r+=jpKoRQ$)cl34@v%s-oQznl&q9f)CXCSh`3af#b%w9lO#da14T0!;;<@ zFfPS$DzGMn7@$-jx*O?6aDNt!`pXpe*+(ID%*nDHV-!dCkiuxc!9F~vkZI|!wgoL- zUdT28%0Lj3-C;`rYtI^fV`z= zp&;tMvF7-yP=S*!N$J0q8lykGFIX|!btx4zs#mqrnx+3C-VHAm73UJ4P}t*j-q92I zFb{$2)&5mdOQz{G@gvF&j&K7QB|7|@Q<4`BWqdExP%nthWe-hjR_Z`Ah$&7>b=C3< zecwlo*Ci|z)c9`<^7mPpjrB{4eGMtJFx1W6(zDk)fa<<^-1NmAjm=9vb#HGky;)GJ zJF5K&XGN^qZ@^l2s_5@+aUgCEi{Ao2>0>%JQ09ZC|Rx-OzxH*K&jvABLv5pOrH0Jb6R2Eak0XYLJn&Sip%L ztObAw(D!yq^f4Ae?Yq#qa4MnLqrNfg0>!N@{%J(9L3%(M$cmPV$jSy0w-QU$^?U|2 zy7&;aR3Hb_IxE;IooIuE;l2$-t+GvpYw6`>Hhy~7_VGAAh;mPH1$$wvh)S+aj(wzZM{%fKn}t`M;x{o|w$X{bNW?c5kLLI{n9;j! zYZ+y&M>d0uUn3dO+0}UfrJur4u9X>ncFy79X}NQ;fqM{(kefs!D|-Q#WAn5|#k(vB zvm^F5EO!@zDn0$w9KPL}ixp6z%Kzs|hOA5!$=4v#C)29(qGn-z?P%}xew7$!g1}SD zt@W~rprpjhd*P=P5^e4^iHa22npZO7+5}|IWKTX#BV{j{w}!0Tt%l}EF4TL&4beP<|XIr7l-MBBTCigrs7fy}d-U(q@XtZpyR+V>%xEzyt8f^2VOaLJrdP3sc z*VD1R-(lHPe<{cd2)kDIF#Y(%=wVtJK}~&XlQ?Ee$^x-9LRE>%+Fh$Wb9DvX>tpiZ zE%sXb&z6BYxev}S68g(Avbo!N_equXAurEv?V^C^sg^uIJ(D8MfQFN#pouH(591Dg z#FZNH6!P`vf?-YNwF$SNy*GX*B17J}qx7(FkFpXw5yc)hRm%YuL|NsIPmj3b+@FO% z4b(07->gl-_X$60FI7)p-I1OK+kVW!2t)>5UBixihv{(}YK2(3Xd4ih_3ba`EO3pc z(#@dN#;+Z-(t=DnlaL`w3T#uH8!sNu(nqcMt^~1*N4y@6`oP(Gkq|+A7S@LCgn1vm zHiYzPQn!gLAk11#N5`}Jl*=rvD5ZStnlMuknxfHuW(O~Ehpb)=wZ-?p#zm0;pS)CX z*ZlCJvo6Wysbjs}n$Ss`L0n<3$wao!xR9*ATN2%wmd-e+|AQXm?J9i+KeG(P{JH;@ zNJ!8V&X;B2QXgW%3=v7)aE4$E;F&609+DKnYYXlmZR-712xR9S=CVo>pf%&1^xi3UQwA{8gn0z!j;7>@|gC3dpS{gPg}C*^n+yc zS3Bg{JMIp82g+&WXIGxwsTJ(^7!rr3 z8*;K7bX>N}bU9~gCMr?36gz(n{LW}7mKLniJZ$lhbZG3UR)_U4z1cqL@k!7jp3Js4 zs^6Omelmn_wCX(eByXIcNxQ8c3$`YjvdeL&3YCZU$&R6D zK4Z|Je8yG>7MweK8T%jty~=3L@_Dt=(C=}{IOH3(8d1aOu0#-WO?KxTUC{egDxG$x_I4Yc5V^B^~V*H78jc&rcXS@Y(XR3y}IjQQ?>=czDCT-R= zfg7@R13{oFZJz>Gbyv=ak4JWK&`#tm#_FQpc4Vi;V!Sut^Dq30^RDr0fVeBbG;B@%T*9yhjU#L*}iz+Hu1*+(U`2GQSAbHp~;0OCwx zDF8ZpwKUcJV-G$CEA8)65pNu}B=Y)tv(DALrO*Gc`4&z>3k(Obmve7t5Uu1Kuh-(i z4zPm^ZH)o%`R<%jOBK6AcWS@gRjdUt!VD&CVv>`c*tCt_5`*thoF-Io(}OG_<7q<1 z6{)^g5MOjOCr7?x!=y&_wbujDKlShDi&a|7 zkXKJSm40`*CWq|XM++6IA06vewLgvu_VHOk@rShUrdAhJkRW;S)Px|@Y9D)f_7{TS z_V}Wd*~;Bm>zcD|(*7{DlH*?AYjxrL6yw>aLc&$=-NUGA0 z83ssl`g8E5E-)FAOez!8$E-=0w9n@~U=w)rLYY!FlMZY|a-M=-sMz#p?&(5p-9rP7 z0)EVCw3b@OFtqYk_0zuoGGG!z?<=;-jzaBa&%WL?V8&Q~G-zpO0xJH|1q2iM|1C)> zq~MRglira}R$AvY zYNW9RX+=W?9KR+E(8D}YBQ{Q}appX}33 z%9G-PFO9xzFUhwkqf2BCTT}uP@NgHgo7P*~P8HP%9$$J?6Jk z!C7yov;cWj7zie9DC$-H8Pj+av&L=clo#L^ejz`qnZap2a_Q^?RtQVTY8Cs?NDP!2 zRG)(P!{qyaa@40~u2tBbt$;f+&iKf=}ZASif9kC3x z=XT)Z#9{sIy~g{+&||HSu|LUtVXdrIlZNfnW;l)t>c#8!O|Q?gjOnfRqos^A&TJjQ z_EcN=gyFm(Uyj8rt)0#3g5&!V?s0IKx$QHu1QKGi}&dfP7FapvLBA&`e{oPubr}#VJ~wt<21L!Di!1eV@8; zR<@&)W4L!yZU34Kq5B3o;RyD@2h1(&n}-}2E>jsBpWoA{pPn@*Pv_{c#>(#-l*~*R z!XF8Q6iwK^kb$y=w5Ti6lwL=>deqaLLXJ`TFOE z;sMOtIrb1g#`T3ml+tk`L}RQCvRD^EqEy%NwZ7S$mjxeMYBy)f-tYa+U(9RbRd`RG zZfa?aY!@hKn*706B?a%!thYQ#_4Uj*gB0i}6i%3l=`z@p(EF}8u}@w-pK(?`{v$>X zj*@wb9|HnX7M&5Ay&z-<`o5BCW6u3xT^I>5WB(+aie6CTXY5vuTSyLH>e+1{C*7$q zP?yp=i@}DaF;1V$F`8qoil_J)nfuvmDz`8h7S`*--8KW$BQQIU*WRHt$USYt24X7D zl=vfB0RpKxi5ffW3)IPU$k!el_|c>_+3a_Nl_9FNv^%3TGwo7It#>oZTay}ladCI< zBu5WDuc(ZD6t2do*TqbPCAS>FOCkV{-;CncU;ox&E7XCupqn=N;b%+eZzUZ;6Rc8%^AMEGhRwg3=ZdA-r5;gtL$u4ZY?-FayR1wO!ETF1 zfjhIA2rX4(A55|5aE@H;ygi`2|C?mvk~vX-KBuEO#Gx`I#eL(Jy97DLKLW{Xei07OOS1qtuwCNJEgh zCvfYNZ&jQ8vn($<_i{chV=K2g!Y78nH?ZCma{dS=80UD*QK5?Wp|*eGwA&WT%T1BVr`(k)Js z`RM85uVr-a-oeIm>0JUFQjYxb4=nC*nFM8n;rvQ$X+db7}wu8Ra^s>aR2gT3@JTXlvKwKYdE%f`)m0bNq! z1uVd&aqct@XU#$~Q+>nTT+T0dG>IRfL^Vf=We<1l_RkR>c31fNAtZ#@xU%xpL^`S{ zu&g>JHFCbUKC{t1;N>;yExnP2(HL0lO^ucsW*pF>@}vHanzHY}A4QQ;!vzjoaXQtU z1ApqMHdL)s$IMRl<)-@9XUJ9lmYI<@6F=O3FImMleu+?D%9l}-n>fwU zS8|TkW&`Rl`qh>owGgfPjJQK-hRQDFm#v0*c;$sB-CSG!0ubeHd$spQ%c1?`Oo19S zP>&VzJ(M?ifV_f$z;zh21wJ%SZJ^tdD&sm`o8`8FoN03i6}HrX04Y&B@;r`)etn=2 zezc)UyBQ0_;ObH?iCcYBNS&?2iIbOsLb>qU%Gn3umU0b*>kxi?Z`+GQzAIU+YP=(a zPd7-R)!nwC1pVT*Zf;G!yOJuu1EY^7nR#YQwNh8J@haKqD~B1iddg;`pBni~jsfSt;<=(HECs6*VnF3`ER#CcIuJ%8}88ut5?!?ui{>wKG;feZ?;1 zJ7?INxadDD93EXX*ls$py0Wo$N}%ZMw8CVH86FqDJ|Qx_AgxfIUfS+2=XX32vu$y( zYigI@gY>a^_1Q)=`><}Jg{FC?ohnsdcg={C>*&*zWtolfQtL62?cdPPdy#||LcPGe{T`LW<`U^w!p=Iz2sQ2 zsx@=Iw3SzKtSv{Qo};2H2vKcgVXHj+BJWcyOM(?FRj3YhVnH~AIgELizmA=yDsLW> zo zdM0DDMCaS-$%Q&gHqO@UIwSOWW!Edok&?4xHiFtB2ha6~ zo}CLu4HDbFej@wdh{*4!)LZdrfBx9f13J6nk=3kG&aRpbwOM0ZFE@zDJh!;IdDvj~ z&8Yd&-J`lcGzg~@hs>0tV(W}=X5b%MZG(2r>Ym;C2oo|!RIljOgye+Z+{SKO*q*NfGtyz@p7~$va}8M^3h|mRh;GkQ}Rg!tbUl1EM04Nw*zd zaF*2H^m3(ycL?bm49jo-kwT>EKC+Qlu<#DCeoN=;C{)9n&ZiWn76;CNHou`6H=@S* z5oWA{_GOr6tqjHjG8xk;R9^1-cE6Py{RKOl)7VlOe$Sq*ylKgf*>a-V=&Ry*qFc^& zqQb%#jv_9Q^IkxIC@2IrW{;M^%@;nejZBNVx!9!y(r$OficdJ=@t=)Xc7MqOAZjP| z>N|dDuy_tlxSJXfBTDx3te!WgrW2~z$RKoHzQzE~wyM$-ZFBkWzc+=C9afp>tt$NRQV|SB z>GYKzFkaIs$NxTpG0<@)onMFUg}ZKW*z9W35$g^8rNH1u%x0g?5I0cytl#~9rzHG&)ZHr4yzr9R2A=f;=TcH_j|3~^TA?(9nGwS*$ zOj`C9cVI{S~p#b66x2E8S~MPtMqs!kFd-& zv6-JwgIz?p=_uCTcDd}UuGITg(;mHTe{F56SU+)B-*a`Fn1E;A(qqRUqcZn(Kcq_% zC9)=qjdA_EInuM=+&6eH5zeN8dPn-Fv?a;%x+SWZP;$kYq572W;ERLM z4yfXXnJc$3MrDVc{s_=piC!65HfXb+-@Np#Ti!C%l2}H2d9*YtN`i78O)Sc0oSj+^ z`HbO|x8D%hW^$Uzxd{~Tg@?QwrNS4|)Crq!ibszM6JOHtS~Xs}w=(e4IdDlC_oR}`&KH`|H?%t-Q$n(*wBr!Tq)VM0q3;g(TBE-(60uFvu!C^ytT_93iOK* z)extLCU{*vR3`K?2_#~x-6@0!iR0zve8EzUaTPT47~@+Ehvfj|7If35B+P~`mt*vd z3D&%@L!x!h7o|5J1;??K*$`b|1BnX14=f0{#YI8}7~U*rXZt5|nsoLoQffx;x*Ad? z`;gc`-qjpKpG+#_iV_8L6X^q-Mx3vf9dR?ouGOt6s!kf?66ta<3C=+p#^F^Py&vB#lWA0OT_A{Qw zsqh}$N(@#x+h%0utI5>Lr`q`!xZ}q7m6=)ps=RH{3Wr2NqojlPFZlyl!+lfpK~Mcr9hza+ zciuqUCBp)%4nFrt3VB5G$dD2=_1uLiyw=e&qucNj*fAxY+&p3C>f})Wx!K!QQQ(H> zm+)%-0%Hg~%otbJb$#7*U9zWq()V^Cs>@g4%L0u}0~)Gf=NWuE8NC`iXQY6|1Lw7~ z-Uq{{j(@j~xc|n8)cd3u=7^f@5cpc%-R+`C-v(ANfl*X9*sP(U$0EQROb#fRRXeYY zM~3T?S=B)n8dU7oy1qtB1LJNB*8&2?G7Z=I0;&P78F+0g%z^6QLn~qlTM^->(6}Pq z9E4secxMrRLeQcVB{>Ln4#|LD9`UpwU;~Y=6z0qsafUzzfu^Ai#45g8Fs=?)Lq^F( z>_?cXv}uS68#e_4XS5$Bq%Z2vqUC2v5sOp2pTHYfXD5X#pI50PHR|a&Du0m;I%~fsP3WGPB&Jb!E2?*eS9ugP zH5w_RrAkCw{%O1rO#Y+Zi~o|U&Lo`po%lXBHG=9dD7g3#>riNiTqiF-YCktW01~voA7VO@;c;tzU!l#cU96!;SzV4; zu(Ku#Tsf(zaz(l_x;4&g=I(V+ecAHX`n`Ay_9-q&4;%H70T5|0Sqd|FieHEP+L#=w zY92CRqQQcwD}d|n6Q)Oh1|1bKl@L z&%_{@**ZXD@i$Mu@FdE&4IJ8xP($EcUe)4|_t5|l3Naz=y|mA_5Ga$Sp(&K=Jn ze|k{={1d_c8M$;>nk+v%!z3{C?_3QZtbFWBVFugPTZOf@;y;*4CEfulyeGGfwQ2iY z+1gEs4~rRBgdGy~tU1%XL8*+*zOBi6h#m)%3jc1rnKx1(6=_d-j*Q%h_+F$itfNp@ z?F4TT=*5g>qb_&XUnbO?h`=|Lh}IOVikQR6w;hk20D(bOeR2OR%Oi|3aYmkzl>0hl!TlFu!*1#;#1J^q-#&E-J>`QY{L;DiV|>1>4cK@ zDEMnofSy0iOM0-ZyM^my)S<>N2syYa55BK`0WXi=p0Q^&w=fsWZUFUcyqa{H2A`-s z;q}&0)8`90uO7Vb)d&licBRlp+J@(=`3IkV#Xk(UqA+&(n|lAnKz_G}?O_1^a% z`1}Q7&e><5y;nTXv(}ynRb^RpR6^#Gftj{KhB3H<^B8j z5$ti1I7*6Z>wMo7U9lfascMR?XFpLDSH%U3OJk{tt4iTgK_C#B{obL_%{ehiUZu<$ z-A_!ZpX`g>cn_{8Iy9Q{i@m(HicSmf3#znld*#${rPVZaMNRQkf&UvZl()F)lh6;hj@cQ>!r>>+85+@N>2&@e$y7`_$r{$KgubO-%rAB@MffU4y?0jb=^6lHb`I?4?hD=fa z=E};S?ICD8Q$>>ft*rqtS(%x}lOOsA28J_)(KHbd5m#G2B9Zg(x$iH~iPbtTH|OW) zAN5ytcgyh6v#=y;`1tz1RoBp<{2mnJs;Vj%)PS(~ zn;Re4_SROhjWf9({}RIn9viSkzVo`*vKKg}r1hBFb_&w^n5=8K4PD&Era%HoIpp+ zlKBWr3KoeWgoa^|zy+S|FA5TaSPkpf4-R4rMtXW=XPd)@R*)G%bVtTm)MC$y@EV5t z`>{=kZMa52ZNz>$8X9pS%cOXCp~eh??yp`c$;rLZDD6mK)aftkT=qRDk&q#FAOED3 zoSdxSLs6nCOR3ERYx3+FVN^nVye^7_)O!C}YkPZp7Ja`D8wQUpEe*}uhx|^go`Kab zE~%@>2&8M@zNusgp^U6Wb#`__o|Z{&V10O*_W8J~u{6Qr3~uw2 zljg)eU!euy5e7y^G*r~%pFiVw*0LlH!@Tr_aHY^2EQd)u{quuf36Q9pnwhDUy=D$H zB4+33uglJc^Dpx|+tsT>MS31XD*QSXo*HztQ<~gbkpPj3j`|{r7#)DZSjx`Th2Wy5 zre-@`EM494#1GCdW+mH-a_ZsO=)ySxBX zEQq5A2@DW|;hvnHo-X@cGjDI~@9&odfUB6dDOp)r)hHRo!&7|k?`~b51bU%jt&h+l zkH$6<*vO3LO6RJt{&0yJo02iqTu-`@#~9&!_^L5 zaf%@6PJv^5EIv4XHdc<+pIhTJN*|-6qc8fM_L3z92k78U1JLzy7M7@_zlH(+)Ehms zhCu!lk!anXX&t3D#7;BAw$AcRh?@i&tyL|_+4=c5TDm@{29E%Et^BR%{!)|v`us=* z8!^bazciP4gcAOU)w!-oIx#wdW(LY9HxzOCqY@bb`t0oN zE&@}xx3>qN-)}%67ZO&eQ__D=m}CjG&oYwQELXq9`mVm@Yi_c>p#vzo#rPHa0dgGE%HW58RH@tj|MNXNdc1 zb|m9Gu|em9UsQCou=g2L3?1(pxtdTKj%ZG4DR{@G>e(IMSQn091q4b49R+<|{~oE$ z6CHyKEq!g4ycp3K9U?@~&pexe$e_z7-m#~;AU`oV87&Cv(j&qGIe&(XxVyXeL}RQy z^`HdN+b9I9YO-(`#z!ktC=y>qscO5spN|BBFRZZrbz#U0G)LeP-U4&2aO%LoFroEo z^1D9Uvk<2f$rgDC95`JsKhMq0d4({k61(P2rR znuF`>>gdDv?Ptr)`M^ev9;4&qI9f(-Zq@Hp`f2zQ6u1qpb5zB}VGCM-c-*_(eg=aH zA|W84ui-T%+V}uEiULD;(Im>uU%leyz`M@m1HZ;I+#q*Crt~`Mo!9NfL4zpD%Zs;K zPG$U>@AdUHRv`U+{@WTH)OH~2ku%1l6Tv}i-P>B$y(y30Xt|!19X@!g6L{?t=_`b6 zGAG3I-S5MhJpu)4o?=ai;MeRSz=AT8YHDi6mvhoK7k=>{3IfkHxR;dIfVSzM^bQSm z`2j)jh;^Yl6_H#*eHR_v^*XH<2v^T3fk*}e{>UW7Z8;TX5Y{g&ZLUhrPDv^0*#Nl` z%ckivjx+iQ>{YuGM4R7Ked&G#_S9w1P8ig6fN1u{aHb;=9$7UZ(wi{OesD7a5o{WE zVVJ~X2*<57sLv;k=SH_*bI8~|V>_V$UL#&@uXS35!w4Gz-#>=zZf%LXteA^!dbR4UWf5!KzSKadGi{f3>XVW_7YCK>=AR zVBj^Y-n$5}AHtj;7Z(>lr1W+2_a=DIb|YQg_bAh9!)rAkNTryW>SZx3Wk4pmeR2xy z^^zGg(x57aZHHYvJu3J1%108=ci~JM4X8LHDROsH;bP&OAuq!k+v_ArDISs3N6!kC z4Knk|W~@}MnX>ha1VYiFrCYuq%PyQ2~S z3epv3b!(w1%?J;aA4@Mb!z;GHMC_OzrjS2dn-~OM#+*wgzU|?gTP`a|a zj#~ndo>Nl=w<$A(Jj)v!eQW|%bJcS{eL_M&h)+nMKXDF`Knf1j;gMF0kD#ES(0;F> zuRmY^YKM@Ju-gw5EyI~@xbgkF<6^y5;bhEJINQO-1|rw{Th=FazSn1yg*x6I9>hW( zrG zKSEw!zOS#Zv7i2RHdB60O^vN;KAW$vZ-d{+;_>+SI6P<)h)2$%;UQuTSzE180D!+4 zotQw#fb|1jkV3uP%fKM*;*!^4VFqx6ygXVDJ2D9FT%%_NHngm)Y<70`*U(=^lQ}KH zn!RMwd&_)uUji6E1Vu(Z)zrkL5R!VTdwzD-?6UECrn#z$n~CX>Nn&iQijh%<%kXh= zY0L;4GxGyREz~Z$I-7SCr^F$$9L_+;z`)zlCMCo&5)*^LUTrBYRi)ZK^?LugxR_^F zv>IV=J(h%ogi)s$wZo_#1TD%zVVGqaugGKy&fKrUL9 zjLsSb1qIb3hB6a43DB$ZXGKUD;@mhyfcHGl!iFYdE>2H}{rvgU73vJ~3t-vR^C1!J zvFJ}XBidEH1f#=kBg86+g|lH*BI)ftfp&Fu_3}Z4DJjivuTFbe0p)c3KLpllZmasrIN z7nPo9RR*;^B_#zb5G;Y7`R*M6VBwEnxw~T`OF-QvQ)Q0Ia&x=#e=r3L(;*XvI~un5 z87j94sDl&cyrjaH{g2k9)0LCb)0<2>LbH@UG7WOc#|pVq@g6_c!<4Y23=_`(Ue=M8MtsChPmf~9d6|3> z9fnD!E#Xl6l|w-Xh>_*?pdA(#7P*>NU>+_m1SF((#<4IrVpEe(@+mJY#@0Oo!Q^2{ zNjg$eQu_M(FJE$IcLW6msRfK!6<0)UNK*Q^y12Bjf|ZOK+=gan^@7hUWxJXE69HLx97Sla&k|eI^2gRL6pX*#O2~* z5G1~>bkYD+F#LN!eP^fCMnyfafZ-1wRfJ4Fb#idjU9GLHWr{E7#>RqvsCIrpARj;hCdL^@v!{a3Vxa1#Oz>Gb zjgNhUX3>H_OFkt>B_(H94uSml{1k*7Ph?0!Q=Fkk!*{hvX^`A!uJ zPQ=@qh3}Qwz)&VyU_%jBd54%K=EgAdb{$EirLRERO~u)GBcL}x|vX7prWLt z)m-G4&qX){WR32-D}(>c?`aS<_>9UNq*^Nc}gFEpu! zmoPRq#>YQmWf`Wo=UjYYRUtj<50ph8nUu}ma zW^Zqgj)tb+9(2Pwv*7DVh5-n| zr5j+nW<4>1fv`B>{kbYMxt$+BVCLcA-~cPgLRbZolXkJe=TWOSGfPV`r-_MpO-3!& zl0CsFmRXwqgw&KZaz3gFizmX?-g)QpU_K-|&o8y*HyP~th+Q-s`9+svD3*N{)Qc8yaM43++OA;^FYp%F?y2>z*fA zgviL!fEW^JsQ?azLIYkhGczLvuMQ@2N{Z*Je>N~MsIRXFWQLGKwE%FSS*C!UN>If+?<;C#%bygBmmT{Uq)#kr*(8ZXj5&bjw0~`AdmrR#8_8XS2D7) zloU*Kbh;H5Lz_dXVL@!v)aD!g2^VWh3p=hxMn+gzSb#+g4Go2392x#y#N)8!$zvfq z0w`#u+HRI2xU{$!Lv3YyvJlWolH=o{s+cC(D4^7oltV24jdV!)BNP;Ir#gp4AWC)K z-TD0;XUuBhJ{&f=Q7{KN9{ND?x zJjqYt@8hy0Qzv+y;y!BVnJLktaVK5I1pD20?I6JanV&#q-|-U^ zXhca0)v}Ww2#jZMDEl{N0e36v(*?3E>nHP!OzZRCk_WJ{a!34)UlL(F1g9Sm+7l_v zpQ$Jd(CJ?Hah(xT{}UO2Pf_jygWigA$~&AHqkyZS9@u|_%8wBm)@yl)qQ2ET1L1S) z09E}o$^Xt;(MJo;#50PcsHPH(`z7VJ_AUH2ibNvLgUOD(Rodnn%SQ=No&TcffPRh) zO66gp2L1gwOKFNm9#`nNQQl=SI~m60JmiHeT$WLZaha*KmewR)GqAPw4vPXRDk^cY z@bK`So}L2fUw3Pm?vo%d9+F{>3K5&<-2pb}r9pzVsYLQ?Ys_#I^ZnvJz=MEnbNLO( zC^{uZ%q^;bKxj2tpaof|4FDrQb8aXv&vD0{o}M;qs;#Z9s2E@W2*_<%0B#!GA364C zrlY0p>F5al{gf9L%8i|jTST1k)+8uzVN5!XJ*%IW0~mZ_Ykwb)3`nk#u^Ss3Yi6dV zYiE1&J&Y6xpt!iW23+iLX29kf+=?2L`+6e4zYU>pFb(&W_M#7U(`t2i!Kk%}7>IZ- zNFKo-$oM+N25t3i&z)Yr1f(kg=QZdB>r~vkoTEDcRwHAQ8dO-I^YA&Xz=*s?7yAN* zBB-bgzkmOP8dO+Vh^2sshnEs?2sl3tQmH?`n9!^3_&!;L5M66KyUs)aWrHvhSNBP~9x*j5tI96%5rxDO0G8VZYnJ`yCnlhsBO?IR%+1Y3AV=eT z$ha@tsf^?^k7>>4#Ec!gDv@E@{ix2gM$8v0Yd3*EP%{Z<1V(k+Dgo~A)|9ruU(eyi@Q{?94Ae4S7DtZio zGB7Yq*l;^N5M~+ZZ)i3sA77_4=AJGHi#o-e!kXHMmrwdM45?QWM2Q^Av(~4me z5fx6_q^GBI6QXB7fP4ghP|kWQnvIo}Zk-D?1skk{m~;*rI7l6`ktG=xO4_?lVDkL= zhf|0Y3#|2V$5Sb&o}S*Z|IuT|1AWdJX=!N^K{v$!RiRMaL--052|SBm!RCeadz~>} zdjnK(b?9|$p8Qd{QMEV%9MMdAO}G2&)1K898-V_3q&4TaQxxs+5cjD%hyr)%u6S--mYE z0uR+0@*{@q7Sa)@#BKWk@m`h$Yui=eLm{wo{)lPHnIa@OI5=2XgFBvs*Cg9C%4_l79D}$d7M8R zj55_mOAVgNWf*@ZAq3mL34^acATOl}yosWU3O*S!5|S7Ru&187h!l-LZGo4U7d{N& zo-QRg6_8E=x>}2&l(RE89B|5`Ot9H%5iGeI1`nmgq!kw*0w`=~{oYg*$W3gsQ&UKB z;TV8RG6jHFS^d%hi*0BD62&h9FzBr1{!yxJ@jQh~&glLE6UIbExxQ$Fsud<1=8=nn zqGD9beGzgpz-Z_JXx};ySW$cj?O@OdAD@EB_pj;C3$URyD#t*zq6mR}>Ik3B&CLzz zBorevz!RYgV6JdC*f==SH7ToNph8os&>uKY!R2h@4fgeIg?ecT|L3u|@U+T}&P2qlRKY=2nMyS~oXWqZ#ML)gDPg(!6vBj|{s}$ZD)j*% zzyC!ekh$y5o3r3)3oL|fI7WHI<$kXaHZ;acJ%QVG1^V8qVe{5<_clu77cl_V?!ZIn z9Jpg5&^A=LQt2U~J!~dI7G(+-uM=DuL@d1a4J79`@*2rfN+IGK)lq{()gJPifc^UK z0%s4Rr&;|?Y=4%=tUvfYR6| zw>6vHOer}KxC)pU zaS;*{0<}lj5H12L%cJ(Wxo1H6ploSkqS9iB@Xr(&=JnuAHaX0n-Rc}DutF3Co)7TP z&d<+t=dZ870H}8{8J9Q~xj3IEgbCoUj~?Of0NJUwVRXy&ABTt-`|XweC`d{TKjGT( z4|-l3uCD_!&dtqDJUxtwy82kP{X76nPxoq;De}QvKrIDOnGb*djEab8ljY^DSzB96 zJ%^v2bpfjz8Igj)D{E^(i$H>-pyuMzjN#kZPJyJ+fhoqFk2?k6d|r5|sKoX?lr`!A zjm}KlWC}%f1bmix?84zly*~qWI^1q2(B4Pj9@AxL9joSOS%5hpZpj*m84%Q3EEo+0 z7v$%w7Eb1?o$t<427@aZ85q<*YXXr5E4;AK*2_yE=qZ%|KfeiW6zIT33PgNdocL?4 z$?FMeLV{^68OJ-(K=YU(N%pMo;&?vq0{@Eb^X_6|r8K^5iY>oiLI6Y!uTwWUEO z5SB>xT9fm)Py9r3>IY3!}mRF=#LBqpSU0Pb&(qfFnAkHTb z;d=6jj{vCjrE3=oJFNs*^;-NE5Mo-cs=61?6(G9>3FGx&(_s*I@LKr!Y0y$5577La zC@9*2+EM`^3ChbK0sl@<_xAT`K(vpcs(@Us-pMBsEz|MOOu>`63b;ZSIUGtG%`@$2 zAlmj9O5abJJp(N=vG$v>N0;WEdxWD1p)mS@D5pCN)F&YTD~zuh-8pr!W$hXAs*u}MoyLq$cc ze709*JDrxEeq{V@r9&d8P_v-9StRJqFF$~|g5s{p-ipn# z(0i#AQzfL}VO|)Mr{Q_Q>Hks*@MA3<%2{5z=kp%ks& z{Yobv|4k>GnA-&jbhXz;Ta!4V`DYbdFecM=IRClXr8m{%w7~1Lq3e|-yl>NgKH>0; z=}YyPHw%`XX8A>le#hdbWUh0XrTQ*MIA}@^{C}=5=aJ7|SzYc!$u_Jsor4d}UFRc0z>Y*|0WP(&52-aP^!y1^r~cu{*Ie6#U|qkrZ^qU0?6qEVfjt z?{`DOlTeWU7+)n$96&}=q#mw<3!_}raCwDFcQO9Pn3$hT<$<*Qem~*&xH$dLMM@Pq z%9==1b183iTYb`{TLiJ%Z^z0alz-EkAiEwmQy`mXOd8v^+i0u`3j(5L&oFoSgBbMB zw4(cP9N#O_jhFf?(alLyDx3udwalFAHhl{GH%kh#e;${M&W15@|0u`y(^X5+`+3e@ zHh228Kj{^ln8ydMug!ll+xo=U!2*wnAX(#h94>ienK_mM-XF%%-e|ZtHxs4}g5Q28 z^EeGb&T%{i$l%Ev9K!U?*h<3*!5&OpABr{Jy(W?eZvD^n68f6XAM6o3Q)ZMUoss2(N+m+YW>{oQ|W&InyF_D=O;5w&#M{E$Mah>~O~{GUzCHVCi1Dw7R9lxb^}oor zw_TFWoP6U8%oxUG`?PYkdW-jw&x#)+L@4pIg(bmXC(w%fh1O7OP$*^(fwBRnFkl>0ydC> zn9Jn?;jcC2_tk4g1chZJ;z%{*(`>amEthVNevs#r`xnL)r6?Lx1+q=wT0Ehhlg@iU zt{e?@+_6Yup~3&L%YwdqWNL81NmpJBT+~t#Ockyu9M2ezm5of z6}e1YY^dot5~&tk@$LJ=%Xa!V zWK;?YDFZ9d5}-(=>a-M!?Je}zhv+$_8|c>B#jARdFsE43rt4IqtsG&6q4bhaV(S28O50eU=4L|XJR`pDAvlj48T_%w& z8%FUq0BWQEJY}fa9(&c~`W%VwV)Y2oeZd^4R}2gs!?q8uVf=NXd7ip^EEMRg&ubdC zwW4DA$GWEFlgnS35E1nl*3DdZv0=Zj2LZfMZm3C8iv+R5aC&>s8k_DuU|^{Qoz3z# zktY@N*z@B3&m(r};vTY+b@!gQR?7*MSUz)aJpttGyqWNPie$OAFkVL!o$g}j%*9*u z@0LI~PlTwz8Fl$|@31VU0(byv!*q0XsD%>_2zmw&ywu}@OvDd7E= z>m}CT)B{SX*EfG=39=kiHU~$&xz1pK24C#J{7L*{qnsyaZli&IzLQ^MVcUVX_YuR#$B=D0TQCI?mL~5eV}vWH{GiAjFX1#cN^VD>-+G0k9NG&Xw>NPaGzF8 z{D4?==lmR)f53?7S-n}>A6OzgJUBlut+gKs+dk!Vf3_53`Oz2wQB%R}Esfi@?s%OX(r8>p8|B_51ijV8F)%wWR;?3LB+-2?nwsqa$j=$rFeI1;? zjTE9*L9mTaTy6l04OE(ccs zUEZ<6r0KfJ7Ojk|mPRJ=`rhonOoN^XVwz#kraaqvRFQ@XE3q=t_9v(1e6#rEaWICt zm;L>&1>djkGVjC6>z6E)!lvt=i7b|zpZ*=TkjByfK;3?Hmez*~i1I%}5-KA4%MZ^C z|2l|1_h*j-^`zpRI{UHKO9F9~)3fuKpH6{cJE7j!EPsu!DCK6=_hk=^@>#@I~KuCmUXIfn)YlG8uN zFJNk6!2%CD#c#&O^`ZKa^x5%76o6us!f%9HszaukfriuHLi}6?5ZPechjEsOi23f9 zm2Zy%f#QZ%Ndehb;9Y$#F60rP=1!|+TDd3~kOPZVd!MtFS^&a003APFaj7~@7H39o znJM>p1_qrzT_Sb1*H|FmoUXQz;0}6|A_S(PrlzK)t@wQhMqy=0q1z3;s=lA&WJ&Kv0M)ot->GIA7jenbdB=eKZnf=DJ=T;WepMu&q$xvX2J)jigHXQC&#X|-7&ayqRL6!^! zDX1MKJ}gYu&@df+DRQ;Cva*N?AaOk#>5O0NZuSPp&auA_#bjPf3=XJBi(H?Kgh?+( zZ{(4;i1jlf8{c27OVkX$!lJ%DPC=DnKMDERjciz7{PA(by`u5uSRjGRC%rm|<98~b z01eeqqrS9C83590l;n9*+oLkgtfqgX#cNpz_;Fyyxy?Ew$AgiSY-2w_Buj-VQvL02 zY{Z}4jaMOXv1|Op^C8(5veB=TBm(R~A}xxXkLO_M1mUyVp7#z9*KmWY&)w3Bgz=wM zdQW=t!W`6G8$Gd35Uxb>=iX=DMW-VfZKxpmbS0CE6aZ`1i)vo|;ZsL6;$6rU;VB1$ zgY!5{T!Dj@$xHUJqh(f&q?HWG-cn56xq{)R zQgQ$&{;vcK-Q3PX(TPHNqLtgJ!)*w|+tZKp`XWO+NXKBM)oedbwVu`H$v8_dGFPC} zsKrtuszKH=0M?q{rX-Ph9YiKY7ol+Duo$aiVIuPtQqn4VV{`c(-mf<~ji?R}&b)#~ zZGem}S~Bs@blU8A$w}RbIob#H`fWW4Dw03*Djnx?J$3*!9MZ)Ht z*v!ZX_{ozWYis46C!5>b+kJHiYKZV=`7sZH-0D?;M7Y34<`!chqh@)&`IoeLKfbsX zSP8`m@tLA11g7Uy+a>ZeYwNfcP8bAq$kgFNZzl6iU@OW}JGWXr+YBR#jn{Y(dFizG z7fi&$1D;Hm9xI~}z_qU`bez(B4@JzJp(!LM(hD0zKupLLTPRVS>!Md&8*Fc6gQ40< zMT;+4wU0%Y;hOsm}xE1VAdt%V;J6EM%w%#3iDuX$BZwvgdX>|Jn8sdqAit*u^cPs$M#n0Nv{oK zvk23f0JRUm7^v=>(*?6`YZe?Z4gJ9^djLuLdA8c!LZI$89ZF;dp* z*zRW}jR_gUPFb8I6HQyx#E!KBMfO=+G{0&3+h&6yJXB5z2 zduM(0)<3)(dtnM7LA95$ZPt@f(F9{WIzTf5K;gx+!xrXu=OTz#?C2?kzu&M|q z#i!=FKk?ZDGp)GWo0tzd#f7zHbd*)m0(!_ujUhEDK@{NzwgM$U@{GQLdh%ytIeptS ziy|?XwZwk>qlXrs!I>{h{OpBxWOyR@q%V-L*nTH9sAml)Tv*?Gzp&CV9zE{^rMg&u zSrX+a6hb=q?W%{qp=x-JDkA8b3@bC`RtFBc-O4?6;G?2WNp}%=o#592BQD1;0#Y+j zLwRkXvLVTbpnpL96~~a1hHH>8$%TUSlI{}SC6URLDUnVL9^n-+wThxcbMw!d~Hb%M!vhUfX^0htu2T;49aZq@&li;QGF~!CSPn}aX zQZmAYl4|tF##>qQvbD4U5AM~N#TVB4$>ooKMuaa1EPo^Nj$X_`!GK3|i@LV@ic*9p z?Ok$H`B;bV*vHjSr+bl>MH&zd<2g2zXs3+BJugo*BHvEddUtR~twkWZlh^V{>Db&* z+~9wgo?W}@Z<~JWU{l^O`sB*Ydh4AL&L|*7Jd~iUo8;MFtflU4xXmGnVL=mF#IbJb z%!@g#FFR$alnpAruP5P5Kw2Arh(L4*%nmd-ZQ`-#+lWYj>BwoS~V$n3%wmp!4u0#OhH zWdfgq2R%ApUf_9d8RO(Po)sLvyR(O#NpxdFQCCds@dOf-Hu?P1v!AR z`guo9>EJ+I^x4Il?DufxuN=<+aJ zI^*4{{y~Ft$@%R$2A92oK(+%1ElYJk5NDF{{yz7N8f+e5K(-p?%V|(dRaO;MV+BD5 z+I%i7Ub<98ajDMmh7u{=IDU67y-}kGA8lpi;M;p3g-8707473ksie~1IO%FU2dy6#!vFBAEzguo%-M&rfz70z@!73^VYy)C6E~g zaabp^Bx$F-9>k9bh@Q#IvRS#&FY>#nP&NW56tJI%53EF7pZ~7F=&kCZ*@nr*M+YX7 zk9|O#a&aeR(#`y!k1oh4=)#-)mBGhG6qja*=4AN1XhCIVRY27#>wJELlh_p$_z(JmaMIZ0Q|-IN>s*H4Yp7X4(yxCssB^+-!0g&WE4HihTUZ{1FWZ z>%qh%6dz^gwgm;^_&P^SXmJGMlG78?=NtMae13Xc^CZ8d{W2@B_3^B(D+#8({dMv0 z$4x3xd=ZC)ducZow_U~fs7T!)Vf6vpJFR7F?%sNiyczvIigwz|vU0K!Ii-vu;jj~m znjq!QQXE-2!R%DU=${BR-^V;vORv&ti_(-f0Xit&hK@CuUa?}Y(^K&2sayXzdY4j7u@gbV7*Sa{I z1LBC{NGVPOtDx2qHey@5ctjFQRj7UW_M^?ppdg@W(sBGpo{RD?&awVpbIe7HUtKyX z;pYJQo3I8wYwU9}z+s%`vlb=+rDyHV>^SUdW}HCutQ?`8V(V4#t&J9-C+c60QP;&P z-dt|dX8=0@G|TW~Z0{XNcb*;fh4d$}^_I}h`clJ*yM2vb=tS!Q!Z5SLZ;tDQxg7!>^F^O6bz>rRp!A7_K|xo!xq~w&`>Sn?b8LNr zdp37Rp;-BnVJ~&nXj*6i4$sfe<_K8zo})#Y82|3L?{a{WW}&IbQo#JR?wh+b83B_{ zK|}ICvs1G<*b|$np=Jde+#Fs60S@ftGkp)(YUBU0bMl7Wo?o?`Qd~(OB z9g_m~ebK!$+3=Svx=Subho;}>AxOLu5efAF0MYg6QNsx!1M`WW^!_E>%84!p8&2Q? z{Tmvw89%z+nB{q}8v27I5zR0EyIyErBT_ZgeV8c+0V-YeoOmf4!*B>S#p_iX|zb6f-!jP4Qwu-YDLfC zC$7UnFU<)zsieW>-9Q^*rGBO~Kb~N(pE|=QYAa9*stv<39hy+#+9oKbPqwDWAXS*ji z%haf(o=bce>M}=gOa0S+<|DeVPxehe{zo|fMyr+hgoB($lk<)(A!-BvaA{FS4G7`C z8g!^YJ@Oz}OcDB!;MuPfS(N11xJY8^Ky=t0}rCC@GlCLpL_^<*u{H`xeBmPf0*r`zqn@P>-ylISSK3Lt+ zn6=6G{Nr+D%|Qyc=b9-R-Nl&badDy7gK_;H+`+ft#8HHhDHaPwn15?bpT?-sSpN-o zT3>-o(Gyl!VvdJ6#!aa-ma}-Z>%g_|FLh~E+M;9#6q9J+k(CtP&IvnrkQUvv{(Iqs zbyS!?ts2<>+Ob*INU_+k=0a(d&Sq-8`~$}?g%SMr!4ZDZ<-PGdaYsd;)6IPG&XC}T zykMch={fyw>_soT^~6e42^t_t49dTTychx^6W}+)gDsbS5!Hnh;`(p208a9&l+%$s zNN0zPXm2tB`J-^GK8df}wcs87MEv$cVG+>%b>ZYlj7xJez?B`W2*@h`j+rTfew8YT z)UnS#mAj-kUI|F3=mX#B$qCls9nUtKwa!OEw${qS*RTR<#tjd zI_i`k$I!^Q`I&db=enRE#$ZM}lU<>|6Y0&h=OOhy+I%Ulm8jT8#PU!Rn~lXhKfCmL zwaobRrFdJ51AUbq>Vv_tivMa(%T95LQo~I78S|E2m;W{kP~j?;3vDL8y1cW%xo!XM zol3|g{#T=^dJUI@zZVn~4)T9O?;IIaa;uOb-Yqq&BPf0F9&>tqjt}vnwfA?^w3Tve zh6i0Z^~>Z54GUGEJjL$RY;*Rlep|i5c=1)^Dv%yKU$#ZgK4`$dO=RCE5rL?~pMo6h zU%0mM!dG(WH1_^^U{Jx7$WgcFgYpLdAhec0C@z(}ncF_!-hOvP3Zk_n5-eQ52P&L8 zLtdJVdJ;Oe0vc8=CJ>gUtqt=_)BX2=tou-+`@OL`B7tIc%v{^zW*g*}qVTs@)juHY z?utM^o20Bl8ne}P>n$pnE=6*l%j@5pL`4EyD?@m(p18%b+t!tpDBa~1*H=1>Dnh_d zfjX!>uE&-7P9r)sT;NNCNHM8@Z=@AL_oCm$8Mj13uwaR62wg%&$P&LKdmi%Q9 zf&i7LK8B~2_0FdP&{dQDbw!+7uv4dA;069&PM3CHz^DLCzNTlo1hwd9>|k!b5Vh+^ zQ`W%CNLJrE8g`d)QJZREzc_z#QS}fJH<4~mq1Ed*X6VjaNHNuqSvm)qmH#GV&- zRrc3?UyO%95d~ff%$4i75!SAohFa>X|7c2bx5_w@T0`-XrkvtxXTn{l| zJ*S{y+Nt`3y`)rCxt_X|1z_o5tc=>3ciu%O^#wH*4fmVwgq%4@!?&@$H$*e99EbZv zr`J0TubR0(mXfp?-&|UB2B~?oj#i|M7MkNMxl-7S71MmRUz} z4`Q?)C(zBU96!h9_2CCVOIVreCRg}hUYef^Ye9@{uE3c{O+SNjeoEJ5+(+b zxupxTHG&dw}-}n zhmPF7c}=5b9H)FYKp;J)Z1uNe7IrS{8e0+S^fy<-zF*G^fLZOE?LL0uYbb47+fqJH z8zh?ZGZF7N>Yo+?Ye|}Ut}8&Vzi~lg=O4((kDfd~d>kBWR{3 zb{}mEw8{d~apI*8Ad8-!opvO%_5u1R|A@8h6O!O@V?+ z!vuEoPi#3;eJG@oFxGPUb*Di+^+9Scius<{+(T&i^6rOxo%%4VskzzZ=|vI zQ(q-@uk*t%7acT!7qBW$LkA?NZ#qleJN?z~lgKH_Ji7luWN8L*hE?ivI++$sv7<&y zdV~k@SjV#{2cj0&BJSn`IH!U4#b|fwh5Sb5XA9z~i9 zN`oxwaZIz7;$_?k#v$ zN3ESxIW9gpptQVvYQ@Ykz5F5tR4f1bQ!rj?0X2lH? zqSW?T6XYAcC)oAzBwC?*DM5bEs!o&Y{91%}F3ISLj09`8RHoeq9iy+*agJiYmQvf4 zsAv}APq2CtVP&}3WfJTvd9Pgc_}8wMt2X&I0bPi_ydx#w3G(FoN5!nzp77Ysyh%#R zo3z0s6?#HKGUT#$L1Vt%8)+q{$)we{kNtW*mrB?4-7I1}p@Vq5MR}(POPeCol&mAo zz`i#!h5zT}dqv+vH10so$i^kUhMOXs%&&ZBcTqXB{&L3SVv4%zPtto?q_xa;i! zIc{6U`&N7}q%fv<#Q{Dm2{pVAm2TN#zx{eYRdeEhws&JVJhg1aBRaiydQHTbS)g}i zun{C%GIV?JnDuTN3k$=9EJ##Ld8157qg_|K2kZ22GPo%_=zeciavHV|mO zOG<3HGq%8=47wLuP`}^zXV_;latm6OaAe))CKgT-@dKt9vY>n_!t zT7)PiW_L&7Da_IpgThaA?vJ(|RAyH1QeH!tn3xu-?NfE9cTR!kSfEpn2RKYNEOer{ zZR~Ha?)_T&yX~{EnCr2o?n8nvW8hSlb&tL z_M7j_M>a0&F(hvIA75Ol7!54FGGv>!Z4-2Gymj9D!rS6^cG@C(a@=T{k$LopTPuVx z!UF=L<)J{pNInHx3MVvSO?-Wu!otFIbv|nX-HPVT8oy5nBL%k&4D2)_XX{Gb3iYDi0m zw6xp1|j;zsBL!%a;|iwqsMMZ)XRFr%+?`;;OZs^66pQf!^m=J5#_} z1>lP$x_~cBk&>FxB)$AkXQ^h6u4wdyA=m84NU7W2TuKVz`ZjQS9Qdz!FwF)UgpCcH z@R2!SBg>TU9N2kGhoQ7!d z^H3`9Ktjyvc=)n(TyGy5K1=xN_O{K!>f8tUtVn#;{rMWqqr_k1`VbR#&Be>>GfG*o zit01+St!lfwPg_#Lu*xj9vxxvRsi3I@;WlI!WsPRVWyT*s=!y4IJDZwu`ezz<`b*M z&NG1;>g!wI=jYP_{oXm#lasR_vkjyEhT5G`vtOf?Y0fOGm1bi+WKxKtZZ5frwO zAwtgL9uJ?#0I4|xC!%M*#_8b1yJycE(JE~SFlqA&2xHh>=iC(i(4GtVT| zKQL^87BkCXYWr)%wHR;UFc+}6`Bv)c>UJ-e+y}6-q7^AcaG}82rtq4<(1>5hM!J`m z$ws4?gG;Ncr^d%MFdBhISaZsRkMc7%!6Cit#}z|CX4O$M&wsr&a3Z8^773>!A!bOK z(g9AQNE>a?px(95;w1+IgH6|-M6Y>p6zq*u0<)MEHf$kZkY$1^)R1CbNq1a7HEI`#C6?XH9|Q<#xnS8U1t_1M6eJWNF&8 z<>gVt`2^yCgW`hj`vy&3+{G$Tj%w?%PpG3#NtsHIi7ROAtN(8g0{Zx&2_9!o7$AvP zdRZqYsa|IP`s?-j|4;SnPo6q8>%!reUw;8tpMJkro&W94O<=~)&CC>hxpU`E`T9Q} z*F{r!3!xC+@O5_IU(l@{=B9Hv0vIS}=)*KW_dv%|2k z9ker;sj2MBVMVgs{dLuc zXJZl2!S?@uo`1jZcV0%u3*au=@AvEb`+=Jle?RKhe=-+%B+%J8mYetOi>o=3*1@#@ z_q*M|6F0h7h*(T9*VE9jD0s44tQDQT90ye<@IRd8xBT~q!~BmQ zJpy{4U&dlX!a=4#=BB1s&z|Lto@Z71>g)A*@%v6*QBhIAU0l}h_cXuoT^pt!wME0$ zR#st-VX|9L&?L9Tft%ho^V;?8E-fTYa zV5;)$$rFaUPi7J9hk?dEJ2$u6;N0QE$|@>HZr_&vU-f?P_glAbm%qKG`p8Mc&hFmv zJ zJ=x!GqJ2|MhoCFN^VhFmzkAnLdVx>A{LPKVuNyWP2;Mkp#0{(jns;nox6ZG|rJ&Qc z{`=kX!;QdW7hZSk?-Srz1`gko%)q^G|9?F0=a;wZIiato_wF#i{gsy`9_P=Tsrh;} zykFkF@2j$V-=2TJUNa>FcV>a2HZV{yp!~xF$2S*rI2JZEG_2qEi%TabKmR^(h5aJe z?q9!u0}tSk+xPR?Y~W6@dCI_=Ml)-ZBS&a>cr$1>=C9lL|AocH=?NV?dOfas?aGy$ zuYo82aJ=6Vwf4vLmzS4|0~7W!>3j=o>+M^%@US~Q(6z9r0Peue-}`kM@Dvx|u9lb1 zjujst9eueyd(m+V;7MonKJ5%RaE$$^we2tevzKX37j7$f<^Vh`j=|H_&t;ucLK6Ut C5=Wl^ literal 0 HcmV?d00001 diff --git a/img/UpSweep.PNG b/img/UpSweep.PNG new file mode 100644 index 0000000000000000000000000000000000000000..8c5871fc9b5e431ef28848f6bc98143cd640e407 GIT binary patch literal 98886 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

1bPz=a8ZIF4d?G^y0#m0@KknKW+e+n9XmL$=hk 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 literal 0 HcmV?d00001 diff --git a/src/main.cpp b/src/main.cpp index 1cc633c..4eb5d99 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -13,7 +13,7 @@ #include #include "testing_helpers.hpp" -const int SIZE = 1 << 4; // feel free to change the size of array +const int SIZE = 1 << 20; // feel free to change the size of array const int NPOT = SIZE - 3; // Non-Power-Of-Two int a[SIZE], b[SIZE], c[SIZE]; From 4fa59bac14359a24c1cf72d15fe70b98442fb6fc Mon Sep 17 00:00:00 2001 From: Rudraksha20 Date: Tue, 19 Sep 2017 21:45:59 -0400 Subject: [PATCH 6/7] Readme.md Update --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 20a391d..bcafa13 100644 --- a/README.md +++ b/README.md @@ -58,7 +58,7 @@ For the performance analysis I have used a block size of 128 and logged the exec * Chart: - ![Performance Chart](img/TableChart.PNG) + ![Performance Chart](img/TableChart.png) - Analysis: From 7cd2f8eaeb8218f4544364cf3dc37ff0c8198014 Mon Sep 17 00:00:00 2001 From: Rudraksha20 Date: Tue, 19 Sep 2017 21:58:08 -0400 Subject: [PATCH 7/7] .md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index bcafa13..1e4a136 100644 --- a/README.md +++ b/README.md @@ -69,7 +69,7 @@ For the performance analysis I have used a block size of 128 and logged the exec Bottle Neck: The primary bottle neck for the GPU implementation is global memory access. For each thread is relatively light for each thread we do a minimum of two memory calls to the global memory to fetch the two values to be added. The second bottle neck I think is due to the inefficient use of the GPU threads. For each subsequent level the number of threads working per wrap reduces. These inactive threads stay there doing nothing and utilizing the resources of the GPU. Thus the overhead of these threads also slows down the GPU implementation. - Unexpected Result: Wait... in the GPU implementation the efficient implementation should be faster as compared to the inefficient implementation!!! But for my analysis I find that the GPU Work-Efficient implementation is nearly as fast as the inefficient implementation and even slower as the number of elements in the array increases. This is a very confusing result to me that i am not able to explain. I tried debugging my code and going through it to make sure I was not doning anything wrong but I could not find anything. If anyone can explain a probable reason to me I would love to hear it! + Unexpected Result: Wait... in the GPU implementation the efficient implementation should be faster as compared to the inefficient implementation!!! But for my analysis I find that the GPU Work-Efficient implementation is nearly as fast as the inefficient implementation and even slower as the number of elements in the array increases. This is a very confusing result to me that i am not able to explain. I tried debugging my code and going through it to make sure I was not doning anything wrong but I could not find anything. I believe this should be the expected result because as mentioned above the number of idle threads in the work-efficient implementatioin will be twice that of the naive implementation but I would like to know the exact reasoning. Thrust Implementation: Thrust performed more or less consistantly throughout the increasing array sizes. Over the final array size values `2^20 - 2^22` the speed reduces as expected. The implementation overall was the slpwest of them all for all the array sizes which is rather expected as the library would be doing lot many things that may not be necessary for the scan. A proper analysis would be possible with a more clear understanding of the base code.