diff --git a/04/lab4_win_unsynchronized.c b/04/lab4_win_unsynchronized.c index 13717b2..f33530c 100644 --- a/04/lab4_win_unsynchronized.c +++ b/04/lab4_win_unsynchronized.c @@ -10,9 +10,6 @@ int p_time; /* # of cycles to spin-wait between each call to enqueue. */ int c_time; /* # of cycles to spin-wait between each call to dequeue. */ int size; /* Size of the queue. */ int* queue; /* Queue to hold values. */ -HANDLE lock; /* Mutex semaphore. */ -HANDLE empty; /* Count semaphore increment. */ -HANDLE full; /* Count semaphore decrement. */ DWORD WINAPI producer(); DWORD WINAPI consumer(); @@ -32,9 +29,6 @@ int main(int argc, char** argv) { c_time = atoi(argv[6]); size = 0; queue = malloc(n * sizeof(int)); - empty = CreateSemaphore(NULL, 0, 0, NULL); - full = CreateSemaphore(NULL, size, size, NULL); - lock = CreateMutex(NULL, FALSE, NULL); producers = malloc(p * sizeof(HANDLE)); consumers = malloc(c * sizeof(HANDLE)); @@ -85,10 +79,6 @@ DWORD WINAPI producer() { printf("producer:> begin\n"); do { - /* P() */ - WaitForSingleObject(empty, 0); - WaitForSingleObject(lock, INFINITE); - /* Induce race condition. */ Sleep(1) @@ -103,10 +93,6 @@ DWORD WINAPI producer() { printf("producer:> size = %d\n", size); - /* V() */ - ReleaseMutex(lock); - ReleaseSemaphore(full); - Sleep(p_time); } while(n > size); @@ -121,10 +107,6 @@ DWORD WINAPI consumer() { printf("consumer:> begin\n"); do { - /* P() */ - WaitForSingleObject(full, 0); - WaitForSingleObject(lock, INFINITE); - /* Induce race condition. */ Sleep(1) @@ -138,10 +120,6 @@ DWORD WINAPI consumer() { printf("consumer:> size = %d\n", size); - /* V() */ - ReleaseMutex(lock); - ReleaseSemaphore(empty); - Sleep(c_time); } while(size > 0); diff --git a/05/Makefile b/05/Makefile new file mode 100644 index 0000000..8f45652 --- /dev/null +++ b/05/Makefile @@ -0,0 +1,3 @@ +lab5: lab5_p1.c lab5_p2.c + gcc -o lab5_p1 lab5_p1.c + gcc -o lab5_p2 lab5_p2.c diff --git a/05/lab5_p1.c b/05/lab5_p1.c new file mode 100644 index 0000000..bca119b --- /dev/null +++ b/05/lab5_p1.c @@ -0,0 +1,55 @@ +#include +#include +#include + +void decimal_to_octal(unsigned long long); + +int main(int argc, char** argv) { + unsigned long long virtual_address; + unsigned long long page_number; + unsigned long long offset; + + virtual_address = atoll(argv[1]); + + /* Bit shifting. */ + page_number = virtual_address >> 15; + + /* Bit masking. */ + offset = virtual_address & 0x7FFF; + + printf("The address %lld is equal to ", virtual_address); + decimal_to_octal(virtual_address); + + printf("Page number: %lld decimal and ", page_number); + decimal_to_octal(page_number); + + printf("Offset = %lld decimal and ", offset, offset); + decimal_to_octal(offset); + + return 0; +} + +void decimal_to_octal(unsigned long long decimal) { + char octal[64]; + char temp[64]; + int i = 0; + int k = 0; + int remainder; + + memset(octal, 0, sizeof(char)); + memset(temp, 0, sizeof(char)); + + while(decimal > 0) { + remainder = decimal % 8; + decimal /= 8; + temp[i++] = remainder + '0'; + } + + while(i >= 0) { + octal[k++] = temp[--i]; + } + + octal[k] = 0; + + printf("%s octal\n", octal); +} diff --git a/05/lab5_p2.c b/05/lab5_p2.c new file mode 100644 index 0000000..59f74b5 --- /dev/null +++ b/05/lab5_p2.c @@ -0,0 +1,134 @@ +#include +#include +#include + +#define SIZE 100 +#define FRAME_SIZE 2 + +int head = 0; +int fifo_page_faults = 0; +int lru_page_faults = 0; + +struct Page { + int index; + int reference; +}; + +void fifo(int*, int); +int frame_exists(int*, int); +/* +void lru(struct Page *, int, int); +void opt(int*, int); +int frame_exists_lru(struct Page *, int, int); +int lru_lookup(struct Page *); +*/ + +int main() { + int i; + int page_frames[FRAME_SIZE]; + int page_reference[SIZE]; + struct Page page_frames_lru[FRAME_SIZE]; + + /* Generates entropy for rand(). */ + srand(time(0)); + + for(i = 0; i < SIZE; i++) { + page_reference[i] = rand() % 14; + printf("%d ", page_reference[i]); + } + printf("\n"); + + for(i = 0; i < FRAME_SIZE; i++) { + page_frames[i] = -1; + } + + for(i = 0; i < SIZE; i++) { + fifo(page_frames, page_reference[i]); + } + + printf("FIFO page faults: %d\n", fifo_page_faults); + + /* + for(i = 0; i < FRAME_SIZE; i++) { + page_frames_lru[i].index = -1; + page_frames_lru[i].reference = -1; + } + + for(i = 0; i < SIZE; i++) { + lru(page_frames_lru, page_reference[i], i); + } + + printf("LRU page faults: %d\n", lru_page_faults); + */ + + return 0; +} + +void fifo(int* page_frames, int page_number) { + int current_page_number; + + if(!frame_exists(page_frames, page_number)) { + current_page_number = page_frames[head]; + page_frames[head] = page_number; + head = (head + 1) % FRAME_SIZE; + fifo_page_faults++; + } +} + +int frame_exists(int* page_frames, int page_number) { + int i; + + for(i = 0; i < FRAME_SIZE; i++) { + if(page_frames[i] == page_number) { + return 1; + } + } + + return 0; +} + +/* +void lru(struct Page *page_frames_lru, int page_reference, int index) { + int current_index; + int current_page_reference; + + if(!frame_exists_lru(page_frames_lru, page_reference, index)) { + current_index = lru_lookup(page_frames_lru); + current_page_reference = page_frames_lru[current_index].reference; + page_frames_lru[current_index].reference = page_reference; + page_frames_lru[current_index].index = index; + lru_page_faults++; + } +} + +int frame_exists_lru(struct Page *page_frames_lru, int page_number, int index) { + int i; + + for(i = 0; i < FRAME_SIZE; i++) { + if(page_frames_lru[i].reference == page_number) { + page_frames_lru[i].index = index; + return 1; + } + } + + return 0; +} + +int lru_lookup(struct Page *page_frames_lru) { + int i; + int k = 0; + int min = -1; + + for(i = 1; i < SIZE; i++) { + if(min > page_frames_lru[i].index) { + min = page_frames_lru[i].index; + k = i; + } + } + + return k; +} + +void opt(int* page_frames, int page_number) { +} +*/