CIS565-Fall-2022 · BigFranklin1 · Sep 2, 2022 · Sep 10, 2022 · Sep 12, 2022 · Sep 12, 2022
diff --git a/README.md b/README.md
@@ -1,11 +1,64 @@
 **University of Pennsylvania, CIS 565: GPU Programming and Architecture,
 Project 1 - Flocking**
 
-* (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)
 
-### (TODO: Your README)
+* Yilin Liu
+  * [LinkedIn](https://www.linkedin.com/in/yilin-liu-9538ba1a5/), [Personal Website](https://yilin.games/)
+* Tested on: Windows 10, i7-10750H @ 2.59GHz 32GB, GeForce RTX 2070 with Max-Q 8GB (Personal Laptop) 
 
-Include screenshots, analysis, etc. (Remember, this is public, so don't put
-anything here that you don't want to share with the world.)
+# Project 1 Results
+
+##  Screenshots:
+|![image](./images/1M_200Scale.gif)|
+|:--:| 
+| *1M boids with Uniform Coherent Grid* |
+
+
+|![image](./images/200k%20uniform%20grid.gif)|
+|:--:| 
+| *200k boids with Unifrom Grid* |
+
+
+## Analysis
+
+|![image](./images/naive_table.png)|
+|:--:| 
+| *Naive method* |
+
+|![image](./images/discrete_table.png)|
+|:--:| 
+| *Uniform Grid Scattered method* |
+
+|![image](./images/coherent_table.png)|
+|:--:| 
+| *Uniform Grid Coherent method* |
+
+|![image](./images/Framerate%20vs%20Methods.png)|
+|:--:| 
+| *Comparision of three methods* |
+
+|![image](./images/block_Size.png)|
+|:--:| 
+| *Effects of Block SIze* |
+
+## Questions:
+
+- For each implementation, how does changing the number of boids affect performance? Why do you think this is?
+
+  **Answer**: 
+For the naïve implementation, increasing the number of boids will significantly affect performance. The complexity O(n^2) is exponential related to the number of boids since we need to calculate the distance between every boids
+For uniform grid methods, the effect is not that obvious as the naive implementation since we only calculate the distance between boids among 8 out of 27 grids (the effects will be lifted). 
+
+- For each implementation, how does changing the block count and block size affect performance? Why do you think this is?
+
+    **Answer**: For all the implementations, increasing the block size before it reaches 64 will increase the performance, However, while greater than 64, increasing the size will slightly reduce the performance. This might be explained by the idle thread wasted.
+
+- For the coherent uniform grid: did you experience any performance improvements with the more coherent uniform grid? Was this the outcome you expected? Why or why not?
+
+    **Answer**: 
+    Coherent uniform grid's influence on performance improves as the number of boids increases. It can be explained by the increasing cost of data transfer for large number of boids. 
+
+- Did changing cell width and checking 27 vs 8 neighboring cells affect performance? Why or why not? Be careful: it is insufficient (and possibly incorrect) to say that 27-cell is slower simply because there are more cells to check!
+
+  **Answer**: 
+  Changing to 27 cells will significantly improve the performance. This effect is especially obvious when boids are super-dense in the grid, because simply searching through 27 cells may be more efficient than calculating the nearest neighborhoods. 
diff --git a/images/1M_200Scale.gif b/images/1M_200Scale.gif
diff --git a/images/200k uniform grid.gif b/images/200k uniform grid.gif
diff --git a/images/50k_uniform.gif b/images/50k_uniform.gif
diff --git a/images/Framerate vs Methods.png b/images/Framerate vs Methods.png
diff --git a/images/block_Size.png b/images/block_Size.png
diff --git a/images/coherent_table.png b/images/coherent_table.png
diff --git a/images/discrete_table.png b/images/discrete_table.png
diff --git a/images/naive_table.png b/images/naive_table.png