• Skriv tydligt och klart. Lösningar som inte går att läsa kan naturligtvis inte ge några poäng. Oklara och tvetydiga formuleringar kommer att misstolkas.
• Antaganden utöver de som står i uppgifterna måste anges. Gjorda antaganden får inte förändra den givna uppgiften.
• Skriv gärna förklaringar om hur du tänkt. Även ett svar som är fel kan ge poäng, om det finns med en förklaring som visar att huvudtankarna var rätt.
• Skriv bara på en sida av papperet. Använd inte röd skrift.
• Skriv den personliga tentamenskoden på varje inlämnat blad. Skriv inte namn eller personnummer på bladen.
• Skriv inte svaren i häftet med provfrågorna och lämna inte in det. Behåll det eller kasta det. Läraren vet redan vad frågorna var.

Tabeller och formler

2^x * 2^y = 2^x+y
2^x / 2^y = 2^x-y

Uppgift 1 (6p)

b) Vad menas med en mikrokärna?

c) Vilka fördelar och nackdelar ger en mikrokärna?

Uppgift 2 (3p)

Uppgift 3 (3 p)

#include <stdio.h>
#include <unistd.h>

int x = 1;

int main(void) {
    int y = 1;
    fork();
    x = x + 1;
    y = y + 1;
    fork();
    fork();
    printf("x = %d, y = %d!\n", x, y);
}

Uppgift 4 (8 p)

b) En process kan befinna sig i olika tillstånd, som "ny", "redo", "körande", "färdig" och "väntar". Rita upp ett tillståndsdiagram för hur processens tillstånd kan ändras, med de händelser som kan göra att det ändras.

c) Operativsystemkärnan innehåller att antal köer som processerna placeras i. Vilka är det? Hur hänger köerna ihop med de olika tillstånden från uppgiften ovan?

d) Processkontrollblocket (PCB) eller task-structen har bland annat plats för innehållet i processorns register. Varför det? Registerinnehållet finns väl i registren?

Uppgift 5 (5 p)

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

volatile int g = 0;

void *thread_body(void *arg) {
    int thread_number = (int)arg;
    printf("Startat tråd %d...\n", thread_number);
    for (int i = 0; i < 100 * 1000 * 1000; ++i) {
        ++g;
    }
    printf("Avslutar tråd %d...\n", thread_number);
    return NULL;
}

int main(void) {
    pthread_t thread_1, thread_2, thread_3;
    pthread_create(&thread_1, NULL, thread_body, (void*)1);
    pthread_create(&thread_2, NULL, thread_body, (void*)2);
    pthread_create(&thread_3, NULL, thread_body, (void*)3);
    printf("Trådarna kör...\n");
    pthread_join(thread_1, NULL);
    pthread_join(thread_2, NULL);
    pthread_join(thread_3, NULL);
    printf("Klart! g = %d\n", g);
}

Vid en provkörning av programmet får vi den här utskriften:

Trådarna kör...
Startat tråd 3...
Startat tråd 1...
Startat tråd 2...
Avslutar tråd 3...
Avslutar tråd 1...
Avslutar tråd 2...
Klart! g = 118428316

a) Eftersom var och en av de tre trådarna ökar variabeln g med ett 100 miljoner gånger, borde utskriften bli 300000000, men i stället blev den 118428316. Vad beror det på?

b) Utskriften av Trådarna kör står efter pthread_create-anropen i main som startar de tre trådarna. Hur är det möjligt att den kan komma före utskrifterna om att trådarna har startat?

c) Skulle även utskriften Klart! kunna komma "konstigt", dvs på en annan plats än som sista raden? Förklara!

Uppgift 6 (4 p)

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

volatile int g = 0;
volatile int the_lock = 0; // 0 = ledigt, 1 = låst

void lock(void) {
    // Först, vänta på att låset blir ledigt
    while (the_lock != 0) { }
    // Nu är låset ledigt, så vi låser det
    the_lock = 1;
}

void unlock(void) {
    the_lock = 0;
}

void *thread_body(void *arg) {
    int thread_number = (int)arg;
    printf("Startat tråd %d...\n", thread_number);
    for (int i = 0; i < 100 * 1000 * 1000; ++i) {
        lock();
        ++g;
        unlock();
    }
    printf("Avslutar tråd %d...\n", thread_number);
    return NULL;
}

int main(void) {
    pthread_t thread_1, thread_2, thread_3;
    pthread_create(&thread_1, NULL, thread_body, (void*)1);
    pthread_create(&thread_2, NULL, thread_body, (void*)2);
    pthread_create(&thread_3, NULL, thread_body, (void*)3);
    printf("Trådarna kör...\n");
    pthread_join(thread_1, NULL);
    pthread_join(thread_2, NULL);
    pthread_join(thread_3, NULL);
    printf("Klart! g = %d\n", g);
}

a) Fungerar låset, så resultatet i variabeln g alltid blir 300 miljoner? Förklara!

b) Det här är en variant på ett så kallat spin-lock. Vad innebär spin-lock?

c) Oavsett om just detta spin-lock fungerar eller inte, är det lämpligt att använda spin-lock här? Förklara!

Uppgift 7 (7 p)

a) Hur stor är den virtuella adressrymden?

b) Vi har satt i så mycket primärminne i datorn att hela den fysiska adressrymden kan utnyttjas. Hur mycket primärminne har datorn?

c) Hur många bitar av den virtuella adressen används för att ange offset inom en minnessida?

d) Hur många bitar av den fysiska adressen används för att ange offset inom en frame?

e) Hur många minnessidor är den virtuella minnesrymden indelad i?

f) Hur många olika ramar ("frames") är det fysiska minnet indelat i?

g) Om vi antar att sidtabellen ("page table") består av en array med en plats för varje virtuell minnessida, skulle den tabellen få plats i det fysiska minnet? Förklara!

Uppgift 8 (4 p)

Svaret var förstås att det beror på, särskilt på vad det är för medium man skriver till, som om det är en SSD, en mekanisk hårddisk, ett primärminnesfilsystem med hela filsystemet lagrat i primärminne, eller om man skriver till specialfilen /dev/null på Linux, som bara kastar bort alla data.

I lösningsförslagen fanns den här tabellen från en provkörning av ett Linux-program som skriver en gigabyte data, med olika tider för olika media:

Programmet öppnade filen som skulle skrivas med systemanropet open, skrev datat med flera anrop till write, och stängde filen med close. Därefter använde det sync, som vi känner igen från programmet flush_cache.c från en av labbarna.

a) Varför tar close-anropet ibland så lång tid, ibland mycket längre än den sammanlagda tiden för write-anropen? Förklara!

b) Varför har man gjort så det blir så?