Milestone

Week	Work	Assignee	Done?
Week3 (second half)	Create a checker to verify the validity of the program with information extracted at each timestep	Vincy
	Implement parallelization algorithm over individual cells using shared address space model (dynamic vs static assignment)	Josh
Week4 (first half)	Generate speedup graph with performance of sequential version and aforementioned implementation. Analyze differences in performance gain with dynamic and static assignment	Both
	Implement parallelization algorithm over batches of cells using shared address space model (dynamic vs static assignment)	Vincy
Week4 (second half)	Generate speedup graph with performance of sequential version and all parallelized implementations. Analyze differences in performance gain between parallelization strategies.	Josh
	Implement parallelization algorithm over individual sections of the vessel using shared address space within each section and message passing between sections - potentially changing the data storage pattern	Both
Week5 (first half)	Finish off the implementation and generate speedup graphs with the performance of sequential version and all parallelized implementations. Analyze differences in performance gain between parallelization strategies.	Both
Week5 (second half)	Create visualization for simulation	Both

We have successfully implemented the initial sequential version of the simulation. This version processes data from a random text file, which is generated by a custom Python script, which sets up initial conditions such as cell positions and velocities. Our simulation then takes over and processes each timestep iteratively. During each timestep, the simulation performs multiple critical functions:

Collision Detection: It checks for collisions both between cells and between cells and the vessel walls.

Trajectory Adjustment: It adjusts the trajectories of the cells based on computed velocity profiles and flow rates. Also, after any collision (either collision between cells or the collision between the cell and the vessel wall), the simulation recalculates and corrects the trajectories of the involved cells to reflect realistic physical responses.

Tracking Cell Movement: Cells are continuously tracked until they exit the bounds of the vessel, at which point they are removed from the simulation.

We might be slightly behind our goals and deliverables as the initial modeling process took us much more time than expected. However, given that the sequential version is completed, we do believe the process of trying different parallelization strategies should be more straightforward. At this point in time, we have realized the importance of performance as such a simulation requires a long time to process. We have also realized the relative insignificance of visualization. Therefore, we would like to shift our attention to testing different parallelization strategies. At the same time, we have also realized the inadequacy of using GPUs. Since the simulation process involves frequent collision checking. This potential creates divergence in data flow, which is inappropriate for using GPUs. Therefore, we have revised our goals and deliverables to the following:

• A sequential version of the simulation
• Parallelization algorithm over individual cells using shared address space model (dynamic vs static assignment)
• Parallelization algorithm over batches of cells using shared address space model (dynamic vs static assignment)
• Parallelization algorithm over individual sections of the vessel using shared address space within each section and message passing between sections - potentially changing the data storage pattern
• The computation time of all the above implementations and speedup graph
• Analysis to identify potential bottlenecks
• Visualization of blood cells through a vessel

If we end up having time to apply visualization, we will be showing a short video of blood cells moving through the blood vessel. In all cases, we plan to show speedup graphs comparing the performance of the different parallelization strategies. During the poster session, we will provide an analysis of those speedup graphs and go through the parallelization choices we made along the way.

Validity checking: Since our simulation involves the dynamic motion of blood cells and the vessel, we have limited information that could be used to verify if the simulation is valid. So far, in an effort to generate a checker, we tried to output information at the end of the simulation. The information isn't related to each cell in particular but pertains to some general attributes that could be generated through the input text file separately. As a result, we could compare the output from the simulation against the benchmark we’ve generated separately. This comparison gives us more confidence in the validity of the simulation. However, we are still looking for more concrete ways of testing.

Optimization and Parallelization: While our simulation seems can employ different parallel processing techniques to optimize computational load, there is a concern that our approach may not be fully optimized, potentially leading to suboptimal performance scalability.