# CSCI-UA.0202 Spring 2015 Homework 4

Handed out Thursday, Feburary 19, 2015
Due 10:00 AM, Wednesday, February 25, 2015

# Homework 4

These problems should be done on your own. We're not going to be grading them strictly (we'll mainly look at whether you attempted them). But they will be reinforcing knowledge and skills, so you should totally work through them carefully.

## Time-of-check-to-time-of-use (TOCTTOU) bugs

Alice and Bob each have an account in a bank. Bob wants to transfer money to Alice. We are using the synchronization primitives in Lab 3.
```// assume all the variables are initialized correctly
double alice_balance, bob_balance;
smutex_t mtx;

bool
transferBob2Alice(double trans) {
if (bob_balance > trans) {
smutex_lock(&mtx);
bob_balance = bob_balance - trans;
alice_balance = alice_balance + trans;
smutex_unlock(&mtx);
return true;
}
return false;
}
```
The implementation of function `transferBob2Alice` is not correct.
1. What's wrong? (Give a problematic interleaving.)
2. State the fix in one sentence.

The bank decides to use fine-grained locking. Here is its implementation:
```// assume all the variables are initialized correctly
double balance[2]; // 0 for alice, 1 for bob
smutex_t mtx[2];    // 0 for alice, 1 for bob

bool transfer(int from, int to, double trans) {
smutex_lock(&mtx[from]);
smutex_lock(&mtx[to]);

bool result = false;
if (balance[from] > trans) {
/*
* EDIT: corrected code is below. here is the original, typo'ed
* version
*   balance[from] = balance[to] - trans;
*   balance[from] = balance[to] + trans;
*/
balance[from] = balance[from] - trans;
balance[to] = balance[to] + trans;
result = true;
}

smutex_unlock(&mtx[to]);
smutex_unlock(&mtx[from]);
return result;
}
```
1. Write down an interleaving that results in deadlock.
2. Keeping the same data structures, rewrite `transfer()` to eliminate the possibility of deadlock

This problem is intended to be somewhat harder than the others. You will implement a multiple-reader, single-writer lock as a spinlock. Here is the description:
```  struct sharedlock {
int value; // when the lock is created, value is initialized to 0
};
```
• It allows multiple readers OR one single writer, and there are four functions:
```  reader_acquire(struct sharedlock*)
writer_acquire(struct sharedlock*)
writer_release(struct sharedlock*)
```
We have given you the first of these, and your task is to write the last three of these. Each of these three functions only needs to be a single line of code.
• When the lock is unlocked (no readers or writers holding the lock), its value is 0.
• When there are one or more readers holding the lock (that is, multiple threads have completed `reader_acquire()` but have not called `reader_release()`), the lock's value equals the number of readers.
• When the lock is held by a writer (i.e., a thread has made it past `writer_acquire()` but has not called `writer_release()`), its value is -1.
• We are unconcerned here with fairness, efficiency, or starvation; just write something that is safe and that eventually allows a waiting thread, reader or writer, to make progress, even though a waiting writer may have to wait until there are no readers.
• Assume that the lock is never acquired by an interrupt handler, so you donâ€™t need to worry about enabling and disabling interrupts. You may also assume that the hardware provides sequential consistency.
You will likely need to call two atomic primitives, described below:
• `int cmpxchg_val(int* addr, int oldval, int newval)`: This is an atomic operation that compares `oldval` to `*addr`, and if the two are equal, it sets ```*addr = newval```. It returns the old contents of `*addr`.
• `void atomic_decrement(int* arg)`: This atomically performs `*arg = *arg - 1`.
(We also include their pseudocode and inline assembly implementations in an appendix. However, you do not need this appendix material to do the problem.)
```  // we are giving you the code for the first of the four functions:
int curr_val;
while (1) {

// spin while a writer owns the lock
while ((curr_val = lock->value) == -1) {}

assert(curr_val >= 0);

// try to atomically increment the count, based on our best
// guess of how many readers there had been. if we were
// wrong, keep looping. if we got it right, then we
// succeeded in incrementing the count atomically, and we
// can proceed.
if (cmpxchg_val(&lock->value, curr_val, curr_val + 1) == curr_val)
break;
}
// lock->value now contains curr_val + 1
}
```
Write the other three functions! (Again, each needs only a single line of code.)

## Priority Inversion

In this problem, the system has three tasks: one at high priority, one at medium priority, and one at low priority. Assume that the intent is to schedule according to strict priority (although we will see that this intent will be thwarted). Some assumptions:
• The system runs one task a time (so assume a single CPU).
• If a task with higher priority is ready to run, it will preempt the running task (note that if a thread is waiting on a mutex that is owned by another thread, then the waiting thread is NOT ready to run!).
• Preemption can happen inside the critical section (just as when you code using mutexes in application space).
• If a thread cannot continue (for example because it is waiting for a mutex), it yields.
```smutex_t res;

void highPriority() {
... // do something
smutex_lock(&res);
... // handle resource
smutex_unlock(&res);
printf("A ");
}

void mediumPriority() {
... // do something
printf("B ");
}

void lowPriority() {
smutex_lock(&res);
... // handle resource
smutex_unlock(&res);
... // do something
printf("C ");
}
```
1. Which of the following outputs are possible?

2. A B C
A C B
B A C
C B A

3. Explain.

## Handing in the homework

Use NYU Classes; there's an entry for this homework.

## Appendix: Implementation of atomic primitives

Here is pseudocode and actual x86 assembly code for the implementations of the atomic primitives in Question 3.
```cmpxchg val()

/* pseudocode */
int cmpxchg_val(int* addr, int oldval, int newval) {
LOCK: // remember, this is pseudocode
return was;
}

/* inline assembly */
int cmpxchg_val(int* addr, int oldval, int newval) {
int was;
asm volatile("lock cmpxchg %3, %0"
: "a" (oldval), "r" (newval)
: "cc");
return was;
}

atomic decrement()

/* pseudocode */
void atomic_decrement(int* arg) {
LOCK: // remember, this is pseudocode
*arg = *arg - 1;
}

/* inline assembly */
void atomic_decrement(int* arg) {
asm volatile("lock decl %0" : "+m" (*arg) : "m" (arg));
}
```

Last updated: Mon May 04 11:24:46 -0400 2015 [validate xhtml]