Operativsystem för civilingenjörer: Hemtentamen 2021-06-01

Jag vill undvika fusk - hur gör jag? / All form av fusk anmäls
Du ska följa instruktionerna för uppgiften. Om du är osäker, fråga ansvarig lärare om något i instruktionerna är oklart.
Du får inte samarbeta. Det här är en individuell examinationsuppgift. Du ska inte prata med någon, ställa frågor till eller ta hjälp av andra studenter eller kurskamrater. Att hjälpa andra under en individuell examination är också fusk.

Lägg undan mobilen. Stäng av sociala medier.

Du får inte använda hjälpmedel. Det vill säga att du får inte använda dig av något annat än det som står angivet i instruktionerna.
Du får inte använda andra formuleringar än dina egna. Dina svar ska vara självständigt formulerade och redovisa dina kunskaper. Det betyder att inga citat eller referat ska förekomma i dina svar om det inte står i instruktionerna att du får använda citat eller referat.
Dina svar kontrolleras via Urkund.
All misstanke om fusk anmäls till universitetets rektor och kan leda till en prövning i universitets disciplinnämnd.

Konsekvenser av fusk

Om du fuskar kan detta leda till en avstängning som kan få följder både för dina studier och privat:

• Uteblivet studiemedel som t.ex. som kan påverka din möjlighet att behålla din bostad.
• Ingen åtkomst till digitala plattformar.
• Du kan behöva meddela dina kursare om att du är fälld för fusk, om du t.ex. ingår i ett grupparbete på en pågående kurs men blir avstängd.
• Tillfällen för examination går förlorade vilket kan innebära att du inte kommer vidare i dina studier nästa läsperiod/termin och din studiegång blir därmed påverkad.
• Beslutet är en offentlig handling som begärs regelbundet ut av en nyhetsbyrå. Och kan även begäras ut av framtida arbetsgivare eller andra.
• Om du fuskar dig igenom din utbildning har du inte den kunskap som arbetsmarknaden förväntar av dig.

// threads-1.c

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

volatile long long data = 0;

void *thread_body(void *arg) {
    for (int i = 0; i < 1000*1000; ++i) {
        ++data;
    }
    return NULL;
}

int main(void) {
    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("Result: data = %lld\n", data);
}

int main(void) {
    pthread_t thread1, thread2;
    pthread_create(&thread1, NULL, thread_body, NULL);
    pthread_join(thread1, NULL);
    pthread_create(&thread2, NULL, thread_body, NULL);
    pthread_join(thread2, NULL);
    printf("Result: data = %lld\n", data);
}

// threads-3.c

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

volatile long long data = 0;
volatile int locked = 0;

void *thread_body(void *arg) {
    for (int i = 0; i < 1000*1000; ++i) {
        // First, wait for the lock in a loop:
        while (locked) { }
        // Lock is free, lock it:
        locked = 1;
        ++data;
        // Release the lock:
        locked = 0;
    }
    return NULL;
}

int main(void) {
    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("Result: data = %lld\n", data);
}

// create-garbage-1.c

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

#define KILO 1024
#define MEGA KILO*KILO

int main(void) {
    char buffer[1];
    buffer[0] = 'x';
    int outfd = open("garbage", O_CREAT | O_WRONLY | O_TRUNC, S_IRWXU);
    for (int i = 0; i < 10*MEGA; ++i)
        write(outfd, buffer, sizeof buffer);
    close(outfd);
}

// create-garbage-2.c

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

#define KILO 1024
#define MEGA KILO*KILO

char buffer[KILO];

int main(void) {
    for (int i = 0; i < sizeof buffer; ++i)
        buffer[i] = 'x';
    int outfd = open("garbage", O_CREAT | O_WRONLY | O_TRUNC, S_IRWXU);
    for (int i = 0; i < 10*KILO; ++i)
        write(outfd, buffer, sizeof buffer);
    close(outfd);
}

// create-garbage-3.c

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

#define KILO 1024
#define MEGA KILO*KILO

char buffer[10*KILO];

int main(void) {
    for (int i = 0; i < sizeof buffer; ++i)
        buffer[i] = 'x';
    int outfd = open("garbage", O_CREAT | O_WRONLY | O_TRUNC, S_IRWXU);
    for (int i = 0; i < KILO; ++i)
        write(outfd, buffer, sizeof buffer);
    close(outfd);
}

// create-garbage-4.c

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

#define KILO 1024
#define MEGA KILO*KILO

char buffer[10*MEGA];

int main(void) {
    for (int i = 0; i < sizeof buffer; ++i)
        buffer[i] = 'x';
    int outfd = open("garbage", O_CREAT | O_WRONLY | O_TRUNC, S_IRWXU);
    write(outfd, buffer, sizeof buffer);
    close(outfd);
}

// create-garbage-5.c

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>

#define KILO 1024
#define MEGA KILO*KILO

char buffer[MEGA];

void *thread_body(void *arg) {
    int thread_number = (int)arg;
    printf("starting thread %d...\n", thread_number);
    int outfd = open("garbage", O_WRONLY);
    // lseek moves to the place in the file where this thread will write
    lseek(outfd, thread_number * MEGA, SEEK_SET);
    write(outfd, buffer, sizeof buffer);
    close(outfd);
    printf("done thread %d\n", thread_number);
    return NULL;
}

int main(void) {
    for (int i = 0; i < sizeof buffer; ++i)
        buffer[i] = 'x';
    // To ensure the file exists and is empty before the threads start
    int outfd = open("garbage", O_CREAT | O_WRONLY | O_TRUNC, S_IRWXU);
    close(outfd);
    pthread_t threads[10];
    for (int thread = 0; thread < 10; ++thread)
        pthread_create(&threads[thread], NULL, thread_body, (void*)thread);
    for (int thread = 0; thread < 10; ++thread)
        pthread_join(threads[thread], NULL);
}