// Program 1 C Language

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

#define ITERATIONS 2

volatile int lock = 0;
int shared_fee_records = 0;

int test_and_set(volatile int *target) {
    return __sync_lock_test_and_set(target, 1);
}

void acquire_lock() {
    while (test_and_set(&lock) == 1);
}

void release_lock() {
    __sync_lock_release(&lock);
}

void *university_process(void *arg) {
    char *process_name = (char *)arg;

    for (int i = 1; i <= ITERATIONS; i++) {
        acquire_lock();

        int old_value = shared_fee_records;
        usleep(100000);
        shared_fee_records = old_value + 1;

        printf("%s updated fee records: %d\n",
               process_name, shared_fee_records);

        release_lock();
    }

    return NULL;
}

int main() {
    pthread_t p1, p2, p3;

    setbuf(stdout, NULL);

    pthread_create(&p1, NULL, university_process, "Fee Processing");
    pthread_create(&p2, NULL, university_process, "Student Registration");
    pthread_create(&p3, NULL, university_process, "Reporting");

    pthread_join(p1, NULL);
    pthread_join(p2, NULL);
    pthread_join(p3, NULL);

    printf("\nFinal value = %d\n", shared_fee_records);
    printf("Expected value = %d\n", 3 * ITERATIONS);

    return 0;
}

// Program 2 C Language

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>
#include <sys/mman.h>
#include <sys/wait.h>

#define ITERATIONS 2

typedef struct {
    sem_t mutex;
    int total_registered_students;
} SharedData;

void update_registration(SharedData *data, const char *process_name) {
    for (int i = 1; i <= ITERATIONS; i++) {
        sem_wait(&data->mutex);

        int old_value = data->total_registered_students;
        usleep(100000);
        data->total_registered_students = old_value + 1;

        printf("%s updated registrations: %d\n",
               process_name, data->total_registered_students);

        sem_post(&data->mutex);

        usleep(50000);
    }
}

int main() {
    setbuf(stdout, NULL);

    SharedData *data = mmap(NULL, sizeof(SharedData),
                            PROT_READ | PROT_WRITE,
                            MAP_SHARED | MAP_ANONYMOUS,
                            -1, 0);

    if (data == MAP_FAILED) {
        perror("mmap failed");
        exit(1);
    }

    data->total_registered_students = 0;

    if (sem_init(&data->mutex, 1, 1) == -1) {
        perror("sem_init failed");
        munmap(data, sizeof(SharedData));
        exit(1);
    }

    pid_t pid = fork();

    if (pid < 0) {
        perror("fork failed");
        sem_destroy(&data->mutex);
        munmap(data, sizeof(SharedData));
        exit(1);
    }

    if (pid == 0) {
        update_registration(data, "Child Process: Library Management");
        munmap(data, sizeof(SharedData));
        exit(0);
    } else {
        update_registration(data, "Parent Process: Student Registration");
        wait(NULL);

        printf("\nFinal registered students = %d\n",
               data->total_registered_students);
        printf("Expected final value = %d\n", 2 * ITERATIONS);

        sem_destroy(&data->mutex);
        munmap(data, sizeof(SharedData));
    }

    return 0;
}