Added OS II assignments

OSU Coursework/CS 444 - Operating Systems II/Concurrency Assignments/Concurrency 3/problem2.c

@@ -0,0 +1,339 @@
+/* 
+ * File:   main.c
+ * Author: caperren
+ *
+ * Created on April 27th, 2018
+ */
+
+#include "mt19937ar.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <sys/param.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <semaphore.h>
+
+////////// Program defines you might want to change //////////
+#define NUM_INSERTERS 2
+#define NUM_DELETERS 2
+#define NUM_SEARCHERS 2
+
+#define MIN_NUMBER 0
+#define MAX_NUMBER 10
+
+#define MIN_SLEEP_INSERTER 2
+#define MAX_SLEEP_INSERTER 4
+
+#define MIN_SLEEP_SEARCHER 1
+#define MAX_SLEEP_SEARCHER 2
+
+#define MIN_SLEEP_DELETER 10
+#define MAX_SLEEP_DELETER 15
+
+////////// Global variables and structs for linked list //////////
+typedef struct linked_list {
+    struct linked_list *next;
+    uint16_t value;
+} linked_list;
+
+linked_list *list_head = NULL;
+uint16_t list_size = 0;
+
+
+////////// Global variables and structs for threading and sempaphores //////////
+typedef struct light_switch {
+    uint16_t counter;
+    sem_t mutex;
+} light_switch;
+
+
+sem_t no_searches_semaphore;
+sem_t no_insertions_semaphore;
+sem_t insertion_mutex;
+
+light_switch insertion_light_switch;
+light_switch search_light_switch;
+
+
+////////// Other global variables //////////
+//RDRAND value to check for
+#define RDRAND_FLAG (1 << 30)
+
+// Get random number based on whether rdrand is supported.
+uint8_t get_random_number(uint8_t min, uint8_t max) {
+    uint8_t rand_val;
+    unsigned long seed;
+
+    unsigned int eax;
+    unsigned int ebx;
+    unsigned int ecx;
+    unsigned int edx;
+
+    eax = 0x01;
+
+    // ASM for checking if RDRAND supported
+    __asm__ __volatile__("cpuid"
+            : "=a" (eax),
+            "=b" (ebx),
+            "=c" (ecx),
+            "=d" (edx)
+            : "a" (1),
+            "c" (0)
+            );
+
+    // Seed random with /dev/random
+    int random = open("/dev/random", O_RDONLY);
+    read(random, &seed, sizeof (seed));
+
+    unsigned int random_value;
+
+    if ((ecx & RDRAND_FLAG) == RDRAND_FLAG) {
+	char return_code = 0;
+	char count = 0;
+
+        // ASM for RDRAND
+	while(return_code != 1 && count < 10){
+		__asm__ volatile(
+		        "rdrand %0 ; setc %1"
+		        : "=r" (random_value), "=qm" (return_code)
+		);
+
+		count++;
+	}
+    } else {
+        // Twister if RDRAND not supported
+        init_genrand(seed);
+	    random_value = genrand_int32();
+    }
+
+    return (random_value % (max + 1 - min)) + min;
+}
+
+void insert_linked_list(uint16_t value){
+    linked_list *new = malloc(sizeof(linked_list));
+    new->next = NULL;
+    new->value = value;
+
+    if(list_head == NULL){
+        list_head = new;
+    }else{
+        linked_list *cursor = list_head;
+
+        while(cursor->next != NULL){
+            cursor = cursor->next;
+        }
+        cursor->next = new;
+    }
+
+    list_size++;
+}
+
+void delete_position_from_linked_list(uint16_t position) {
+    linked_list *cursor_prev = list_head;
+    linked_list *cursor_current = list_head;
+
+    if(list_head == NULL || position >= list_size){
+        return;
+    }
+
+    if(position == 0){
+        list_head = cursor_current->next;
+        free(cursor_current);
+    }else{
+        for(uint16_t i = 0 ; i < position ; i++){
+            cursor_prev = cursor_current;
+            cursor_current = cursor_current->next;
+        }
+
+        cursor_prev->next = cursor_current->next;
+        free(cursor_current);
+    }
+
+    list_size--;
+}
+
+int16_t position_of_value_linked_list(uint16_t value){
+    linked_list *cursor_current = list_head;
+
+    if(list_head == NULL){
+        return -1;
+    }
+
+    uint16_t count = 0;
+
+    do{
+        if(cursor_current->value == value){
+            return count;
+        }
+
+        count++;
+        cursor_current = cursor_current->next;
+    }while(cursor_current != NULL);
+
+    return -1;
+}
+
+void light_switch_lock(light_switch *current_light_switch, sem_t *current_semaphore){
+    sem_wait(&current_light_switch->mutex);
+    current_light_switch->counter++;
+
+    if(current_light_switch->counter == 1){
+        sem_wait(current_semaphore);
+    }
+
+    sem_post(&current_light_switch->mutex);
+}
+
+void light_switch_unlock(light_switch *current_light_switch, sem_t *current_semaphore){
+    sem_wait(&current_light_switch->mutex);
+    current_light_switch->counter--;
+
+    if(current_light_switch->counter == 0){
+        sem_post(current_semaphore);
+    }
+
+    sem_post(&current_light_switch->mutex);
+}
+
+void *inserter_thread(){
+    printf("Inserter starting.\n");
+    fflush(stdout);
+
+    sleep(2); //Do this so you can easily see threads starting
+
+    while(1){
+        uint16_t new_number = get_random_number(MIN_NUMBER, MAX_NUMBER);
+        uint16_t sleep_time = get_random_number(MIN_SLEEP_INSERTER, MAX_SLEEP_INSERTER);
+
+        printf("Inserter going to sleep for %d seconds.\n", sleep_time);
+        fflush(stdout);
+        sleep(sleep_time);
+
+        printf("Inserter awake and waiting for access.\n");
+        fflush(stdout);
+        light_switch_lock(&insertion_light_switch, &no_insertions_semaphore);
+        sem_wait(&insertion_mutex);
+
+        printf("Inserter now has access.\n");
+        printf("Inserting number %u.\n", new_number);
+        fflush(stdout);
+        insert_linked_list(new_number);
+
+        sem_post(&insertion_mutex);
+        light_switch_unlock(&insertion_light_switch, &no_insertions_semaphore);
+    }
+}
+
+void *searcher_thread(){
+    printf("Searcher starting.\n");
+    fflush(stdout);
+
+    sleep(2); //Do this so you can easily see threads starting
+
+    while(1){
+        uint16_t search_value = get_random_number(MIN_NUMBER, MAX_NUMBER);
+        uint16_t sleep_time = get_random_number(MIN_SLEEP_SEARCHER, MAX_SLEEP_SEARCHER);
+
+        printf("Searcher going to sleep for %d seconds.\n", sleep_time);
+        fflush(stdout);
+        sleep(sleep_time);
+
+        printf("Searcher awake and waiting for access.\n");
+        fflush(stdout);
+        light_switch_lock(&search_light_switch, &no_searches_semaphore);
+
+        printf("Searcher has access.\n");
+        fflush(stdout);
+
+        int16_t value = position_of_value_linked_list(search_value);
+
+        if(value != -1){
+            printf("Search successful. Found value %d.\n", value);
+        } else {
+            printf("Search unsuccessful. Could not find value %u.\n", search_value);
+        }
+        fflush(stdout);
+
+        light_switch_unlock(&search_light_switch, &no_searches_semaphore);
+
+    }
+}
+
+void *deleter_thread(){
+    printf("Deleter starting.\n");
+    fflush(stdout);
+
+    sleep(2); //Do this so you can easily see threads starting
+
+    while(1){
+        uint16_t sleep_time = get_random_number(MIN_SLEEP_DELETER, MAX_SLEEP_DELETER);
+
+        printf("Deleter going to sleep for %d seconds.\n", sleep_time);
+        fflush(stdout);
+        sleep(sleep_time);
+
+        printf("Deleter awake and waiting for access.\n");
+        fflush(stdout);
+        sem_wait(&no_searches_semaphore);
+        sem_wait(&no_insertions_semaphore);
+
+        uint16_t delete_position = get_random_number(0, list_size);
+
+        printf("Deleter has access.\n");
+        printf("Deleting node at position %d.\n", delete_position);
+        fflush(stdout);
+        delete_position_from_linked_list(delete_position);
+
+        sem_post(&no_insertions_semaphore);
+        sem_post(&no_searches_semaphore);
+    }
+}
+
+int main(int argc, char **argv) {
+    // Storage for threads
+    pthread_t inserters[NUM_INSERTERS];
+    pthread_t searchers[NUM_INSERTERS];
+    pthread_t deleters[NUM_INSERTERS];
+
+    // Initialize light switches
+    sem_init(&insertion_light_switch.mutex, 1, 1);
+    insertion_light_switch.counter = 0;
+
+    sem_init(&search_light_switch.mutex, 1, 1);
+    search_light_switch.counter = 0;
+
+    // Initialize other semaphores and mutex
+    sem_init(&no_insertions_semaphore, 1, 1);
+    sem_init(&no_searches_semaphore, 1, 1);
+    sem_init(&insertion_mutex, 1, 1);
+
+    // Spin up threads
+    for(uint8_t i = 0 ; i < NUM_INSERTERS ; i++){
+        pthread_create(&inserters[i], NULL, inserter_thread, NULL);
+    }
+
+    for(uint8_t i = 0 ; i < NUM_SEARCHERS ; i++){
+        pthread_create(&searchers[i], NULL, searcher_thread, NULL);
+    }
+
+    for(uint8_t i = 0 ; i < NUM_DELETERS ; i++){
+        pthread_create(&deleters[i], NULL, deleter_thread, NULL);
+    }
+
+    // Wait for threads to join for completion.
+    for(uint8_t i = 0 ; i < NUM_INSERTERS ; i++){
+        pthread_join(inserters[i], NULL);
+    }
+
+    for(uint8_t i = 0 ; i < NUM_SEARCHERS ; i++){
+        pthread_join(searchers[i], NULL);
+    }
+
+    for(uint8_t i = 0 ; i < NUM_DELETERS ; i++){
+        pthread_join(deleters[i], NULL);
+    }
+}