-
Notifications
You must be signed in to change notification settings - Fork 3
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
Showing
927 changed files
with
246,429 additions
and
5,175 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,97 @@ | ||
| --- | ||
| title: "CS139-lecture-20211021" | ||
| # date: 2021-10-21T13:19:01-07:00 | ||
| draft: false | ||
| bookToc: true | ||
| tags: ["synchronization", "semaphores"] | ||
| --- | ||
|
|
||
| ## Process synchronization | ||
|
|
||
|  | ||
|  | ||
|  | ||
|
|
||
| ### Race condition | ||
|
|
||
|  | ||
|  | ||
|  | ||
|  | ||
|
|
||
| ### Critical selection and mutual exclusion | ||
|
|
||
|  | ||
|
|
||
| In the above code examples, the `counter++` and `counter--` are considered a critical section. | ||
|
|
||
|  | ||
|  | ||
|  | ||
|  | ||
|  | ||
|  | ||
|  | ||
|
|
||
| ### How to implement mutual exclusion | ||
|
|
||
|  | ||
|  | ||
|  | ||
|
|
||
| {{< hint info >}} | ||
| Note: This solution isn't fully correct. | ||
| {{< /hint >}} | ||
|
|
||
| ``` | ||
| producer: | ||
| while (lock == 0) | ||
| lock = 1 | ||
| put | ||
| lock = 0 | ||
| consumer: | ||
| while (lock == 0) | ||
| lock = 1 | ||
| fetch | ||
| lock = 0 | ||
| ``` | ||
|
|
||
| The problem with this code is that if the OS does a context switch during a critical section, it can create an error. | ||
|
|
||
|  | ||
|  | ||
|
|
||
| One solution is to disable interrupts. | ||
|
|
||
|  | ||
|  | ||
|
|
||
| ### Sync hardware, spin locks and compare-and-swap | ||
|
|
||
|  | ||
|  | ||
|  | ||
|  | ||
|  | ||
|
|
||
| ### Mutex locks | ||
|
|
||
| Mutex locks allow the OS to provide a mutual exclusion as a service. | ||
|
|
||
|  | ||
|  | ||
|  | ||
|
|
||
| ### Semaphores | ||
|
|
||
|  | ||
|
|
||
| A semaphore is simply a non-negative interger that has two valid operations. | ||
|
|
||
|  | ||
|  | ||
|  | ||
|  | ||
|  | ||
|
|
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,128 @@ | ||
| --- | ||
| title: "CS139-lecture-20211026" | ||
| # date: 2021-10-26T13:15:48-07:00 | ||
| draft: false | ||
| bookToc: true | ||
| tags: ["synchronization", "semaphores"] | ||
| --- | ||
|
|
||
| ## Synchronization cont. | ||
|
|
||
|
|
||
|  | ||
|
|
||
| Since these could output in any order, we can setup semaphores to ensure the run order. | ||
|
|
||
|  | ||
|
|
||
| ### Bounded buffer problem | ||
|
|
||
|  | ||
|
|
||
| - `full` and `empty` are counting semaphores. | ||
| - `full` notifies consumers how many items are there | ||
| - `empty` notifies producers how many empty slots available | ||
| - `mutex` is a binary semaphore. | ||
|
|
||
|  | ||
|
|
||
| - `mutex` starts at 1, "unlocked", so the first process can have mutual exclusion | ||
| - `full` is set to 0, and `empty` is set to n, because all slots are available | ||
|
|
||
|  | ||
|  | ||
|
|
||
| - The first `wait(empty)` checks if there is an empty slot | ||
| - `wait(mutex)` checks if there is a process accessing the shared buffer | ||
| - `wait(full)` checks if there is any items to consume | ||
|
|
||
| Consider switching the order of the first to `wait` functions, to: | ||
|
|
||
| ``` | ||
| wait(mutex); | ||
| wait(empty); | ||
| ``` | ||
|
|
||
| This would have the consequences of being able to get mutual exclusion first, then all other processes would be prevented from running. | ||
| But then if the buffer is already full it won't ever get past the `wait(empty)`. | ||
| So, the order cannot be swapped. | ||
|
|
||
| Next, consider switching the order of the `signal` functions: | ||
|
|
||
| ``` | ||
| signal(full); | ||
| signal(mutex); | ||
| ``` | ||
|
|
||
| This is actually okay because the order of the unlock does not matter as much. | ||
| The other process is waiting for both locks to continue. | ||
|
|
||
|  | ||
|  | ||
|  | ||
|
|
||
| ### The readers writers problem | ||
|
|
||
|  | ||
|
|
||
| This is a slight difference in the producer consumer problem, because readers actually don't change the shared buffer (just read it). | ||
| Also, any number of readers can access data simultaneously. | ||
|
|
||
|  | ||
|
|
||
| - multiple readers are reading database | ||
| - new readers may join | ||
| - new writer must waiting | ||
|
|
||
|  | ||
|
|
||
| - new readers must wait | ||
| - new writers must wait | ||
|
|
||
|  | ||
|
|
||
| - if a new writer arrives at {{<k>}} t = 1 {{</k>}}, it waits | ||
| - if a new reader arrives at {{<k>}} t=2 {{</k>}}, there are 2 variations: | ||
| - skip the line and join the other readers, prioritizing readers | ||
| - wait behind the writer, prioritizing writers | ||
|
|
||
|  | ||
|  | ||
|
|
||
| Why ensure mutual exclusion for updating `readcount`? | ||
| We need to make sure that the `readcount` variable is being updated atomically. | ||
|
|
||
| {{< hint info >}} | ||
| Note: The solution to the second readers writers problem (prioritizing writers) is more complex. | ||
| It requires five variables. | ||
| {{< /hint >}} | ||
|
|
||
| ### The dining philosophers problem | ||
|
|
||
|  | ||
|  | ||
|  | ||
|
|
||
| - you can only use your adjacent chopsticks | ||
| - you can only pick up one chopstick each turn | ||
| - you can eat when you have both chopsticks | ||
| - the goal is to order the picking up and placing of chopsticks without deadlock or starvation | ||
|
|
||
| So if everyone starts by picking up the left chopstick, then the right chopstick, it will end up in deadlock. | ||
|
|
||
| We can treat each philosopher as a process, and the chopstick as a competing resource. | ||
|
|
||
|  | ||
|
|
||
| - `wait(fork[i])` waits for the left chopstick | ||
| - `wait(fork[i+1 % 5]);` waits for the right chopstick | ||
| - then they may eat | ||
| - then they put the chopsticks back down right then left using the `signal` functions | ||
| - however, this current state results in deadlock | ||
|
|
||
| {{< hint info >}} | ||
| Note: `fork` here is the chopstick, for brevity. | ||
| {{< /hint >}} | ||
|
|
||
|  | ||
|
|
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,163 @@ | ||
| --- | ||
| title: "CS140-lecture-20211014" | ||
| # date: 2021-10-14T14:03:41-07:00 | ||
| draft: false | ||
| bookToc: true | ||
| tags: ["recurrences", "quicksort"] | ||
| --- | ||
|
|
||
| ## Recurrences cont | ||
|
|
||
| ### Recursion tree method | ||
|
|
||
| Another method to solve recurrences is to draw a recursion tree, where each node gets a cost. | ||
| The cost of each node is the additional work done on each recursive call (not recursive call itself). | ||
|
|
||
|  | ||
|
|
||
| The leaf nodes are the base cases. | ||
| The idea is to identify a pattern, and use a known series to evaluate that pattern. | ||
|
|
||
|  | ||
|
|
||
| Then, after identifying the sum of each level of the tree, you then sum all the level's themselves (except the base level, the leaves). | ||
| Notice that the height of this tree is {{<k>}} \lg n {{</k>}}. | ||
| We can sum all the levels up to the last one (notice that {{<k>}} k {{</k>}} goes to {{<k>}} \lg n {{</k>}}). | ||
| Then, add the cost of the last level (there are {{<k>}} 2^{\lg n} = n {{</k>}} leaf nodes). | ||
| So we can describe this summation like this: | ||
|
|
||
| {{<k display>}} | ||
| \begin{aligned} | ||
| \sum_{k=1}^{\lg n} \frac{n^2}{2^k} + n W(1) &= \frac{\frac{1}{2}^{(\lg n - 1) + 1} -1}{\frac{1}{2} - 1} n^2 + \Theta(n) \\ | ||
| &= \left( 2 - \frac{2}{n} \right) n^2 + \Theta(n) \\ | ||
| &= \Theta(n^2) | ||
| \end{aligned} | ||
| {{</k>}} | ||
|
|
||
|  | ||
|
|
||
| Its okay to also let {{<k>}} n \to \infty {{</k>}} and get an approximation: | ||
|
|
||
|  | ||
|
|
||
| However, don't make the approximation too loose. | ||
|
|
||
|  | ||
|
|
||
| {{<k display>}} | ||
| \begin{aligned} | ||
| \sum_{k=0}^{\log_4 n - 1} 3^k c \left( \frac{n}{4^k} \right)^2 + n^{\log_3 4} T(1) &= cn^2 \sum_{k=0}^{\log_4 n - 1} \left( \frac{3}{4^2} \right)^k + \Theta(n^{\log_3 4}) | ||
| \end{aligned} | ||
| {{</k>}} | ||
|
|
||
|  | ||
|  | ||
|  | ||
|  | ||
|  | ||
|
|
||
| This gives an overall complexity of {{<k>}} \Theta(n^2) {{</k>}}. | ||
|
|
||
| Lets solve this same problem using the substitution method. | ||
|
|
||
|  | ||
|
|
||
| Once this is setup, we can solve for {{<k>}} d {{</k>}}. | ||
|
|
||
|  | ||
|
|
||
| Now, lets try an unbalanced tree: | ||
|
|
||
|  | ||
|
|
||
| When we have an unbalanced tree, we need to find the height of the root to leaf nodes that reach the base case the fastest, and the height of the root to leaf nodes that reach the base case the slowest. | ||
| When we start to sum each level, we can see each level costs {{<k>}} n {{</k>}}, until the tree becomes unbalanced. | ||
| At this point, the cost is {{<k>}} \leq n {{</k>}}. | ||
|
|
||
| <blockquote class="book-hint info"> | ||
| Note: If we assume the cost at each level is in fact {{<k>}} n {{</k>}}, then we will find an upper bound for the | ||
| complexity. | ||
| If we assume that the tree ends at the shortest path from root to leaf, then we will get the lower bound. | ||
| </blockquote> | ||
|
|
||
|  | ||
|
|
||
| If we find the lower bound and upper bound, and they are the same, then we can say we found the exact bound. | ||
| So, the lower bound is | ||
|
|
||
|  | ||
|  | ||
|
|
||
| Now that we have found a lower bound, lets find the upper bound: | ||
|
|
||
|  | ||
|
|
||
| <blockquote class="book-hint info"> | ||
| Note: In the term {{<k>}} n^{\log_\frac{3}{2} 2} {{</k>}}, since the base in the log is less than the number, it means | ||
| that the overall value is {{<k>}} > 1 {{</k>}}, so the polynomial term dominates the linearithmic term. | ||
| </blockquote> | ||
|
|
||
|  | ||
|
|
||
| Since our lower and upper bounds are not equivalent, we cannot say we have an exact bound (big theta). | ||
|
|
||
| We can get a better assumption but not overestimating as much. | ||
| If we assume that each level costs the same all the way down, then NOT include the leaf node costs, | ||
| This would give our upper bound as {{<k>}} O(n \lg n) {{</k>}}, which matches our lower bound. | ||
| That means we have an overall complexity of {{<k>}} \Theta(n \lg n) {{</k>}}. | ||
|
|
||
|  | ||
|  | ||
|
|
||
| ### Quicksort recurrence | ||
|
|
||
|  | ||
|  | ||
|  | ||
|  | ||
|  | ||
|  | ||
|
|
||
| ### Master's method | ||
|
|
||
| Masters method can be used when recurrences are in this exact form: | ||
|
|
||
|  | ||
|
|
||
| Generally, we'll have 3 cases: | ||
|
|
||
|  | ||
|
|
||
| Lets visualize the first case with a recursion tree: | ||
|
|
||
|  | ||
|  | ||
|
|
||
|
|
||
| ### Mergesort recurrence using Master's method | ||
|
|
||
| So first we identify our variables {{<k>}} a,b,f(n) {{</k>}} and go thru the cases. | ||
|
|
||
|  | ||
|
|
||
| The first case is false because {{<k>}} \Theta(n) \not = O(n^{1-\epsilon}) {{</k>}}. | ||
| So we check the second case, which is true because {{<k>}} \Theta(n) = \Theta(n) {{</k>}}. | ||
|
|
||
|  | ||
|
|
||
| So the Master's method gives us a runtime complexity of {{<k>}} \Theta(n \lg n) {{</k>}}, which is the average case runtime of mergesort. | ||
|
|
||
| ### Some more recurrence examples using Master's method | ||
|
|
||
|  | ||
|  | ||
|
|
||
| The third case works for this example, and you usually need to find a {{<k>}} \epsilon {{</k>}} value between 0 and 1. | ||
|
|
||
|  | ||
|  | ||
|  | ||
|  | ||
|
|
||
| In this example, all 3 cases fail, so another method of solving recurrences it needed besides Master's method. | ||
|
|
Oops, something went wrong.