OS LV6

1. Koristeći POSIX Threads biblioteku kreirajte program koji kreira i pokreće 3 neovisne niti: jednu nit za ispis najvećeg elementa polja, drugu za ispis najmanjeg elementa polja i treću za ispis cijelog polja. Polje inicijalizirajte kao globalnu varijablu.

Naredba za kreiranje direktorija: mkdir LV6
Naredba za pozicioniranje unutar tog direktorija: cd LV6/
Naredba za kreiranje datoteke: touch zad1.c
Naredba za pokretanje uređivača teksta: nano zad1.c
Naredba za izlistanje sadržaja datoteke: cat zad1.c
Kod:

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void* print_message_function(void* ptr);

int polje[] = { 5, -7, 3, 1, 9, 6, 3, 8, 2, 5, 3, -2 };

void* najmanji_element(){
        int i;
        int n = sizeof(polje) / sizeof(polje[0]);
        int najmanj_element = polje[0];
        for (i = 1; i < n; i++){
                if (polje[i] < najmanji_element){
                        najmanji_element = polje[i];
                }
        }
        printf("Najmanji element je: %d\n", najmanji_element);
}

void* najveci_element(){
        int i;
        int n = sizeof(polje) / sizeof(polje[0]);
        int najveci_element = polje[0];
        for (i = 1; i < n; i++){
                if (polje[i] > najveci_element){
                        najveci_element = polje[i];
                }
        }
        printf("Najveci element je: %d\n", najveci_element);
}

void* cijelo_polje(){
        int i;
        int n = sizeof(polje) / sizeof(polje[0]);
        for (i = 0; i < n; i++){
                printf("%d ", polje[i]);
        }
        printf("\n");
}

main() {
        pthread_t thread1, thread2, thread3;
        int iret1, iret2, iret3;
        iret1 = pthread_create(&thread1, NULL, najmanji_element, NULL);
        iret2 = pthread_create(&thread2, NULL, najveci_element, NULL);
        iret3 = pthread_create(&thread3, NULL, cijelo_polje, NULL);
        pthread_join(thread1, NULL);
        pthread_join(thread2, NULL);
        pthread_join(thread3, NULL);
        exit(0);
}
//////////////////////////////////////////////////////////////////////////////////////////////////
Naredba za prevođenje datoteke: gcc zad1.c -pthread -o zad1
Naredba za pokretanje datoteke: ./zad1
Izlaz:

Najmanji element je: -7
Najveci element je: 9
5 -7 3 1 9 6 3 8 2 5 3 -2


2. Na dnu je dan primjer višenitnog programa implementiranog u programskom jeziku C, u kojem jedna nit izvodi funkciju firstFunction, a druga nit funkciju secondFunction. Prva funkcija povećava vrijednost varijable1, a smanjuje vrijednost varijable2, dok druga nit radi obrnuto. Ukoliko vrijednost varijable1 postane veća od vrijednosti varijable2, može se izvoditi samo druga nit. Također, ako vrijednost varijable2 postane veća od vrijednosti varijable1, može se izvoditi samo prva nit. Vaš zadatak je dovršiti programski kod tako da omogućite sinkronizaciju među nitima koristeći mutekse i uvjetne varijable iz biblioteke pthreads. Kopirajte programski kod i objasnite svoje rješenje. Kod kompajliranja dodajte opciju -lm zbog matematičke biblioteke.

Naredba za kreiranje datoteke: touch zad2.c
Naredba za pokretanje uređivača teksta: nano zad2.c
Naredba za izlistanje sadržaja datoteke: cat zad2.c
Kod:

#include <stdio.h>
#include <pthread.h>
#include <math.h>
#include <stdlib.h>


float variable1 = 10;
float variable2 = 9;
pthread_mutex_t lock;
pthread_cond_t cond1, cond2;

void* firstFunction() {
        while (1) {
                pthread_mutex_lock(&lock);
                while (variable2 < variable1)
                {
                        pthread_cond_wait(&cond1, &lock);
                }
                while (variable2 >= variable1)
                {
                        variable1 = 3 * variable1 * variable1 + 4 * variable1 - 3;
                        variable2 = sqrt(abs(variable2)) - 4;
                        printf("Thread1: %.2f %.2f\n", variable1, variable2);
                }
                pthread_cond_signal(&cond2);
                pthread_mutex_unlock(&lock);
        }
        pthread_exit(0);
}
void* secondFunction() {
        while (1) {
                pthread_mutex_lock(&lock);
                while (variable1 < variable2)
                {
                        pthread_cond_wait(&cond2, &lock);
                }
                while (variable1 >= variable2)
                {
                        variable1 = sqrt(abs(variable1)) - 4;
                        variable2 = 3 * variable2 * variable2 + 4 * variable2 - 3;
                        printf("Thread2: %.2f %.2f\n", variable1, variable2);
                }
                pthread_cond_signal(&cond1);
                pthread_mutex_unlock(&lock);
        }
        pthread_exit(0);
}
int main(void) {
        pthread_t thread1, thread2;
        pthread_mutex_init(&lock, NULL);
        pthread_cond_init(&cond1, NULL);
        pthread_cond_init(&cond2, NULL);
        pthread_create(&thread1, NULL, firstFunction, NULL);
        pthread_create(&thread2, NULL, secondFunction, NULL);
        pthread_join(thread1, NULL);
        pthread_join(thread2, NULL);
        pthread_mutex_destroy(&lock);
        pthread_cond_destroy(&cond1);
        pthread_cond_destroy(&cond2);
        return 0;
}

///////////////////////////////////////////////////////////////////////////////////////
Naredba za prevođenje datoteke: gcc zad2.c -lm -pthread -o zad2
Naredba za pokretanje datoteke: ./zad2
Izlaz:

Thread1: 1.00 1.83
Thread1: 4.00 -3.00
Thread2: -2.00 12.00
Thread1: 1.00 -0.54
Thread2: -3.00 -4.28
Thread2: -2.27 34.88
Thread1: 3.36 1.83
Thread2: -2.27 14.38
Thread1: 3.36 -0.26
Thread2: -2.27 -3.83
Thread2: -2.59 25.75
Thread1: 6.72 1.00
Thread2: -1.55 4.00
Thread1: -1.99 -2.00
Thread2: -3.00 1.00
Thread1: 12.00 -3.00
Thread2: -0.54 12.00
Thread1: -4.28 -0.54
Thread1: 34.88 -4.00
Thread2: 1.83 29.00
Thread1: 14.38 1.39
Thread2: -0.26 8.30

/////////////////////////////////////////////////////////////////////////////////////////////////


3. Zadan je sustav sa 4 resursa čiji je broj instanci definiran vektorom E = [6 5 8 7]. Pretpostavimo da je u memoriji u nekom trenutku 4 procesa (A, B, C, D) sa sljedećom tablicom alociranih resursa C te tablicom potrebnih resursa R.

𝐂 = (𝐷𝐵𝐴 𝐶 1 2 2 0 1 0 3 0 1 1 4 2 1 3 1 0)  𝐑 = (𝐷𝐵𝐴 𝐶 1 2 3 2 0 1 2 2 0 1 3 2 2 2 5 2)

Naredba za kreiranje datoteke: touch zad3.c
Naredba za pokretanje uređivača teksta: nano zad3.c
Naredba za izlistanje sadržaja datoteke: cat zad3.c
Kod:

#include<stdio.h>

int main(){
        int i,j;
        int E[4] = { 6, 5, 8, 7 };
        int C[4][4] =
        {
                {1, 1, 1, 1},
                {2, 0, 1, 3},
                {2, 3, 4, 1},
                {0, 0, 2, 0}
        };
        int R[4][4] =
        {
                { 1, 0, 0, 2 },
                { 2, 1, 1, 2 },
                { 3, 2, 3, 5 },
                { 2, 2, 2, 2 }
        };

        int A[4] = { 0 };
        for (i = 0; i < 4; i++){
                int zbroj = 0;
                for (j = 0; j < 4; j++){
                        zbroj += C[j][i];
                }
                A[i] = E[i] - zbroj;
        }
        int n = 0;
        int broken[4] = { -1, -1, -1, -1 };

        for (i = 0; i < 4; i++){
                for (j = 0; j < 4; j++){
                        if (i == broken[j]){
                                i++;
                                j = -1;
                        }
                }
                int manji = 0;
                for (j = 0; j < 4; j++){
                        if (R[i][j] > A[j]){
                                manji = 1;
                                break;
                        }
                }
                if (manji == 0){
                        for (j = 0; j < 4; j++){
                                A[j] += C[i][j];
                        }
                        broken[n] = i;
                        i = -1;
                        n++;
                        if (n == 4){
                                break;
                        }
                }
        }
        if (n == 4){
                printf("Sustav je rjesiv!");
        }
        else{
                printf("Sustav nije rjesiv!");
        }
        printf("\n");
}
//////////////////////////////////////////////////////////////////////////////////////////////////
Naredba za prevođenje datoteke: gcc zad3.c -lm -pthread -o zad3
Naredba za pokretanje datoteke: ./zad3
Izlaz:

Sustav je rjesiv!

//////////////////////////////////////////////////////////////////////////////////////////////////

Prvo računamo ukupnu zauzetost svakog resursa po svim procesima, zbrajajući retke matrice C:

𝐴 1 1 1 1
𝐵 2 0 1 3
𝐶 2 3 4 1
𝐷 0 0 2 0 +
------------
  5 4 8 5

Zatim oduzimamo od broj instanci resursa ukupnu zauzetost svakog resursa:

E = (6  5  8  7)
 -  (5  4  8  5)
________________
A = (1  1  0  2)

Nadalje, redom se dodjeljuju resursi onim procesima čiji je zahtjeve moguće ispuniti. Promatramo redak u matrici
R koji ima sve elemente manje ili jednake vektoru A. Po pronalasku takvog reda, uzimamo ekvivalentni red iz
matrice C i nadodajemo vektoru A. Ukoliko nije moguće naći odgovarajući red u matrici R kojemu su elementi
manji ili jednaki od elemenata vektora A, zaustavljamo algoritam i pišemo da je došlo do zastoja!

   (1  1  0  2)
 + (1  1  1  1)            Gledamo 1. redak matrice R, a dodajemo 1. redak matrice C
_______________
   (2  2  1  3)
 + (2  0  1  3)            Gledamo 2. redak matrice R, a dodajemo 2. redak matrice C
_______________
   (4  2  2  6)
+  (0  0  2  0)            Gledamo 4. redak matrice R, a dodajemo 4. redak matrice C
_______________
   (4  2  4  6)
+  (2  3  4  1)            Gledamo 3. redak matrice R, a dodajemo 3. redak matrice C
_______________
   (6  5  8  7)


Dobiveni rezultat je jednak početnom vektoru E, što znači da je sustav rješiv i neće doći do zastoja.