Operativsystem: Lösningar till tentamen 2023-05-29

Här kan man ge olika svar. En känd historisk händelse är "webbläsarkriget" på 1990-talet. Webben var ganska ny, och webbläsaren Netscape Navigator var helt dominerande. Den var ett applikationsprogram som, precis som andra applikationsprogram, man fick ladda ner (eller snarare läsa in från CD-skiva, för det var ju på 1990-talet) och installera på sin dator. Microsoft hävdade då att deras konkurrerande webbläsare, Internet Explorer, var en del av operativsystemet Windows. De skickade med den med varje kopia av Windows, och hävdade att den inte gick att avinstallera eftersom den var en integrerad del av operativsystemet. Eftersom alla Windows-användare var tvungna att ha Internet Explorer, och nästan alla vanliga datorer använde Windows, lyckades Microsoft konkurrera ut Netscape, och Internet Explorer blev den dominerande webbläsaren.

Andra exempel: Virusskydd (som kan vara inbyggt i operativsystemet eller ett separat program). Trådhantering (som kan ha stöd av operativsystemet och kärnan, elle vara ett separat paket med enbart user space-trådar).

En fördel med mikrokärnor är att om en av de funktioner som är placerade i vanliga processer utanför kärnan skulle krascha, så leder det inte till att hela systemet kraschar. Därigenom blir operativsystemet stabilare.

Eftersom det blir mindre kod i kärnan, blir det också lättare att granska och testa den, vilket är tänkt att göra operativsystemet stabilare (mot krascher) och säkrare (mot angrepp).

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

int x = 0;

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

x = 3, y = 3
x = 3, y = 3
x = 3, y = 3
x = 3, y = 3
x = 3, y = 3
x = 3, y = 3
x = 3, y = 3
x = 3, y = 3

Nej. Vid fork får barnprocessen en egen adressrymd, som till att börja med är en kopia av föräldraprocessens, förutom att returvärdet från fork-anropet är olika. Varje process har alltså sin egen adressrymd, så ingen av variablerna x och y är delad mellan dem. Raderna som skrivs ut kan visserligen komma i olika ordning, eftersom det inte finns någon synkronisering mellan de olika processerna, men i slutet av programmet när variablerna skrivs ut har de samma innehåll i alla processerna, så utskrifterna är identiska.

Det kan förstås bli olika utskrifter, till exempel om någon stänger av datorn medan programmet körs, eller om datorn redan kör maximalt antal processer, så att fork-anropen misslyckas, eller om kosmisk strålning påverkar innehållet i minnet.

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

volatile int x = 0;

void *thread_body(void *arg) {
    int y = 0;
    x = x + 1;
    y = y + 1;
    printf("x = %d, y = %d\n", x, y);
    return NULL;
}

int main(void) {
    int z = 0;
    x = x + 1;
    z = z + 1;
    printf("x = %d, z = %d\n", x, z);
    pthread_t thread1, thread2;
    pthread_create(&thread1, NULL, thread_body, NULL);
    pthread_create(&thread2, NULL, thread_body, NULL);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    printf("x = %d, z = %d\n", x, z);
}

x = 1, z = 1
x = 2, y = 1
x = 3, y = 1
x = 3, z = 1

x = 1, z = 1
x = 3, y = 1
x = 2, y = 1
x = 3, z = 1

x = 1, z = 1
x = 2, y = 1
x = 2, y = 1
x = 2, z = 1

x = 1, z = 1
x = 3, y = 1
x = 3, y = 1
x = 3, z = 1

• Ja, värdena på x kan bli olika. Variabeln x är delad mellan trådarna, och det finns ingen synkronisering mellan trådarna. Båda trådarna uppdaterar variabeln x, som är gemensam för båda trådarna. Därför kan innehållet i x bli olika mellan olika körningar av programmet, både till slut och i trådarna.
• Värdena på y och z kan dock inte bli olika. Varje tråd har en egen stack, och en egen variabel y, så utskrifterna av y är alltid lika. Variabeln z finns bara i main-funktionen, som körs i huvudtråden, så den finns bara i ett exemplar, och utskrifterna av z är alltid lika.
• Ordningen på utskrifterna i thread_body kan också bli olika, men det påverkar inte hur utskrifterna ser ut. Värdet på x kan som vi sett bli olika mellan trådarna, men själva ordningen på utskrifterna spelar ingen roll. Om man hade haft ett trådnummer i varje tråd, och skrivit ut det trådnumret i utskriften inuti tråden, så hade man sett i vilken ordning utskrifterna kom, och det hade man sett även om det var samma värde på x.

På samma sätt översätts virtuell adress 49 (0011 0001 binärt) till 33 (10 0001 binärt), virtuell adress 50 (0011 0010 binärt) till 34 (10 0010 binärt), och så vidare till den sista virtuella adressen på den sidan, 63 (0011 1111 binärt), som översätts till 33 (10 1111 binärt):

Minnet är förstås mycket litet, så det går inte att göra särskilt komplicerade beräkningar. Dels är det virtuella minnet litet, så vi kan inte ha så mycket data, och dessutom är det fysiska minnet ännu mindre, så om vi har annat än mycket lite data kommer vi att behöva page:a ut och in från någon sorts sekundärminne, vilket blir långsamt. Om vi dessutom tänkt oss att ha körbar programkod, operativsystem och sidtabell i primärminnet, blir det verkligen svår att få plats med allt. (Men våra 256 byte virtuellt minne är mer minne än vad som från början fanns i ENIAC: 20 stycken register för 10-siffriga decimala tal!)

Minnet är litet, men sidstorleken är stor jämfört med minnet. Det kan ge onödigt stor intern fragmentering. (Intern fragmentering betyder att eftersom minnessidorna har en fast storlek, kommer en del av vissa sidor att vara oanvänd.)

Det finns bara plats för 4 sidor åt gången i minnet, vilket kan orsaka thrashing. (Thrashing betyder att de data som används inte alla får plats i det fysiska minnet, så datorn måste ägna mycket tid åt att flytta data fram och tillbaka mellan primärminnet och sekundärminnet.) Särskilt illa blir det om vi tänkt oss att vi ska kunna köra flera processer samtidigt.

Med sidindelat virtuellt minne. Man allokerar inte sammanhängande fysiskt minne, utan använder en virtuell minnesrymd som delas in i lika stora "sidor" (på engelska "pages"), exempelvis med storleken fyra kilobyte. Det fysiska minnet delas in i "frames" (på svenska kanske "ramar"), med samma storlek som sidorna, och en sida kan sedan placeras i vilken ledig frame som helst. Processens sidor behöver inte lagras sammanhängande eller i ordning i ramarna. "Sidtabellen" (på engelska "page table") översätter mellan sidnummer och ramnummer, dvs mellan virtuella och fysiska adresser. Den virtuella minnesrymden är sammanhängande, men fysiskt kan sidorna vara lagrade i en annan ordning.

Man kombinerar ofta detta med "paging", som innebär att en sidas innehåll kan flyttas till sekundärminne om det inte används just då. Då kan man frigöra plats i det fysiska primärminnet, för innehåll som faktiskt ska användas. Det gör att en process kan använda mer minne än vad som fysiskt finns, och det underlättar att hitta lediga frames, men det som löser problemet med att hitta ett tillräckligt stort, sammanhängande utrymme är den sidindelade virtuella adressrymden, inte att minnesinnehåll sparas på sekundärminne.

Förutom det gemensamma minnesutrymmet har varje process fortfarande eget minne, som den andra processen inte kommer åt. Trådar lever inom en process och i dess minnesutrymme, och de olika trådarna har inget eget minne som de andra trådarna inte kan komma åt. Varje tråd har en egen stack, men den skyddas inte från åtkomst från de andra trådarna.

Operativsystemets data om processerna, som till exempel vilken användare det är som kör och vilka filer de har öppna, är fortfarande separata för de två processerna, inte gemensamma som om de varit trådar i samma process.

En annan skillnad mot om det var trådar är att trådar kan vara "user space-trådar", vars schedulering sköts helt av vanliga programkod i det körande programmet, utan att operativsystemkärnan är inblandad eller ens vet om att de finns. Det kan inte dessa processer.