OS Lab 08

Pasted Nov 3, 2026, 3:42 AM2 files182 lines

Scan to open on your phone

Point a camera at the QR code - it opens this exact paste, no app needed.

https://codepastes.com/oslab08

inlab.cC

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

#define NUM_THREADS 3

typedef struct {
    int thread_id;
    int start;
    int end;
} ThreadData;

int total_sum = 0;
pthread_mutex_t mutex;

void *thread_task(void *arg)
{
    ThreadData *data = (ThreadData *)arg;
    int local_sum = 0;

    for (int i = data->start; i <= data->end; i++) {
        printf("Thread %d: %d\n", data->thread_id, i);
        local_sum += i;
    }

    /* Protect the shared total from simultaneous updates. */
    pthread_mutex_lock(&mutex);
    total_sum += local_sum;
    printf("Thread %d sum: %d\n", data->thread_id, local_sum);
    pthread_mutex_unlock(&mutex);

    return NULL;
}

int main(void)
{
    pthread_t threads[NUM_THREADS];
    ThreadData data[NUM_THREADS] = {
        {1, 1, 5},
        {2, 6, 10},
        {3, 11, 15}
    };

    if (pthread_mutex_init(&mutex, NULL) != 0) {
        perror("Mutex initialization failed");
        return EXIT_FAILURE;
    }

    for (int i = 0; i < NUM_THREADS; i++) {
        int result = pthread_create(&threads[i], NULL, thread_task, &data[i]);
        if (result != 0) {
            fprintf(stderr, "Could not create thread %d\n", i + 1);
            return EXIT_FAILURE;
        }
    }

    /* Wait until every thread has finished. */
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("Total sum: %d\n", total_sum);

    pthread_mutex_destroy(&mutex);
    return EXIT_SUCCESS;
}

postab.cC

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

#define NUM_READERS 5
#define NUM_WRITERS 2

int shared_data = 0;
int active_readers = 0;
int active_writers = 0;
int waiting_writers = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t readers_ok = PTHREAD_COND_INITIALIZER;
pthread_cond_t writers_ok = PTHREAD_COND_INITIALIZER;

void *reader(void *arg)
{
    int id = *(int *)arg;

    for (int i = 0; i < 3; i++) {
        pthread_mutex_lock(&mutex);

        /* Give waiting writers priority over new readers. */
        while (active_writers > 0 || waiting_writers > 0) {
            pthread_cond_wait(&readers_ok, &mutex);
        }

        active_readers++;
        printf("Reader %d reads shared_data = %d\n", id, shared_data);

        active_readers--;
        if (active_readers == 0 && waiting_writers > 0) {
            pthread_cond_signal(&writers_ok);
        }

        pthread_mutex_unlock(&mutex);
        sleep(1);
    }

    return NULL;
}

void *writer(void *arg)
{
    int id = *(int *)arg;

    for (int i = 0; i < 3; i++) {
        pthread_mutex_lock(&mutex);

        waiting_writers++;
        while (active_readers > 0 || active_writers > 0) {
            pthread_cond_wait(&writers_ok, &mutex);
        }
        waiting_writers--;

        active_writers = 1;
        shared_data++;
        printf("Writer %d updates shared_data to %d\n", id, shared_data);
        active_writers = 0;

        /* Let another waiting writer go first, if there is one. */
        if (waiting_writers > 0) {
            pthread_cond_signal(&writers_ok);
        } else {
            pthread_cond_broadcast(&readers_ok);
        }

        pthread_mutex_unlock(&mutex);
        sleep(2);
    }

    return NULL;
}

int main(void)
{
    pthread_t readers[NUM_READERS];
    pthread_t writers[NUM_WRITERS];
    int reader_ids[NUM_READERS];
    int writer_ids[NUM_WRITERS];

    for (int i = 0; i < NUM_READERS; i++) {
        reader_ids[i] = i + 1;
        if (pthread_create(&readers[i], NULL, reader, &reader_ids[i]) != 0) {
            perror("Failed to create reader thread");
            return EXIT_FAILURE;
        }
    }

    for (int i = 0; i < NUM_WRITERS; i++) {
        writer_ids[i] = i + 1;
        if (pthread_create(&writers[i], NULL, writer, &writer_ids[i]) != 0) {
            perror("Failed to create writer thread");
            return EXIT_FAILURE;
        }
    }

    for (int i = 0; i < NUM_READERS; i++) {
        pthread_join(readers[i], NULL);
    }

    for (int i = 0; i < NUM_WRITERS; i++) {
        pthread_join(writers[i], NULL);
    }

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&readers_ok);
    pthread_cond_destroy(&writers_ok);

    printf("All threads finished. Final shared_data = %d\n", shared_data);
    return EXIT_SUCCESS;
}

4,326 chars · codepastes.com