Net 4 Activity

Activity 1

In this activity, you will implement a mutex object with correct behaviors by modifying the following code.

// unlocked: state = 0;
// locked: state = 1;

struct mutex {
    std::atomic<int> state = 0;

    void lock() {
        // Your code should have the same effect as this code,
        // but it must behave as if it executes in one atomic step—
        // even if multiple threads are simultaneously calling
        // lock() and unlock() on the same mutex.

        // while (this->state == 1) {
        // }
        // this->state = 1;
    }

    void unlock() {
        // Same note as above.

        // this->state = 0;
    }
}

The atomic state object supports reads and writes, but you can also use atomic read-modify-write arithmetic primitives. For instance, these operations modify state in an atomic way:

++state;  // atomic increment
--state;  // atomic decrement

Activity 2

Now let's try a different way of implementing mutex with just a single bit (spinlock). We add a new primitive:

// Atomically swap the value of `*this` with `value`.
// Returns the previous value of `*this`.
int std::atomic<int>::swap(int value);
struct mutex {
    std::atomic<int> state = 0;

    void lock () {
        // while (this->state == 1) {
        // }
        // this->state = 1;
    }

    void unlock() {
        // this->state = 0; 
    }
}