Parallelism Revisions #83

jespiron · 2025-04-02T02:13:22Z

Recover from #43

This is a rewrite of the first half, with the goal of making the second half easier to understand

Main change:

Introduces a real-world example, of circle rendering, to situate the concepts (inter-thread communication, data races)
Add motivating example for thread::scope

Smaller changes:

Explain atomics before second half's Arc
Added advice + considerations that I personally find useful
Added speaker notes for second half. Second half can benefit from revisions too, but we'll do that in a separate pass

Copilot

Copilot reviewed 3 out of 3 changed files in this pull request and generated no comments.

connortsui20 · 2025-04-03T20:28:40Z

Copilot reviewed 3 out of 3 changed files in this pull request and generated no comments.

I never enabled Copilot so I have no idea why this is here

connortsui20

I like this outline a lot! I think it makes the flow of the lecture quite nice. However, I think something that Ben did well to make up for that was that he explained a lot of stuff that was not actually on the slides. Additionally, in the past semesters we've had older students who were already familiar with this. So I think we can allocate a good amount of time to going through the why and what of parallelism before the how.

week12/parallelism.md

connortsui20 · 2025-04-03T20:33:38Z

week12/parallelism.md

+* 8 cores, 8 threads
+* 4 threads load the webpage, 4 threads update the progress bar

 </div>
 <div>

-## Concurrency
+## Alternate Concurrency Model
+
+* 1 core, 1 thread
+* When blocked on loading the webpage, update the progress bar
+


I think these examples could be improved, for example Im sure there are other more intuitive ways to split up 8 workers in general.

Also remember that some people in the class have never even seen threads before. So I think try to stick to higher-level examples like multiple people working on one thing vs one person working on many things

Originally, I preserved the old lecture's example, but we can go higher-level because of the shifted demographics this semester.

The point of this slide is really just that parallelism => # of threads > 1

I've opted to go directly to the diagram slide, with a high-level explanation like "In parallelism, you have three people: one taking orders, one cooking, and one serving. In some concurrency models, you have one person alternating between these tasks..."

week12/parallelism.md

connortsui20 · 2025-04-03T20:35:04Z

week12/parallelism.md

+```
+* `thread::spawn` takes a function as argument
+  * This is the function that the thread runs
+* We can spawn multiple of these, to run multiple functions at once


We can spawn multiple threads (but we cannot spawn multiple of the same closure because they are FnOnce

Very valuable point, I would save that for the second half when we talk about the Rust-specific implementation.
See "# Creating Threads, In More Detail" - this slide is a copy from old lecture, except I hid the Rust-specific details (FnOnce, Send, JoinHandle type)

Purpose of this slide is to give a gist of how threads are used, independent of language implementation

Ok, I added it to second half

week12/parallelism.md

connortsui20 · 2025-04-03T20:38:39Z

week12/parallelism.md

+* We can spawn multiple of these, to run multiple functions at once
+
+
+---


I think I would like to see an example of threads here before you talk about (potentially) complex communication protocols.

Could you copy the example from the book? https://rust-book.cs.brown.edu/ch16-01-threads.html#creating-a-new-thread-with-spawn

This is a super simple example but again, remember that some people have never seen this before.

At the very least, I would like to see everything on that first section of that chapter in this lecture near the beginning, with the exception that you can somewhat handwave how join works.

This is the same example as the book's, condensed to show only the thread::spawn call.

I see value in expanding it out like the book, especially the println outputs. Can definitely do

Alright, I expanded out this first half's example and elaborated on join in second half

week12/parallelism.md

jespiron · 2025-04-07T11:38:28Z

!remind me

discuss thread::scope

jespiron · 2025-04-07T13:56:21Z

Okay, I added an example for thread::scope.
It should help them with the RowLab homework. It also better contextualizes Arc+Mutex, by framing them under a shared problem

connortsui20

Very nice job! I think the flow of the lecture is super clear and the specific concepts are great for this lecture.

I've ignored some nits and things that need to be cleaned up since I'll just do those on Wednesday before lecture. The biggest thing that can be improved is examples of actually using Rust code for parallelism.

connortsui20 · 2025-04-07T14:08:51Z

week12/parallelism.md

+# Example: Creating a Thread
+
+We can create ("spawn") more threads with `thread::spawn`:
+
+```rust
+let handle = thread::spawn(|| {
+    for i in 1..10 {
+        println!("working on item {} from the spawned thread!", i);
+        thread::sleep(Duration::from_millis(1));
+    }
+});
+
+for i in 1..5 {
+    println!("working on item {i} from the main thread!");
+    thread::sleep(Duration::from_millis(1));
+}
+```
+
+* `thread::spawn` takes a closure as argument
+  * This is the function that the thread runs


It would be nice to see a few examples of this running without joining, because it shows the non-determinism of multithreading.

I actually added it, then deleted here: b5f50cb

it was out of timing concerns, could one of you or @Fiona-CMU add it back where you see fit?

connortsui20 · 2025-04-07T14:09:21Z

week12/parallelism.md

+
+handle.join().unwrap();
+```
+
+* Blocks the current thread until the thread associated with `handle` finishes
+


And by showing the example without joining you can motivate why we have joining in the first place

Yes it’s here b5f50cb

connortsui20 · 2025-04-07T14:10:18Z

week12/parallelism.md

+```
+
+* When a thread touches a pixel, increment the pixel's associated `x`
+* Now each thread knows how many layers of paint on that pixel has


Now each thread knows how many layers of paint there are on that pixel

connortsui20 · 2025-04-07T14:11:13Z

week12/parallelism.md

+First ingredient: `x` is in shared memory, and `x` must satisfy some property to be correct.
+
+```c
+// x is # of times *any* thread has called `update_x`


Maybe include a forward declaration of update_x?

Also we could say:

// Invariant: `x` is the total number of times **any** thread has called `update_x`.

connortsui20 · 2025-04-07T14:11:36Z

week12/parallelism.md

+
+# Shared Memory: Data Races
+
+Suppose we have a shared variable `x`.
+
+```c
+static int x = 0;
+```
+
+* This is C pseudocode; we'll explain Rust's interface in second half


I think this slide can be merged into the next one, the previous slides showed this code anyways

connortsui20 · 2025-04-07T14:19:08Z

week12/parallelism.md

+* `fetch_and_add`: performs the operation suggested by the name, and returns the value that was previously in memory
+  * Also `fetch_and_sub`, `fetch_and_or`, `fetch_and_and`, ...


These should be Rust code slide examples

connortsui20 · 2025-04-07T14:20:09Z

week12/parallelism.md

+Other common atomic is `compare_and_swap`
+* If the current value matches some old value, then write new value into memory
+  * Depending on variant, returns a boolean for whether new value was written into memory
+* "Lock-free" programming:
+  * No locks! Just `compare_and_swap` until we successfully write new value
+  * Not necessarily more performant than lock-based solutions
+    * Contention is bottleneck, not presence of locks


I think that we should probably keep this simple and skip past this during lecture. Call this a "sneak peek of CAS" and leave this here for people who are interested to read later

connortsui20 · 2025-04-07T14:20:38Z

week12/parallelism.md

+# Atomics
+
+Rust provides atomic primitive types, like `AtomicBool`, `AtomicI8`, `AtomicIsize`, etc.
+* Provides a way to access values atomically from any thread
+  * Safe to share between threads implementing `Sync`
+* We won't cover it further in this course, but the API is largely 1:1 with the C++20 atomics
+  * If interested in pitfalls, read up on *memory ordering* in computer systems


This should come directly after the proposed Rust Atomics slide example

connortsui20 · 2025-04-07T14:21:17Z

week12/parallelism.md

+* Approach 2: Message Passing
+  * Eliminates shared memory


connortsui20 · 2025-04-07T14:23:07Z

week12/parallelism.md

+* The Scope object `s` has a lifetime tied to the `thread::scope` call
+  * The closure *cannot* smuggle a reference to borrowed data outside this lifetime
+  * You *cannot* return thread handles (`t1`, `t2`) outside the scope


This goes off the edge of the slide

jespiron · 2025-04-08T12:25:41Z

Thank you Fiona for the additions! Merging this so we pick it up at #85

recover from #43

5794db2

jespiron mentioned this pull request Apr 2, 2025

Parallelism Revisions #43

Closed

jespiron added 5 commits April 1, 2025 23:17

dedup

f5664ae

discuss lock-free vs lock-based, address comments

900a2ba

revamp first half, add diagrams

a5ea700

rewrite second half w/ more motivation

120ed98

clean up speaker notes

4e70486

jespiron marked this pull request as ready for review April 3, 2025 19:53

jespiron requested a review from Copilot April 3, 2025 19:53

Copilot AI reviewed Apr 3, 2025

View reviewed changes

jespiron requested review from connortsui20, Fiona-CMU and YHTerrance April 3, 2025 19:53

format

b8d1b04

connortsui20 requested changes Apr 3, 2025

View reviewed changes

Fiona-CMU reviewed Apr 5, 2025

View reviewed changes

week12/parallelism.md Outdated Show resolved Hide resolved

week12/parallelism.md Outdated Show resolved Hide resolved

week12/parallelism.md Show resolved Hide resolved

jespiron added 4 commits April 5, 2025 16:02

remove div

1f85f90

address comments

15468ac

add more detailed example

07bf294

elaborate on join in second half

c01f1a5

jespiron requested a review from connortsui20 April 5, 2025 22:02

jespiron added 5 commits April 7, 2025 08:58

order

6517f55

add motivating example for thread::scope

3603504

delete joining threads from second half

b5f50cb

correction

43beef3

clean

76cb328

connortsui20 requested changes Apr 7, 2025

View reviewed changes

Fiona-CMU added 3 commits April 7, 2025 15:05

quiz syntax, grammer fixes

539926a

adding examples, making some edits to the second half

da1dfc7

add rust atomics example

0467fa8

jespiron merged commit bc753b4 into main Apr 8, 2025

jespiron deleted the jess/parallelism-revisions branch April 8, 2025 12:26

connortsui20 restored the jess/parallelism-revisions branch April 8, 2025 13:50

connortsui20 deleted the jess/parallelism-revisions branch April 8, 2025 13:54

connortsui20 mentioned this pull request Apr 8, 2025

Refactor parallelism #86

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Parallelism Revisions #83

Parallelism Revisions #83

jespiron commented Apr 2, 2025 •

edited

Loading

Copilot AI left a comment

connortsui20 commented Apr 3, 2025

connortsui20 left a comment

connortsui20 Apr 3, 2025

jespiron Apr 5, 2025 •

edited

Loading

connortsui20 Apr 3, 2025

jespiron Apr 5, 2025 •

edited

Loading

jespiron Apr 5, 2025

connortsui20 Apr 3, 2025

jespiron Apr 5, 2025

jespiron Apr 5, 2025

jespiron commented Apr 7, 2025

jespiron commented Apr 7, 2025

connortsui20 left a comment

connortsui20 Apr 7, 2025

jespiron Apr 7, 2025

connortsui20 Apr 7, 2025

jespiron Apr 7, 2025

connortsui20 Apr 7, 2025

connortsui20 Apr 7, 2025

connortsui20 Apr 7, 2025

connortsui20 Apr 7, 2025

connortsui20 Apr 7, 2025

connortsui20 Apr 7, 2025

connortsui20 Apr 7, 2025

connortsui20 Apr 7, 2025

jespiron commented Apr 8, 2025

		* We can spawn multiple of these, to run multiple functions at once


		---

		* `fetch_and_add`: performs the operation suggested by the name, and returns the value that was previously in memory
		* Also `fetch_and_sub`, `fetch_and_or`, `fetch_and_and`, ...

Parallelism Revisions #83

Parallelism Revisions #83

Conversation

jespiron commented Apr 2, 2025 • edited Loading

Copilot AI left a comment

Choose a reason for hiding this comment

connortsui20 commented Apr 3, 2025

connortsui20 left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jespiron Apr 5, 2025 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jespiron Apr 5, 2025 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jespiron commented Apr 7, 2025

jespiron commented Apr 7, 2025

connortsui20 left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jespiron commented Apr 8, 2025

jespiron commented Apr 2, 2025 •

edited

Loading

jespiron Apr 5, 2025 •

edited

Loading

jespiron Apr 5, 2025 •

edited

Loading