Operativsystem: Lösningar till tentamen 2024-08-30

• Om en långsam hårdvaruoperation har startats, till exempel läsning från disk, behöver processorn inte polla, dvs då och då se efter, för att veta när operationen är klar. Operativsystemkärnan som kör på processorn bara startar läsningen eller vad det nu är för extern process det gäller, och sen får hårdvaran (i det här fallet disken) arbeta vidare utan inblandning av processorn. När operationen är färdig signalerar hårdvaran till processorn med ett avbrott, och då kan processorn i sin avbrottsrutin ta hand om resultatet från den operationen.
• Om det finns processer eller trådar som väntar på att få köra, behöver de just nu körande processerna inte "samarbeta" genom att själva lämna över resurser (så kallad "cooperative multitasking"), utan med hjälp av avbrott (från en timer) kan man stoppa en körande process, och operativsystemkärnan kan starta en annan process på processorn.

• First-Come, First-Served Scheduling (5.3.1)
• Shortest-Job-First Scheduling (5.3.2)
• Shortest-Remaining-Time-First Scheduling (s 209)
• Round-Robin Scheduling (5.3.3)
• Priority Scheduling (5.3.4)
• Multilevel Queue Scheduling (5.3.5)
• Multilevel Feedback Queue Scheduling (5.3.6)
• Rate-Monotonic Scheduling (5.6.3)
• Earliest-Deadline-First Scheduling (5.6.4)
• Proportional Share Scheduling (5.6.5)

Parallellitet innebär att de på riktigt körs samtidigt, vilket förstås kräver att det finns flera olika processorer eller processorkärnor.

User space är den vanliga minnesrymd som går att komma åt i user mode. Kernel space är det ytterligare minne som bara operativsystemkärnan har tillgång till.

(Inoder är en implementationsdetalj i hur Unix och Unix-liknande system lagrar filerna. Andra operativsystem kan göra på andra sätt.)

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

#define STUFFS_TO_DO 3

int global = 0;

void do_stuff(int number) {
    int local = 0;
    ++local;
    ++global;
    printf("number %d: local = %d, global = %d\n", number, local, global);
}

int main(void) {
    printf("forks: starting!\n");
    for (int i = 0; i < STUFFS_TO_DO; ++i) {
        int fork_result = fork();
        if (fork_result == -1) {
            fprintf(stderr, "forks: fork failed\n");
            exit(EXIT_FAILURE);
        }
        else if (fork_result == 0) {
            do_stuff(i);
            exit(EXIT_SUCCESS);
        }
        else {
            // Nothing
        }
    }

    printf("forks: finished!\n");
}

forks: starting!
number 0: local = 1, global = 1
forks: finished!
number 1: local = 1, global = 1
number 2: local = 1, global = 1

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

#define NR_THREADS 10

volatile long long int data = 0;
pthread_mutex_t lock;

void *thread_body(void *arg) {
    int this_thread_number = (int)arg;
    for (int i = 0; i < 1000000; ++i) {
        pthread_mutex_lock(&lock);
        ++data;
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main(void) {
    printf("Starting %d threads...\n", NR_THREADS);
    pthread_mutex_init(&lock, NULL);
    pthread_t threads[NR_THREADS];
    for (int i = 0; i < NR_THREADS; ++i)
        pthread_create(&threads[i], NULL, thread_body, (void*)i);
    for (int i = 0; i < NR_THREADS; ++i)
        pthread_join(threads[i], NULL);
    printf("The value of data is %lld.\n", data);
}

Starting 10 threads...
The value of data is 10000000.

Om flera trådar försöker göra detta samtidigt kan det till exempel bli så att tråd 1 hämtar värdet (låt oss säga 17) och ökar värdet med ett i ett register till 18. Därefter, innan tråd 1 hinner skriva tillbaka värdet till variabelns plats i minnet hinner tråd 2 hämta värdet (fortfarande 17) från variabeln. Tråd 1 skriver tillbaka 18 till variabeln, tråd 2 ökar sitt hämtade värde 17 i ett register till 18, och till sist skriver tråd 2 tillbaka 18 till variabeln. Trots två ökningar med ett har värdet bara ökat med ett, inte två.

Först kan man fråga sig vad "vara igång" betyder. Betyder det samtidighet eller parallellitet? Om det är parallellitet, beror svaret på hur många kärnor processorn har.

Därefter kan man titta på minnet. Om varje process använder hela sin virtuella minnesrymd, och alla processernas hela virtuella minnesinnehåll ska vara inläst i det fysiska minnet (till exempel om man inte har något sekundärminne, och inte kan använda paging eller swapping) kan man ha 2²⁰ / 2¹⁶ = 16 processer.

Om varje process behöver ha minst en virtuell minnessida i det fysiska minnet, kan man ha 2²⁰ / 2¹² = 256 processer.

Om man har sekundärminne och kan utnyttja paging eller swapping, beror det på hur stort sekundärminnet är. Med ett tillräckligt stort sekundärminne skulle man kunna få plats med många helt utswappade processer som helst. (Men då betyder "igång" förstås inte parallellitet.)