diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json
new file mode 100644
index 00000000..83945620
--- /dev/null
+++ b/.vscode/c_cpp_properties.json
@@ -0,0 +1,26 @@
+{
+ "configurations": [
+ {
+ "name": "Win32",
+ "includePath": [
+ "${default}",
+ "C:/Program Files (x86)/Windows Kits/10/Include/10.0.19041.0/ucrt",
+ "C:/Program Files (x86)/Windows Kits/10/Include/10.0.19041.0/shared",
+ "C:/Program Files (x86)/Windows Kits/10/Include/10.0.19041.0/um",
+ "C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/MSVC/14.44.35207/include",
+ "${workspaceFolder}/**"
+ ],
+ "defines": [
+ "_DEBUG",
+ "UNICODE",
+ "_UNICODE"
+ ],
+ "windowsSdkVersion": "10.0.19041.0",
+ "compilerPath": "cl.exe",
+ "cStandard": "c17",
+ "cppStandard": "c++17",
+ "intelliSenseMode": "windows-msvc-x64"
+ }
+ ],
+ "version": 4
+}
\ No newline at end of file
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 00000000..aef098f1
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,80 @@
+{
+ "C_Cpp.intelliSenseEngine": "default",
+ "C_Cpp.default.compilerPath": "cl.exe",
+ "cmake.debugConfig": {
+ "cwd": "${workspaceFolder}"
+ },
+ "files.associations": {
+ "array": "cpp",
+ "atomic": "cpp",
+ "bit": "cpp",
+ "cctype": "cpp",
+ "charconv": "cpp",
+ "chrono": "cpp",
+ "clocale": "cpp",
+ "cmath": "cpp",
+ "compare": "cpp",
+ "concepts": "cpp",
+ "cstdarg": "cpp",
+ "cstddef": "cpp",
+ "cstdint": "cpp",
+ "cstdio": "cpp",
+ "cstdlib": "cpp",
+ "cstring": "cpp",
+ "ctime": "cpp",
+ "cwchar": "cpp",
+ "exception": "cpp",
+ "expected": "cpp",
+ "format": "cpp",
+ "forward_list": "cpp",
+ "fstream": "cpp",
+ "functional": "cpp",
+ "initializer_list": "cpp",
+ "iomanip": "cpp",
+ "ios": "cpp",
+ "iosfwd": "cpp",
+ "iostream": "cpp",
+ "istream": "cpp",
+ "iterator": "cpp",
+ "limits": "cpp",
+ "list": "cpp",
+ "locale": "cpp",
+ "map": "cpp",
+ "memory": "cpp",
+ "mutex": "cpp",
+ "new": "cpp",
+ "optional": "cpp",
+ "ostream": "cpp",
+ "ratio": "cpp",
+ "set": "cpp",
+ "sstream": "cpp",
+ "stdexcept": "cpp",
+ "stop_token": "cpp",
+ "streambuf": "cpp",
+ "string": "cpp",
+ "system_error": "cpp",
+ "thread": "cpp",
+ "tuple": "cpp",
+ "type_traits": "cpp",
+ "typeinfo": "cpp",
+ "unordered_map": "cpp",
+ "utility": "cpp",
+ "vector": "cpp",
+ "xfacet": "cpp",
+ "xhash": "cpp",
+ "xiosbase": "cpp",
+ "xlocale": "cpp",
+ "xlocbuf": "cpp",
+ "xlocinfo": "cpp",
+ "xlocmes": "cpp",
+ "xlocmon": "cpp",
+ "xlocnum": "cpp",
+ "xloctime": "cpp",
+ "xmemory": "cpp",
+ "xstring": "cpp",
+ "xtr1common": "cpp",
+ "xtree": "cpp",
+ "xutility": "cpp",
+ "algorithm": "cpp"
+ }
+}
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 610c27d4..01960c10 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,8 @@
cmake_minimum_required(VERSION 3.18)
project(cis5650_stream_compaction_test LANGUAGES CUDA CXX)
+enable_testing()
+
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
@@ -42,5 +44,6 @@ source_group(Headers FILES ${headers})
source_group(Sources FILES ${sources})
add_executable(${CMAKE_PROJECT_NAME} ${sources} ${headers})
+add_test(NAME AllTests COMMAND ${CMAKE_PROJECT_NAME})
target_link_libraries(${CMAKE_PROJECT_NAME} stream_compaction)
set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT ${CMAKE_PROJECT_NAME})
diff --git a/README.md b/README.md
index 0e38ddb1..4101e752 100644
--- a/README.md
+++ b/README.md
@@ -3,12 +3,371 @@ CUDA Stream Compaction
**University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 2**
-* (TODO) YOUR NAME HERE
- * (TODO) [LinkedIn](), [personal website](), [twitter](), etc.
-* Tested on: (TODO) Windows 22, i7-2222 @ 2.22GHz 22GB, GTX 222 222MB (Moore 2222 Lab)
+* Saahil Gupta
+ * [LinkedIn](https://www.linkedin.com/in/saahil-g), [personal website](https://www.saahil-gupta.com)
+* Tested on: Windows 11 10.0.26100, AMD Ryzen 9 7940HS @ 4.0GHz 32GB, RTX 4060 Laptop GPU 8GB
-### (TODO: Your README)
+## Table of Contents
-Include analysis, etc. (Remember, this is public, so don't put
-anything here that you don't want to share with the world.)
+- [Overview](#overview)
+- [Implementation and Performance Analysis](#implementation-and-performance-analysis)
+ - [CPU](#basic-cpu-implementation)
+ - [Scan](#scan)
+ - [Stream Compaction](#stream-compaction)
+ - [GPU Naive](#gpu-naive)
+ - [Scan](#scan-1)
+ - [GPU Work Efficient](#gpu-work-efficiency)
+ - [Scan](#scan-2)
+ - [Stream Compaction](#stream-compaction-1)
+ - [GPU Thread Efficient](#gpu-thread-efficient)
+ - [Scan](#scan-3)
+ - [Stream Compaction](#stream-compaction-2)
+ - [GPU Thrust](#gpu-thrust)
+ - [Scan](#scan-4)
+ - [Stream Compaction](#stream-compaction-3)
+- [Potential Future Optimizations](#potential-future-optimizations)
+ - [Global Memory Coalescing](#global-memory-coalescing)
+ - [Shared Memory](#shared-memory)
+ - [Block Based Division](#block-based-division)
+
+
+## Overview
+This project implements and benchmarks multiple algorithms for **stream compaction** and **scan** on both the CPU and GPU. Stream compaction is the process of removing unwanted elements from an array(*in our case, removing zeroes from an array of integers*) while maintaining the order of remaining elements, and scan computes prefix sums of an array.
+
+This project contains the following versions of `scan` and `compact`:
+
+- **CPU**: iterative scan and stream compaction using standard sequential methods
+- **GPU Naive**: a straightforward parallel implementation using simple GPU scan kernels
+- **GPU Work-Efficient**: an optimized parallel algorithm that reduces redundant work
+- **GPU Thread-Efficient**: further optimizes GPU execution by minimizing idle threads through striding
+- **GPU Thrust**: leverages NVIDIA’s Thrust library for highly optimized scan and compaction routines
+
+
+## Implementation and Performance Analysis
+
+Performance data was collected for each implementation. CPU timings were measured with `std::chrono`, and GPU timings with `cudaEvents`.
+
+The profiler is implemented in Rust and can be found in `profiling/`. It writes to a cache in `profiling/profile_output/`. *Note that this cache is overwritten on each run and should not be used for multi-configuration results; it only reflects the latest profiling session.*
+
+To run the profiler locally across all configurations, execute `runtests.bat`. This script collects data and generates plot images for each configuration in `img/`.
+
+The graphs below show runtime (ms) against input data size. Data size is plotted on a logscale, where each position corresponds to $2^x$. The y-axis typically ranges from 0–300 ms, but is scaled up for configurations with longer runtimes.
+
+## Basic CPU Implementation
+
+The CPU implementations can be found in `src/cpu.cu`.
+
+1. `StreamCompaction::CPU::scan`
+Implements a standard prefix-sum (scan) algorithm, starting at the beginning of the array and accumulating values iteratively:
+```py
+scan(data) -> out:
+ out[0] = 0;
+ for i in 1..n do
+ out[i] = out[i-1] + data[i-1]
+```
+
+2. `StreamCompaction::CPU::compactWithoutScan`
+Performs stream compaction without using scan, by iteratively appending nonzero values to an output array:
+```py
+compactWithoutScan(data) -> out, len:
+ c = 0
+ for i in 0..n do
+ if data[i] != 0 then
+ out[c] = data[i]
+ c += 1
+
+ len = c
+```
+
+3. `StreamCompaction::CPU::compactWithScan`
+Implements stream compaction using the scan function, resembling the parallel algorithm used for the GPU implementation:
+```py
+compactWithScan(data) -> out, len:
+ flags = [0; n]
+ scanout = [0; n]
+
+ for i in 0..n do
+ flags[i] = if data[i] == 0 then 0 else 1
+
+ scanout = scan(flags)
+
+ for i in 0..n do
+ if flags[i] == 1 then
+ out[scanout[i]] = data[i]
+
+ len = scanout[n-1] + flags[n-1]
+```
+
+### Scan
+
+
+
+ 
+
+
+### Stream Compaction
+
+
+
+ 
+
+
+
+## GPU Naive
+
+The GPU Naive implementations can be found in `src/naive.cu`.
+
+1. `StreamCompaction::Naive::scan`
+Implements scan by precomputing sum for a window size `k` for every index `i > k`, where `k` doubles every iteration.
+
+
+
+*Naive stream compaction was omitted, since the only difference would be a call to the naive scan function (naive vs work efficient).*
+
+### Scan
+
+
+
+
+
Block Size 256
+
+
+
+
+ 
+ 128
+ |
+
+ 
+ 512
+ |
+
+ 
+ 1024
+ |
+
+
+
+
+
+
+
Block Size 256
+
+
+
+
+ 
+ 128
+ |
+
+ 
+ 512
+ |
+
+ 
+ 1024
+ |
+
+
+
+
+
+
+
Block Size 256
+
+
+
+ 
+ 128
+ |
+
+ 
+ 512
+ |
+
+ 
+ 1024
+ |
+
+
+
+
+
+
+
Block Size 256
+
+
+
+
+ 
+ 128
+ |
+
+ 
+ 512
+ |
+
+ 
+ 1024
+ |
+
+
+
+
+
+
+
Block Size 256
+
+
+
+ 
+ 128
+ |
+
+ 
+ 512
+ |
+
+ 
+ 1024
+ |
+
+
+
+
+
+
+
Block Size 256
+
+
+
+
+ 
+ 128
+ |
+
+ 
+ 512
+ |
+
+ 
+ 1024
+ |
+
+
+
+
+
+
+
Block Size 256
+
+
+
+ 
+ 128
+ |
+
+ 
+ 512
+ |
+
+ 
+ 1024
+ |
+
+
+
+