mirror of
https://github.com/caperren/school_archives.git
synced 2025-11-09 21:51:15 +00:00
Added OS II assignments
This commit is contained in:
@@ -0,0 +1,9 @@
|
||||
all: clean build
|
||||
|
||||
clean:
|
||||
rm -f *.o
|
||||
rm -f concurrency3_problem1 concurrency3_problem2
|
||||
|
||||
build:
|
||||
gcc problem1.c mt19937ar.h -o concurrency3_problem1 -std=c99 -lpthread -lrt
|
||||
gcc problem2.c mt19937ar.h -o concurrency3_problem2 -std=c99 -lpthread -lrt
|
||||
@@ -0,0 +1,190 @@
|
||||
/*
|
||||
A C-program for MT19937, with initialization improved 2002/1/26.
|
||||
Coded by Takuji Nishimura and Makoto Matsumoto.
|
||||
|
||||
Before using, initialize the state by using init_genrand(seed)
|
||||
or init_by_array(init_key, key_length).
|
||||
|
||||
Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. The names of its contributors may not be used to endorse or promote
|
||||
products derived from this software without specific prior written
|
||||
permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
|
||||
Any feedback is very welcome.
|
||||
http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
|
||||
email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
/* Period parameters */
|
||||
#define N 624
|
||||
#define M 397
|
||||
#define MATRIX_A 0x9908b0dfUL /* constant vector a */
|
||||
#define UPPER_MASK 0x80000000UL /* most significant w-r bits */
|
||||
#define LOWER_MASK 0x7fffffffUL /* least significant r bits */
|
||||
|
||||
static unsigned long mt[N]; /* the array for the state vector */
|
||||
static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */
|
||||
|
||||
/* initializes mt[N] with a seed */
|
||||
void init_genrand(unsigned long s)
|
||||
{
|
||||
mt[0]= s & 0xffffffffUL;
|
||||
for (mti=1; mti<N; mti++) {
|
||||
mt[mti] =
|
||||
(1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
|
||||
/* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
|
||||
/* In the previous versions, MSBs of the seed affect */
|
||||
/* only MSBs of the array mt[]. */
|
||||
/* 2002/01/09 modified by Makoto Matsumoto */
|
||||
mt[mti] &= 0xffffffffUL;
|
||||
/* for >32 bit machines */
|
||||
}
|
||||
}
|
||||
|
||||
/* initialize by an array with array-length */
|
||||
/* init_key is the array for initializing keys */
|
||||
/* key_length is its length */
|
||||
/* slight change for C++, 2004/2/26 */
|
||||
void init_by_array(unsigned long init_key[], int key_length)
|
||||
{
|
||||
int i, j, k;
|
||||
init_genrand(19650218UL);
|
||||
i=1; j=0;
|
||||
k = (N>key_length ? N : key_length);
|
||||
for (; k; k--) {
|
||||
mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525UL))
|
||||
+ init_key[j] + j; /* non linear */
|
||||
mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
|
||||
i++; j++;
|
||||
if (i>=N) { mt[0] = mt[N-1]; i=1; }
|
||||
if (j>=key_length) j=0;
|
||||
}
|
||||
for (k=N-1; k; k--) {
|
||||
mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941UL))
|
||||
- i; /* non linear */
|
||||
mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
|
||||
i++;
|
||||
if (i>=N) { mt[0] = mt[N-1]; i=1; }
|
||||
}
|
||||
|
||||
mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
|
||||
}
|
||||
|
||||
/* generates a random number on [0,0xffffffff]-interval */
|
||||
unsigned long genrand_int32(void)
|
||||
{
|
||||
unsigned long y;
|
||||
static unsigned long mag01[2]={0x0UL, MATRIX_A};
|
||||
/* mag01[x] = x * MATRIX_A for x=0,1 */
|
||||
|
||||
if (mti >= N) { /* generate N words at one time */
|
||||
int kk;
|
||||
|
||||
if (mti == N+1) /* if init_genrand() has not been called, */
|
||||
init_genrand(5489UL); /* a default initial seed is used */
|
||||
|
||||
for (kk=0;kk<N-M;kk++) {
|
||||
y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
|
||||
mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1UL];
|
||||
}
|
||||
for (;kk<N-1;kk++) {
|
||||
y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
|
||||
mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
|
||||
}
|
||||
y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
|
||||
mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1UL];
|
||||
|
||||
mti = 0;
|
||||
}
|
||||
|
||||
y = mt[mti++];
|
||||
|
||||
/* Tempering */
|
||||
y ^= (y >> 11);
|
||||
y ^= (y << 7) & 0x9d2c5680UL;
|
||||
y ^= (y << 15) & 0xefc60000UL;
|
||||
y ^= (y >> 18);
|
||||
|
||||
return y;
|
||||
}
|
||||
|
||||
/* generates a random number on [0,0x7fffffff]-interval */
|
||||
long genrand_int31(void)
|
||||
{
|
||||
return (long)(genrand_int32()>>1);
|
||||
}
|
||||
|
||||
/* generates a random number on [0,1]-real-interval */
|
||||
double genrand_real1(void)
|
||||
{
|
||||
return genrand_int32()*(1.0/4294967295.0);
|
||||
/* divided by 2^32-1 */
|
||||
}
|
||||
|
||||
/* generates a random number on [0,1)-real-interval */
|
||||
double genrand_real2(void)
|
||||
{
|
||||
return genrand_int32()*(1.0/4294967296.0);
|
||||
/* divided by 2^32 */
|
||||
}
|
||||
|
||||
/* generates a random number on (0,1)-real-interval */
|
||||
double genrand_real3(void)
|
||||
{
|
||||
return (((double)genrand_int32()) + 0.5)*(1.0/4294967296.0);
|
||||
/* divided by 2^32 */
|
||||
}
|
||||
|
||||
/* generates a random number on [0,1) with 53-bit resolution*/
|
||||
double genrand_res53(void)
|
||||
{
|
||||
unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6;
|
||||
return(a*67108864.0+b)*(1.0/9007199254740992.0);
|
||||
}
|
||||
/* These real versions are due to Isaku Wada, 2002/01/09 added */
|
||||
|
||||
//int main(void)
|
||||
//{
|
||||
// int i;
|
||||
// unsigned long init[4]={0x123, 0x234, 0x345, 0x456}, length=4;
|
||||
// init_by_array(init, length);
|
||||
// printf("1000 outputs of genrand_int32()\n");
|
||||
// for (i=0; i<1000; i++) {
|
||||
// printf("%10lu ", genrand_int32());
|
||||
// if (i%5==4) printf("\n");
|
||||
// }
|
||||
// printf("\n1000 outputs of genrand_real2()\n");
|
||||
// for (i=0; i<1000; i++) {
|
||||
// printf("%10.8f ", genrand_real2());
|
||||
// if (i%5==4) printf("\n");
|
||||
// }
|
||||
// return 0;
|
||||
//}
|
||||
@@ -0,0 +1,172 @@
|
||||
/*
|
||||
* 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 MAX_NUM_THREADS 4
|
||||
#define MAX_RESOURCE_USAGE 3
|
||||
|
||||
#define MIN_RANDOM_USE_WAIT 3
|
||||
#define MAX_RANDOM_USE_WAIT 5
|
||||
|
||||
//RDRAND value to check for
|
||||
#define RDRAND_FLAG (1 << 30)
|
||||
|
||||
sem_t resource_semaphore;
|
||||
uint8_t wait_for_resource_recovery = 0;
|
||||
|
||||
// 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 resource_user_wait(uint8_t id, uint8_t *wait_kind){
|
||||
uint8_t random = get_random_number(MIN_RANDOM_USE_WAIT, MAX_RANDOM_USE_WAIT);
|
||||
|
||||
printf("Resource user %d waiting %u seconds for %s.\n", id, random, wait_kind);
|
||||
fflush(stdout);
|
||||
|
||||
sleep(random);
|
||||
}
|
||||
|
||||
void *resource_user(void *thread_num){
|
||||
|
||||
uint8_t thread_number = *((uint8_t *)thread_num);
|
||||
|
||||
printf("Resourcing using thread with id: %d now running.\n", thread_number);
|
||||
fflush(stdout);
|
||||
|
||||
while(1){
|
||||
resource_user_wait(thread_number, "initial wait");
|
||||
|
||||
if(wait_for_resource_recovery){
|
||||
printf("Resource user %d waiting for recovery of all resources.\n", thread_number);
|
||||
fflush(stdout);
|
||||
while(wait_for_resource_recovery);
|
||||
}
|
||||
|
||||
sem_wait(&resource_semaphore);
|
||||
|
||||
printf("Resource user %d now using resource.\n", thread_number);
|
||||
fflush(stdout);
|
||||
|
||||
resource_user_wait(thread_number, "usage wait");
|
||||
|
||||
printf("Resource user %d done with resource.\n", thread_number);
|
||||
fflush(stdout);
|
||||
|
||||
sem_post(&resource_semaphore);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
// Containers to hold our threads, and the philosopher index
|
||||
pthread_t usage_threads[MAX_NUM_THREADS];
|
||||
uint8_t thread_id_numbers[MAX_NUM_THREADS];
|
||||
|
||||
// Initialize semaphores, and arrays used to keep track of things
|
||||
sem_init(&resource_semaphore, 0, MAX_RESOURCE_USAGE);
|
||||
|
||||
for(uint8_t i = 0 ; i < MAX_NUM_THREADS ; i++){
|
||||
thread_id_numbers[i] = i;
|
||||
}
|
||||
|
||||
// Create all the philosopher threads
|
||||
for(uint8_t i = 0 ; i < MAX_NUM_THREADS ; i++){
|
||||
if(pthread_create(&usage_threads[i], NULL, resource_user, &thread_id_numbers[i])) {
|
||||
fprintf(stderr, "Error creating thread\n");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
int used_semaphores = 0;
|
||||
uint8_t resources_left = MAX_RESOURCE_USAGE;
|
||||
uint8_t last_resources_left_value = resources_left;
|
||||
|
||||
|
||||
while(1){
|
||||
sem_getvalue(&resource_semaphore, &used_semaphores);
|
||||
|
||||
resources_left = MAX_RESOURCE_USAGE - used_semaphores;
|
||||
|
||||
if(resources_left != last_resources_left_value){
|
||||
|
||||
printf("Manager ### Resources currently used: %d\n", resources_left);
|
||||
fflush(stdout);
|
||||
|
||||
if(resources_left == MAX_RESOURCE_USAGE){
|
||||
printf("Manager ### Maximum resources used. Locking out.\n");
|
||||
fflush(stdout);
|
||||
wait_for_resource_recovery = 1;
|
||||
}else if (resources_left == 0){
|
||||
wait_for_resource_recovery = 0;
|
||||
}
|
||||
|
||||
last_resources_left_value = resources_left;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -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(¤t_light_switch->mutex);
|
||||
current_light_switch->counter++;
|
||||
|
||||
if(current_light_switch->counter == 1){
|
||||
sem_wait(current_semaphore);
|
||||
}
|
||||
|
||||
sem_post(¤t_light_switch->mutex);
|
||||
}
|
||||
|
||||
void light_switch_unlock(light_switch *current_light_switch, sem_t *current_semaphore){
|
||||
sem_wait(¤t_light_switch->mutex);
|
||||
current_light_switch->counter--;
|
||||
|
||||
if(current_light_switch->counter == 0){
|
||||
sem_post(current_semaphore);
|
||||
}
|
||||
|
||||
sem_post(¤t_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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
Corwin Perren - Concurrency HW 3
|
||||
|
||||
To make this program on the os server, cd into this directory and run "make".
|
||||
|
||||
To run program1, type "./concurrency3_problem1" into the terminal and hit enter.
|
||||
To run program2, type "./concurrency3_problem2" into the terminal and hit enter.
|
||||
Reference in New Issue
Block a user