zad3

/*Napisati konkurentni program koji modeluje pristupanje vise procesora deljenoj memoriji.

Deljena memorija je predstavljena klasom Memory.
Prilikom instanciranja se zadaje velicina memorije.
Upis vrednosti u memoriju se obavlja pozivom operacije write(),
a citanje pozivom operacije read().

I citanje i pisanje svake vrednosti traju po 1 sekundu.

Svaka adresa u memoriji adresira lokaciju velicine jednog bajta.
Tokom pisanja u memorijsku lokaciju ekskluzivno se zakljucava
cela rec kojoj ta lokacija (bajt) pripada.
Tokom citanja memorijske lokacije rec kojoj ta lokacija (bajt) pripada
se zakljucava, tako da i drugi procesori koji zele da citaju mem. lokaciju
iz te reci to mogu istovremeno da urade.

Treba omoguciti istovremeno pristupanje memorijskim lokacijama koje ne pripadaju istoj reci.

Ako istovremeno postoje i procesori koji zeli da citaju i procesori koji zeli da pisu u istu rec,
treba prvo pristup dozvoliti procesorima koji zele da citaju.

Stvoriti nekoliko niti koje pokazuju da program radi ispravno.

Dat je primer scenarija pristupanja, zarad lakseg testiranja.
*/

class Memory {
public:
enum State { FREE, READING, WRITING };
Memory(size_t bytes);
char read(size_t address);
void write(size_t address, char value);
};

struct MemoryAccess {
Memory::State accessType;
size_t address;
char value;
MemoryAccess(Memory::State rw, size_t addr, char v=0) : accessType(rw), address(addr), value(v) {}
};

void processor(Memory& mem, vector<MemoryAccess>& exec) {
static mutex term_m;
for(auto action = exec.begin(); action!=exec.end(); ++action) {
if(action->accessType == Memory::READING) {
action->value = mem.read(action->address);
unique_lock<mutex> l(term_m);
cout << "Processor " << this_thread::get_id()
<< " read from address " << action->address
<< " value=" << action->value << endl;
} else {
mem.write(action->address, action->value);
unique_lock<mutex> l(term_m);
cout << "Processor " << this_thread::get_id()
<< " wrote to address " << action->address
<< " value=" << action->value << endl;
}
}
}

int main() {
vector<MemoryAccess> I = {
{Memory::WRITING, 0, '0'},
{Memory::WRITING, 4, '4'},
{Memory::READING, 0},
{Memory::WRITING, 8, '8'}
};
vector<MemoryAccess> II = {
{Memory::WRITING, 5, '5'},
{Memory::WRITING, 1, '1'},
{Memory::READING, 1},
{Memory::WRITING, 9, '9'}
};
vector<MemoryAccess> III = {
{Memory::WRITING, 8, '8'},
{Memory::WRITING, 9, '9'},
{Memory::WRITING, 2, '2'},
};

}