// gcc shm-posix-producer-string.c -o produce -lrt && ./produce
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/types.h>

void display(char *prog, char *bytes, int n) {
    printf("display: %s\n", prog);
    for (int i = 0; i < n; i++) {
        printf("%02x%c", bytes[i], ((i+1)%16) ? ' ' : '\n');
    }
    printf("\n");
}

int main() {
    const int SIZE = 4096;
    const char *name = "OS";
    const char *message0= "Studying ";
    const char *message1= "Operating Systems ";
    const char *message2= "Is Fun!";

    int shm_fd;
    void *ptr;

    /* create the shared memory segment */
    shm_fd = shm_open(name, O_CREAT | O_RDWR, 0666);

    /* configure the size of the shared memory segment */
    ftruncate(shm_fd,SIZE);

    /* now map the shared memory segment in the address space of the process */
    ptr = mmap(0,SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
    if (ptr == MAP_FAILED) {
        printf("Map failed\n");
        return -1;
    }

    /**
     * Now write to the shared memory region.
     *
     * Note we must increment the value of ptr after each write.
     */
    char *str = (char *)ptr;
    sprintf(str,"%s",message0);
    str += strlen(message0);
    sprintf(str,"%s",message1);
    str += strlen(message1);
    sprintf(str,"%s",message2);
    str += strlen(message2);
    display("prod", ptr, 64);

    return 0;
}

// gcc linux-sem_wait.c -pthread
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

#define BUFFER_SIZE 5
int buffer[BUFFER_SIZE];

pthread_mutex_t mutex;
sem_t empty;
sem_t full;

int insertPointer = 0, removePointer = 0;

void *producer(void *param);
void *consumer(void *param);

void display_int_array(char *prog, int *arr, int n) {
    printf("%s: ", prog);
    for (int i = 0; i < n; i++) {
        printf("%d%c", arr[i], ((i+1)%16) ? ' ' : '\n');
    }
    printf("\n");
}

int insert_item(int item) {
    /* Acquire Empty Semaphore */
    sem_wait(&empty);
    
    /* Acquire mutex lock to protect buffer */
    pthread_mutex_lock(&mutex);

    buffer[insertPointer++] = item;
    insertPointer = insertPointer % BUFFER_SIZE;
    display_int_array("prod", buffer, BUFFER_SIZE);

    /* Release mutex lock and full semaphore */
    pthread_mutex_unlock(&mutex);
    sem_post(&full);

    return 0;
}

int remove_item(int *item) {
    /* Acquire Full Semaphore */
    sem_wait(&full);

    /* Acquire mutex lock to protect buffer */
    pthread_mutex_lock(&mutex);

    *item = buffer[removePointer];
    buffer[removePointer++] = -1;
    removePointer = removePointer % BUFFER_SIZE;
    display_int_array("cons", buffer, BUFFER_SIZE);

    /* Release mutex lock and empty semaphore */
    pthread_mutex_unlock(&mutex);
    sem_post(&empty);

    return 0;
}

int main(int argc, char *argv[]) {
    int sleepTime = 10, producerThreads, consumerThreads;

    /* Initialize the synchronization tools */
    pthread_mutex_init(&mutex, NULL);
    sem_init(&empty, 0, BUFFER_SIZE);
    sem_init(&full, 0, 0);
    srand(time(0));

    /* Create the producer and consumer threads */
    {
        pthread_t tid;
        pthread_attr_t attr;
        pthread_attr_init(&attr);
        pthread_create(&tid, &attr, producer, NULL);
    }

    {
        pthread_t tid;
        pthread_attr_t attr;
        pthread_attr_init(&attr);
        pthread_create(&tid, &attr, consumer, NULL);
    }

    /* Sleep for user specified time */
    sleep(sleepTime);
    return 0;
}

void *producer(void *param) {
    int random;
    int r;

    while (1) {
        r = rand() % 3;
        sleep(r);
        random = rand() % 20 + 1;

        if (insert_item(random))
            fprintf(stderr, "Error");

        printf("Producer produced %d \n", random);
    }
}

void *consumer(void *param) {
    int random;
    int r;

    while (1) {
        r = rand() % 3;
        sleep(r);

        if (remove_item(&random))
            fprintf(stderr, "Error Consuming");
        else
            printf("Consumer consumed %d \n", random);
    }
}

// gcc linux-sem_wait-2.c -lrt -pthread
#include <semaphore.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>

void display(char *prog, char *bytes, int n) {
    printf("%s: ", prog);
    for (int i = 0; i < n; i++) {
        printf("%02x%c", bytes[i], ((i+1)%16) ? ' ' : '\n');
    }
    printf("\n");
}

int main(int argc, char **argv) {
    int fd, i, count = 0,nloop = 2,zero = 0, *ptr;
    sem_t *mutex;

    int shm;
    if ((shm = shm_open("myshm", O_RDWR | O_CREAT, S_IRWXU)) == 0) {
        perror("shm_open");
        exit(1);
    }

    if (ftruncate(shm, sizeof(sem_t)) < 0 ) {
        perror("ftruncate");
        exit(1);
    }

    if ((mutex = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE,
                      MAP_SHARED, shm, 0)) == MAP_FAILED) {
        perror("mmap");
        exit(1);
    }

    // open a file and map it into memory
    fd = open("tmp.txt",O_RDWR | O_CREAT, S_IRWXU);
    write(fd, &zero, sizeof(int));
    ptr = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    close(fd);

    /*if ((mutex = sem_open("mysemaphore", O_CREAT, 0644, 1)) == SEM_FAILED) {
        perror("semaphore initilization");
        exit(1);
    }*/

    // create, initialize semaphore
    if (sem_init(mutex, 1, 1) < 0) {
        perror("semaphore initilization");
        exit(0);
    }

    if (fork() == 0) { // child process
        for (i = 0; i < nloop; i++) {
            sem_wait(mutex);
            printf("child entered crititical section: %d\n", (*ptr)++);
            display("child", (char *)ptr, 16);
            sleep(2);
            printf("child leaving critical section\n");
            sem_post(mutex);
            sleep(1);
        }
        exit(0);
    }

    // back to parent process
    for (i = 0; i < nloop; i++) {
        sem_wait(mutex);
        printf("parent entered critical section: %d\n", (*ptr)++);
        display("parent", (char *)ptr, 16);
        sleep(2);
        printf("parent leaving critical section\n");
        sem_post(mutex);
        sleep(1);
    }

    return 0;
}