marcorealacci/master-degree-notes
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

vault backup: 2025-04-04 23:35:23

Browse source
This commit is contained in:
Marco Realacci 2025-04-04 23:35:23 +02:00
parent 96872ffa06
commit 6a9cf80167
13 changed files with 28 additions and 28 deletions
Download patch file Download diff file Expand all files Collapse all files

12
.obsidian/workspace.json vendored
View file

@ -13,12 +13,12 @@
"state": { "state": {
"type": "markdown", "type": "markdown",
"state": { "state": {
"file": "Concurrent Systems/notes/1 - CS Basics.md", "file": "Concurrent Systems/notes/2 - Fast mutex by Lamport.md",
"mode": "source", "mode": "source",
"source": false "source": false
}, },
"icon": "lucide-file", "icon": "lucide-file",
"title": "1 - CS Basics" "title": "2 - Fast mutex by Lamport"
} }
}, },
{ {
@ -201,8 +201,11 @@
"companion:Toggle completion": false "companion:Toggle completion": false
} }
}, },
"active": "2b2245f56092006e", "active": "7c5b0ca6f7687800",
"lastOpenFiles": [ "lastOpenFiles": [
"Concurrent Systems/notes/3a - Hardware primitives & Lamport Bakery algorithm.md",
"Concurrent Systems/notes/2 - Fast mutex by Lamport.md",
"Concurrent Systems/notes/1 - CS Basics.md",
"Concurrent Systems/ignore this folder/Untitled.md", "Concurrent Systems/ignore this folder/Untitled.md",
"Concurrent Systems/notes/4 - Semaphores.md", "Concurrent Systems/notes/4 - Semaphores.md",
"Foundation of data science/notes/9 XGBoost.md", "Foundation of data science/notes/9 XGBoost.md",
@ -216,8 +219,6 @@
"HCIW/notes/2 - Interface and Interaction for IoT.md", "HCIW/notes/2 - Interface and Interaction for IoT.md",
"Concurrent Systems/notes/10 - Implementing Consensus.md", "Concurrent Systems/notes/10 - Implementing Consensus.md",
"Concurrent Systems/notes/5 - Software Transactional Memory.md", "Concurrent Systems/notes/5 - Software Transactional Memory.md",
"Concurrent Systems/notes/2 - Fast mutex by Lamport.md",
"Concurrent Systems/notes/1 - CS Basics.md",
"Concurrent Systems/notes/1b - Peterson algorithm.md", "Concurrent Systems/notes/1b - Peterson algorithm.md",
"Concurrent Systems/notes/2b - Round Robin algorithm.md", "Concurrent Systems/notes/2b - Round Robin algorithm.md",
"Concurrent Systems/notes/3b - Aravind's algorithm and improvements.md", "Concurrent Systems/notes/3b - Aravind's algorithm and improvements.md",
@ -229,7 +230,6 @@
"Concurrent Systems/notes/6a - Alternatives to Atomicity.md", "Concurrent Systems/notes/6a - Alternatives to Atomicity.md",
"Concurrent Systems/notes/4b - Monitors.md", "Concurrent Systems/notes/4b - Monitors.md",
"Concurrent Systems/notes/4c - Dining Philosophers.md", "Concurrent Systems/notes/4c - Dining Philosophers.md",
"Concurrent Systems/notes/3a - Hardware primitives & Lamport Bakery algorithm.md",
"Concurrent Systems/slides/class 4.pdf", "Concurrent Systems/slides/class 4.pdf",
"Concurrent Systems/slides/class 9.pdf", "Concurrent Systems/slides/class 9.pdf",
"Concurrent Systems/slides/class 10.pdf", "Concurrent Systems/slides/class 10.pdf",

2
Concurrent Systems/notes/1 - CS Basics.md
View file

@ -100,7 +100,7 @@ Every solution to a problem should satisfy at least:
**Both inclusions are strict:** **Both inclusions are strict:**
$$\text{Deadlock freedom} \not \implies \text{Starvation freedom}$$ $$\text{Deadlock freedom} \not \implies \text{Starvation freedom}$$
![[Pasted image 20250303093116.png]] ![[images/Pasted image 20250303093116.png]]
*p1 is starving!* *p1 is starving!*
$$\text{Starvation freedom} \not \implies \text{Bounded bypass}$$ $$\text{Starvation freedom} \not \implies \text{Bounded bypass}$$
Assume a $f$ and consider the scheduling above, where p2 wins $f(3)$ times and so does p3, then p1 looses (at least) $2f(3)$ times before winning. Assume a $f$ and consider the scheduling above, where p2 wins $f(3)$ times and so does p3, then p1 looses (at least) $2f(3)$ times before winning.

4
Concurrent Systems/notes/10 - Implementing Consensus.md
View file

@ -30,7 +30,7 @@ A configuration C obtained during the execution of all A is called:
If A wait-free implements binary consensus for n processes, then there exists a bivalent initial configuration. If A wait-free implements binary consensus for n processes, then there exists a bivalent initial configuration.
*Proof:* *Proof:*
![[Pasted image 20250401083747.png]] ![[images/Pasted image 20250401083747.png]]
### CN(Atomic R/W registers) = 1 ### CN(Atomic R/W registers) = 1
**Thm:** There exists no wait-free implementation of binary consensus for 2 processes that uses atomic R/W registers. **Thm:** There exists no wait-free implementation of binary consensus for 2 processes that uses atomic R/W registers.
@ -135,7 +135,7 @@ propose(i, v) :=
Let us consider a verison of the compare&swap where, instead of returning a boolean, it always returns the previous value of the object, i.e.: Let us consider a verison of the compare&swap where, instead of returning a boolean, it always returns the previous value of the object, i.e.:
![[Pasted image 20250401092557.png]] ![[images/Pasted image 20250401092557.png]]
``` ```
CS a compare&swap object init at ⊥ CS a compare&swap object init at ⊥

6
Concurrent Systems/notes/1b - Peterson algorithm.md
View file

@ -53,10 +53,10 @@ unlock(i) :=
**How has p0 entered its CS?** **How has p0 entered its CS?**
a) `FLAG[1] = down`, this is possible only with the following interleaving: a) `FLAG[1] = down`, this is possible only with the following interleaving:
![[Pasted image 20250303100721.png]] ![[images/Pasted image 20250303100721.png]]
b) `AFTER_YOU = 1`, this is possible only with the following interleaving: b) `AFTER_YOU = 1`, this is possible only with the following interleaving:
![[Pasted image 20250303100953.png]] ![[images/Pasted image 20250303100953.png]]
##### Bounded Bypass proof (with bound = 1) ##### Bounded Bypass proof (with bound = 1)
- If the wait condition is true, then it wins (and waits 0). - If the wait condition is true, then it wins (and waits 0).
@ -140,7 +140,7 @@ Easy to generalize to k-MUTEX.
Peterson's algorithm cost $O(n^2)$ Peterson's algorithm cost $O(n^2)$
A first way to reduce this cost is by using a tournament of MUTEX between pairs of processes: A first way to reduce this cost is by using a tournament of MUTEX between pairs of processes:
![[Pasted image 20250304082459.png|350]] ![[images/Pasted image 20250304082459.png|350]]
Of course this is a binary tree, and the height of a binary tree is logaritmic to the number of leaves. A process then wins after $\lceil \log_{2}n \rceil$ competitions $\to O(\log n)$ cost. Of course this is a binary tree, and the height of a binary tree is logaritmic to the number of leaves. A process then wins after $\lceil \log_{2}n \rceil$ competitions $\to O(\log n)$ cost.

6
Concurrent Systems/notes/2 - Fast mutex by Lamport.md
View file

@ -49,9 +49,9 @@ unlock(i) :=
##### MUTEX proof ##### MUTEX proof
How can pi enter its CS? How can pi enter its CS?
![[Pasted image 20250304084537.png]] ![[images/Pasted image 20250304084537.png]]
![[Pasted image 20250304084901.png]] ![[images/Pasted image 20250304084901.png]]
(*must finished before nel senso che $p_i$ deve aspettare $p_j$*) (*must finished before nel senso che $p_i$ deve aspettare $p_j$*)
##### Deadlock freedom ##### Deadlock freedom
Let $p_i$ invoke lock Let $p_i$ invoke lock
@ -72,6 +72,6 @@ Let $p_i$ invoke lock
- In the second wait Y = ⊥: but then there exists a $p_h$ that eventually enters its CS -> good - In the second wait Y = ⊥: but then there exists a $p_h$ that eventually enters its CS -> good
- In the ∀j.wait FLAG[j]=down: this wait cannot block a process forever - In the ∀j.wait FLAG[j]=down: this wait cannot block a process forever
![[Pasted image 20250304090219.png]] ![[images/Pasted image 20250304090219.png]]
esercizio: prova che NON soddisfa starvation freedom esercizio: prova che NON soddisfa starvation freedom

2
Concurrent Systems/notes/2b - Round Robin algorithm.md
View file

@ -50,5 +50,5 @@ By Deadlock freedom of RR, at least one process eventually unlocks
The worst case is when TURN = *i+1* mod n when FLAG[i] is set. The worst case is when TURN = *i+1* mod n when FLAG[i] is set.
![[Pasted image 20250304093223.png]] ![[images/Pasted image 20250304093223.png]]

4
Concurrent Systems/notes/3b - Aravind's algorithm and improvements.md
View file

@ -31,7 +31,7 @@ unlock(i) :=
*Proof:* by contradiction. *Proof:* by contradiction.
Let's consider the execution of $p_i$ leading to its CS: Let's consider the execution of $p_i$ leading to its CS:
![[Pasted image 20250310172134.png]] ![[images/Pasted image 20250310172134.png]]
**Corollary** (of the MUTEX proof)**:** DATE is never written concurrently. **Corollary** (of the MUTEX proof)**:** DATE is never written concurrently.
@ -57,7 +57,7 @@ Let's consider the execution of $p_i$ leading to its CS:
**Theorem:** the algorithm satisfies bounded bypass with bound $2n-2$. **Theorem:** the algorithm satisfies bounded bypass with bound $2n-2$.
*Proof:* *Proof:*
![[Pasted image 20250310103703.png]] ![[images/Pasted image 20250310103703.png]]
so by this, the very worst possible case is that my lock experiences that. so by this, the very worst possible case is that my lock experiences that.
It looks like I can experience at most $2n-1$ other critical sections, but it is even better, let's see: It looks like I can experience at most $2n-1$ other critical sections, but it is even better, let's see:

2
Concurrent Systems/notes/4 - Semaphores.md
View file

@ -180,7 +180,7 @@ producer A:
- so producer A will write at `BUF[0]` - so producer A will write at `BUF[0]`
- but wait! Consumer B is still reading there - but wait! Consumer B is still reading there
- **Producer A doesn't give a fuck.** - **Producer A doesn't give a fuck.**
![[Pasted image 20250312121828.png|200]] ![[images/Pasted image 20250312121828.png|200]]
*don't be like Producer A, be more like Bob, who always scans EMPTY before!* *don't be like Producer A, be more like Bob, who always scans EMPTY before!*
So the issue here is that producers just assume that IN is the first available slot. But it its not necessarily the case. So the issue here is that producers just assume that IN is the first available slot. But it its not necessarily the case.

2
Concurrent Systems/notes/4c - Dining Philosophers.md
View file

@ -3,7 +3,7 @@ The first real practical example of a concurrent system.
- one chopstick between each pair of philosophers - one chopstick between each pair of philosophers
- a philosophers must pick up its two nearest chopsticks in order to eat - a philosophers must pick up its two nearest chopsticks in order to eat
- a philosopher must pick up first one chopstick, then the second one, not both at once - a philosopher must pick up first one chopstick, then the second one, not both at once
![[Pasted image 20250317100456.png|100]] ![[images/Pasted image 20250317100456.png|100]]
**PROBLEM:** *Devise a deadlock-free algorithm for allocating these limited resources (chopsticks) among several processes (philosophers).* **PROBLEM:** *Devise a deadlock-free algorithm for allocating these limited resources (chopsticks) among several processes (philosophers).*

2
Concurrent Systems/notes/5 - Software Transactional Memory.md
View file

@ -105,7 +105,7 @@ The **casual past** of a transaction T is the set of all T' and T'' such that
VWC allows more transactions to commit -> it is a more liberal property than opacity. VWC allows more transactions to commit -> it is a more liberal property than opacity.
![[Pasted image 20250317105355.png]] ![[images/Pasted image 20250317105355.png]]
#### A Vector clock based STM system #### A Vector clock based STM system
We have m shared MRMW registers; register X is represented by a pair XX, with: We have m shared MRMW registers; register X is represented by a pair XX, with:

4
Concurrent Systems/notes/6 - Atomicity.md
View file

@ -21,9 +21,9 @@ A complete history $\hat{H}$ is **linearizable** if there exists a sequential hi
Given an history $\hat{K}$, we can define a binary relation on events $⟶_{K}$ s.t. (op, op’) ∈ ⟶K if and only if res[op] <K inv[op’]. We write op ⟶K op’ for denoting (op, op’) ∈ ⟶K. Hence, condition 3 of the previous Def. requires that ⟶H ⊆ ⟶S. Given an history $\hat{K}$, we can define a binary relation on events $⟶_{K}$ s.t. (op, op’) ∈ ⟶K if and only if res[op] <K inv[op’]. We write op ⟶K op’ for denoting (op, op’) ∈ ⟶K. Hence, condition 3 of the previous Def. requires that ⟶H ⊆ ⟶S.
![[Pasted image 20250318090733.png]] ![[images/Pasted image 20250318090733.png]]
![[Pasted image 20250318090909.png]]But there is another linearization possible! I can also push a before if I pull it before c! ![[images/Pasted image 20250318090909.png]]But there is another linearization possible! I can also push a before if I pull it before c!
Of course I have to respect the semantics of a Queue (if I push "a" first, I have to pop "a" first because it's a fucking FIFO) Of course I have to respect the semantics of a Queue (if I push "a" first, I have to pop "a" first because it's a fucking FIFO)
#### Compositionality theorem #### Compositionality theorem

4
Concurrent Systems/notes/6a - Alternatives to Atomicity.md
View file

@ -2,9 +2,9 @@ Let us define $op ->_{proc} op'$ to hold whenever there exists a process p that
### Sequential consistency ### Sequential consistency
**Def:** a complete history is sequentially consistent if there exists a sequential history $𝑆$ s.t. **Def:** a complete history is sequentially consistent if there exists a sequential history $𝑆$ s.t.
![[Pasted image 20250324082534.png]] ![[images/Pasted image 20250324082534.png]]
![[Pasted image 20250324082545.png]] ![[images/Pasted image 20250324082545.png]]
>[!warning] >[!warning]
>The problem with sequential consistency is that it is NOT compositional. >The problem with sequential consistency is that it is NOT compositional.

6
Concurrent Systems/notes/7- MUTEX-free concurrency.md
View file

@ -64,7 +64,7 @@ this implementation satisfies the three requirements for the splitter
- let us consider the last process that writes into LAST (this is an atomic register, so this is meaningful) - let us consider the last process that writes into LAST (this is an atomic register, so this is meaningful)
- if the door is closed, it receives R and √ - if the door is closed, it receives R and √
3. let $p_i$ be the first process that receives $S \to LAST=i$ in its second if 3. let $p_i$ be the first process that receives $S \to LAST=i$ in its second if
![[Pasted image 20250324091452.png]] ![[images/Pasted image 20250324091452.png]]
### An Obstruction-free Timestamp Generator ### An Obstruction-free Timestamp Generator
A **timestamp generator** is a concurrent object that provides a single operation get_ts such that: A **timestamp generator** is a concurrent object that provides a single operation get_ts such that:
@ -98,7 +98,7 @@ this implementation satisfies the three properties of the timestamp generator
- every process that starts after its termination will find NEXT to a greater value (NEXT never decreases!) - every process that starts after its termination will find NEXT to a greater value (NEXT never decreases!)
3. Obstruction freedom is trivial 3. Obstruction freedom is trivial
**REMARK:** this implementation doesn’t satisfy the non-blocking property:![[Pasted image 20250324092633.png]] **REMARK:** this implementation doesn’t satisfy the non-blocking property:![[images/Pasted image 20250324092633.png]]
### A Wait-free Stack ### A Wait-free Stack
REG is an unbounded array of atomic registers (the stack) REG is an unbounded array of atomic registers (the stack)
@ -149,7 +149,7 @@ This is needed for the so called ABA problem with compare&set:
- with the compare&set you mainly test that the sequence_number has not changed - with the compare&set you mainly test that the sequence_number has not changed
TOP : a register that can be read or compare&setted TOP : a register that can be read or compare&setted
![[Pasted image 20250324100652.png]] ![[images/Pasted image 20250324100652.png]]
``` ```
push(w) := push(w) :=