ОС1/Модификације фебруар 2023

2023-02-25T00:29:29Z

Vuk Davidović: Dodate modifikacije za Februar 2023. i rešena prva modifikacija

Sledeće modifikacije su se pojavile na odbrani projekta u februarskom roku 2023.

Mogli ste da izabere da radite ili 1. modifikaciju ili 2. modifikaciju.

== Modifikacija bez asinhrone promene konteksta ==
* Dodati sistemski poziv čija je deklaracija <code>void thread_join(thread_t* handle)</code> koji tekuću nit zaustavlja dok se ne završi izvršavanje niti označene ručkom <code>handle</code>. U okviru C++ API dodati nestatičku metodu klasi <code>Thread</code> sa deklaracijom <code>void join()</code>. Napisati test program koristeći C++ API sa tri niti, gde će jedna nit čekati da se završe druge dve. Svaka nit na početku ispisuje poruku koja je to nit, zatim radi neku obradu(implementirati ugnježdenim petljama) i na kraju ispisuje poruku da se završila.

=== Rešenje ===

syscall_c.hpp
<syntaxhighlight lang="cpp">
class TCB;
typedef TCB* thread_t;

void thread_join(thread_t* handle);
</syntaxhighlight>

syscall_c.cpp
<syntaxhighlight lang="cpp">
void thread_join(thread_t* handle)
{
uint64 number = 0x03; // Mogao je bilokoji, slobodan, ulaz

__asm__ volatile("mv a1, %0" : : "r" (handle));
__asm__ volatile("mv a0, %0" : : "r" (number));

__asm__ volatile("ecall");
}
</syntaxhighlight>

TCB.hpp
<syntaxhighlight lang="cpp">
typedef TCB* thread_t;

class TCB
{
public:
// ...
private:
// ...
static void join (thread_t* handle);
// ...
};
</syntaxhighlight>

TCB.cpp
<syntaxhighlight lang="cpp">
/* Glavni deo resenja */
void TCB::join(thread_t* handle)
{
while(!(*handle)->isFinished())
TCB::dispatch();
}
</syntaxhighlight>

riscv.cpp
<syntaxhighlight lang="cpp">
case 0x03: // Mogao je bilokoji, slobodan, ulaz
{
thread_t *handle;
__asm__ volatile ("mv %0, a1" : "=r" (handle));

TCB::join(handle);

break;
}
</syntaxhighlight>

syscall_cpp.hpp
<syntaxhighlight lang="cpp">
class Thread
{
public:
// ...
void join(); // Obavezno nestaticka metoda
protected:
// ...
private:
thread_t myHandle; // Ovo je vec postojalo
};
</syntaxhighlight>

syscall_cpp.cpp
<syntaxhighlight lang="cpp">
void Thread::join()
{
if (myHandle)
thread_join(&myHandle);
}
</syntaxhighlight>

main.cpp
<syntaxhighlight lang="cpp">
#include "../h/syscall_cpp.hpp"

bool finishedA = false;
bool finishedB = false;

class WorkerA: public Thread
{
void mod_fun_A(void* arg);
public:
WorkerA():Thread() {}

void run() override
{
mod_fun_A(nullptr);
}
};

class WorkerB: public Thread
{
void mod_fun_B(void* arg);
public:
WorkerB():Thread() {}

void run() override
{
mod_fun_B(nullptr);
}
};

void WorkerA::mod_fun_A(void *arg)
{
for (uint64 i = 0; i < 10; i++)
{
printString("A: i=");
printInt(i);
printString("\n");

for (uint64 j = 0; j < 10000; j++)
{
for (uint64 k = 0; k < 30000; k++)
{
/* busy wait */
}

thread_dispatch();
}
}

printString("A finished!\n");
finishedA = true;
}

void WorkerB::mod_fun_B(void *arg)
{
for (uint64 i = 0; i < 16; i++)
{
printString("B: i=");
printInt(i);
printString("\n");

for (uint64 j = 0; j < 10000; j++)
{
for (uint64 k = 0; k < 30000; k++)
{
/* busy wait */
}

thread_dispatch();
}
}

printString("B finished!\n");
finishedB = true;
thread_dispatch();
}

int main()
{
Riscv::w_stvec((uint64) &Riscv::supervisorTrap);

Thread* main = new Thread(nullptr, nullptr);
printString("Main Created\n");
TCB::running = main->getMyHandle();

/* Modifikacija */
Thread* threads[2];

threads[0] = new WorkerA();
printString("ThreadA created\n");

threads[1] = new WorkerB();
printString("ThreadB created\n");

for(int i = 0; i < 2; i++)
threads[i]->start();

threads[0]->join(); // Blokiraj main nit(u ovom slucaju) dok se nit 0 ne zavrsi
threads[1]->join(); // Blokiraj main nit(u ovom slucaju) dok se nit 1 ne zavrsi

for (auto thread: threads)
delete thread;

printString("Main Stopped\n");

return 0;
}
</syntaxhighlight>

=== Dodatno ===
Dodatno, prilikom ispitivanja, tražili su da nit A čeka da se završi nit B. U tom slučaju morali smo ovo:
<syntaxhighlight lang="cpp">
threads[0] = new WorkerA();
printString("ThreadA created\n");

threads[1] = new WorkerB();
printString("ThreadB created\n");

for(int i = 0; i < 2; i++)
threads[i]->start();
</syntaxhighlight>

da definisemo globalno u fajlu "main.cpp" i da
nakon kreiranja main-a, odmah uradimo dispatch.

A onda da unutar funkcije "mod_fun_A", stavimo:
<syntaxhighlight lang="cpp">
threads[1]->join();
</syntaxhighlight>

threads[1] je nit B.

== Modifikacija sa asinhronom promenom konteksta ==
* Dodati sitemski poziv čija je deklaracija <code>void thread_join(thread_t* handle, time_t t)</code> koji tekuću nit zaustavlja dok se ne završi izvršavanje niti označenom ručkom <code>handle</code> ukoliko je <code>t</code> jednako nuli, a ukoliko je <code>t</code> veće od nule onda se tekuća nit zaustavlja maksimalno <code>t</code> vremena ili kraće ukoliko se nit označena sa <code>handle</code> završi. U okviru C++ API dodati metodu klasi <code>Thread</code> sa deklaracijom <code>void join(time_t)</code>.

Napisati test program koristeći C++ API sa tri niti, gde će dve niti čekati da se završi treća nit, ali jedna treba da čeka maksimalno neko vreme <code>t</code>, a druga dok se zaista ne završi treća nit. Treća nit treba da traje dovoljno dugo kako bi se ispoljilo opisano ponašanje. Svaka nit na početku ispisuje poruku koja je to nit, zatim radi neku obradu(implementirati ugnježdenim petljama) i na kraju ispisuje poruku da se završila. Dodatno, nit koja čeka maksimalno <code>t</code> vremena treba nakon što istekne to vreme da ispiše poruku da je nastavila izvršavanje.

SI Wiki - Кориснички доприноси [sr]

ОС1/Модификације фебруар 2023