Upload files

Author: arunkumaraqm

00_copying/00_copying.c

@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <unistd.h>
+//#include <sys/types.h>
+#include <fcntl.h> // for all O_ and S_
+
+
+/*
+int open(const char *pathname, int flags); or
+int open(const char *pathname, int flags, int mode); 
+The parameter flags must include one of the following access modes: O_RDONLY, O_WRONLY, or O_RDWR. These request opening the file read-only, write-only, or read/write, respectively.
+In addition, zero or more file creation flags and file status flags can be bitwise-or’d in flags. The file creation flags are O_CREAT, O_EXCL, O_NOCTTY, and O_TRUNC.
+open() return the new file descriptor, or -1 if an error occurred.
+*/
+/*
+ssize_t read(int fd, void *buf, size_t count); // under unistd.h
+read() attempts to read up to `count` bytes from file descriptor `fd` into the buffer starting at `buf`. On success, the number of bytes read is returned. Else -1.
+*/
+
+void main()
+{
+	char buf;
+	int fd_one, fd_two;
+
+	fd_one = open("first_file", O_RDONLY);
+	
+	//fd_two = open("second_file", O_WRONLY | O_CREAT);
+	// creates second_file with perms ---sr-x--T
+	// so, specify mode explicitly
+
+	fd_two = open("second_file", 
+				  O_WRONLY | O_CREAT,
+				  S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+	// -rw-r--r-- is the default permission for new files
+	// From the table given here:  https://www.tutorialspoint.com/unix_system_calls/open.htm
+	// irusr or iwusr or irgrp or iroth = rw-r--r--
+	
+	while(read(fd_one, &buf, 1))
+	{
+		write(fd_two, &buf, 1);
+	}
+
+	printf("Successful copy");
+
+	close(fd_one);
+	close(fd_two);
+
+}

00_copying/first_file

@@ -0,0 +1,2 @@
+This is the first file.
+

00_copying/second_file

@@ -0,0 +1,2 @@
+This is the first file.
+

01_fcfs_with_arrivals/fcfs_with_arrivals.c

@@ -0,0 +1,118 @@
+#include <stdio.h> 
+#include <stdbool.h>
+
+#define max(one, two) ((one < two) ? two: one)
+typedef struct Process
+{
+	int process_number;
+	float burst;
+	float arrival;
+	float waiting;
+	float turnaround;
+} Process;
+
+void print_process(Process* proc)
+{
+	printf("(%d, %f, %f, %f, %f)\n",
+			proc->process_number, 
+			proc->burst,
+			proc->arrival,
+			proc->waiting,
+			proc->turnaround);
+}
+
+void print_process_array(int nf, Process* arr)
+{
+	for (int i = 0; i < nf; ++i)
+	{
+		print_process(&arr[i]);
+	}
+	printf("\n");
+}
+
+void read_process(Process* proc)
+{
+	scanf("%f %f",
+			&proc->burst,
+			&proc->arrival);
+}
+
+void read_process_array(int nf, Process* arr)
+{
+	for (int i = 0; i < nf; ++i)
+	{
+		arr[i].process_number = i + 1;
+		read_process(&arr[i]);
+	}
+}
+
+bool cmp_by_arrival_then_burst(Process* proc_one, Process* proc_two)
+{
+	return proc_one->arrival < proc_two->arrival ||
+		(proc_one->arrival == proc_two->arrival &&
+		 proc_one->burst < proc_two->burst);
+}
+
+bool cmp_by_process_no(Process* proc_one, Process* proc_two)
+{
+	return proc_one->process_number < proc_two->process_number;
+}
+
+void swap(Process *xp, Process *yp) 
+{ 
+	Process temp = *xp; 
+	*xp = *yp; 
+	*yp = temp; 
+} 
+
+void bubble_sort(int nf, Process* arr, bool (*lt)(Process*, Process*))
+{ 
+	int i, j; 
+	for (i = 0; i < nf - 1; i++)       
+	{
+		for (j = 0; j < nf - i - 1; j++)  
+		{
+			if (lt(&arr[j + 1], &arr[j])) 
+			{
+				swap(&arr[j], &arr[j + 1]); 
+			}
+		}
+	}
+} 
+
+void fcfs(int nf, Process* arr, float* avg_waiting, float* avg_turnaround)
+{
+	float time_elapsed = 0, sum_waiting, sum_turnaround;
+	for (int i = 0; i < nf; ++i)
+	{
+		time_elapsed = max(time_elapsed, arr[i].arrival);
+		arr[i].waiting = time_elapsed;
+		time_elapsed += arr[i].burst;
+		arr[i].turnaround = time_elapsed;
+
+		sum_waiting += arr[i].waiting;
+		sum_turnaround += arr[i].turnaround;
+	}
+
+	*avg_waiting = sum_waiting / nf;
+	*avg_turnaround = sum_turnaround / nf;
+}
+
+void main()
+{
+	int nf;
+	scanf("%d", &nf);
+
+	Process arr[nf];
+	read_process_array(nf, arr);
+	
+	bubble_sort(nf, arr, cmp_by_arrival_then_burst);
+	
+	float avg_waiting, avg_turnaround;
+	fcfs(nf, arr, &avg_waiting, &avg_turnaround);
+
+	bubble_sort(nf, arr, cmp_by_process_no);
+	print_process_array(nf, arr);
+	printf("=> (%f, %f)",
+			avg_waiting, avg_turnaround);
+}

01_fcfs_with_arrivals/test1_fcfs_with_arrivals

@@ -0,0 +1,6 @@
+4
+8 0
+4 1
+5 3
+9 2
+

01_fcfs_with_arrivals/test2_fcfs_with_arrivals

@@ -0,0 +1,6 @@
+5
+8 0
+6 0
+1 0
+9 0
+3 0

01_fcfs_with_arrivals/test3_fcfs_with_arrivals

@@ -0,0 +1,6 @@
+5
+8 0
+6 1
+1 2
+9 3
+3 4

01_fcfs_with_arrivals/test4_fcfs_with_arrivals

@@ -0,0 +1,6 @@
+5
+4 3
+3 5
+2 0
+1 5
+3 4

02_sjf_with_arrivals/sjf_with_arrivals.c

@@ -0,0 +1,141 @@
+#include <stdio.h> 
+#include <stdbool.h>
+#include <limits.h>
+
+#define max(one, two) ((one < two) ? two: one)
+typedef struct Process
+{
+	int process_number;
+	float burst;
+	float arrival;
+	float waiting;
+	float turnaround;
+} Process;
+
+void print_process(Process* proc)
+{
+	printf("(%d, %f, %f, %f, %f)\n",
+			proc->process_number, 
+			proc->burst,
+			proc->arrival,
+			proc->waiting,
+			proc->turnaround);
+}
+
+void print_process_array(int nf, Process* arr)
+{
+	for (int i = 0; i < nf; ++i)
+	{
+		print_process(&arr[i]);
+	}
+	printf("\n");
+}
+
+void read_process(Process* proc)
+{
+	scanf("%f %f",
+			&proc->burst,
+			&proc->arrival);
+}
+
+void read_process_array(int nf, Process* arr)
+{
+	for (int i = 0; i < nf; ++i)
+	{
+		arr[i].process_number = i + 1;
+		read_process(&arr[i]);
+	}
+}
+
+bool cmp_by_arrival_then_burst(Process* proc_one, Process* proc_two)
+{
+	return proc_one->arrival < proc_two->arrival ||
+		(proc_one->arrival == proc_two->arrival &&
+		 proc_one->burst < proc_two->burst);
+}
+
+bool cmp_by_process_no(Process* proc_one, Process* proc_two)
+{
+	return proc_one->process_number < proc_two->process_number;
+}
+
+void swap(Process *xp, Process *yp) 
+{ 
+	Process temp = *xp; 
+	*xp = *yp; 
+	*yp = temp; 
+} 
+
+void bubble_sort(int nf, Process* arr, bool (*lt)(Process*, Process*))
+{ 
+	int i, j; 
+	for (i = 0; i < nf - 1; i++)       
+	{
+		for (j = 0; j < nf - i - 1; j++)  
+		{
+			if (lt(&arr[j + 1], &arr[j])) 
+			{
+				swap(&arr[j], &arr[j + 1]); 
+			}
+		}
+	}
+} 
+
+void sjf(int nf, Process* arr, float* avg_waiting, float* avg_turnaround)
+{
+	float time_elapsed = 0, sum_waiting, sum_turnaround;
+	int left = 0, right = 0;
+
+	for (int i = 0; i < nf; ++i)
+	{
+		float minn = FLOAT_MAX;
+		int pos = -1;
+
+		for (int j = left; j <= right; ++j)
+		{
+			if (arr[j].burst < minn)
+			{
+				minn = arr[j].burst;
+				pos = j;
+			}
+		}
+
+		if (pos != -1) //INCOMPLETE
+		{
+			swap(&arr[pos], &arr[left]);
+			left++;
+		}
+	}
+	for (int i = 0; i < nf; ++i)
+	{
+		time_elapsed = max(time_elapsed, arr[i].arrival);
+		arr[i].waiting = time_elapsed;
+		time_elapsed += arr[i].burst;
+		arr[i].turnaround = time_elapsed;
+
+		sum_waiting += arr[i].waiting;
+		sum_turnaround += arr[i].turnaround;
+	}
+
+	*avg_waiting = sum_waiting / nf;
+	*avg_turnaround = sum_turnaround / nf;
+}
+
+void main()
+{
+	int nf;
+	scanf("%d", &nf);
+
+	Process arr[nf];
+	read_process_array(nf, arr);
+	
+	bubble_sort(nf, arr, cmp_by_arrival_then_burst);
+	
+	float avg_waiting, avg_turnaround;
+	sjf(nf, arr, &avg_waiting, &avg_turnaround);
+
+	bubble_sort(nf, arr, cmp_by_process_no);
+	print_process_array(nf, arr);
+	printf("=> (%f, %f)",
+			avg_waiting, avg_turnaround);N
+}

02_sjf_with_arrivals/test1_fcfs_with_arrivals

@@ -0,0 +1,6 @@
+4
+8 0
+4 1
+5 3
+9 2
+