Initial Commit

Author: Loriah Pope

#kernel.c#

@@ -0,0 +1,104 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "hardware.h"
+#include "drivers.h"
+#include "kernel.h"
+
+
+
+/* You may use the definitions below, if you are so inclined, to
+   define the process table entries. Feel free to use your own
+   definitions, though. */
+
+
+typedef enum { RUNNING, READY, BLOCKED , UNINITIALIZED } PROCESS_STATE;
+
+typedef struct process_table_entry {
+  PROCESS_STATE state;
+  int CPU_time_used;
+  int quantum_start_time;
+} PROCESS_TABLE_ENTRY;
+
+extern PROCESS_TABLE_ENTRY process_table[];
+
+
+/* A quantum is 40 ms */
+
+#define QUANTUM 40
+
+PROCESS_TABLE_ENTRY process_table[MAX_NUMBER_OF_PROCESSES];
+
+
+/* You may use this code for maintaining a queue of
+   ready processes. It's simply a linked list structure
+   with each element containing the PID of a ready process */    
+
+typedef struct ready_queue_elt {
+  struct ready_queue_elt *next;
+  PID_type pid;
+} READY_QUEUE_ELT;
+
+
+READY_QUEUE_ELT *ready_queue_head = NULL;  /* head of the event queue */
+READY_QUEUE_ELT *ready_queue_tail = NULL;
+
+
+//places process id at end of ready queue
+
+void queue_ready_process(PID_type pid)
+{
+  //  printf("QUEUEING ready PID %d\n", pid);
+  READY_QUEUE_ELT *p = (READY_QUEUE_ELT *) malloc(sizeof(READY_QUEUE_ELT));
+  p->pid = pid;
+  p->next = NULL;
+  if (ready_queue_tail == NULL) 
+    if (ready_queue_head == NULL) {
+      ready_queue_head = ready_queue_tail = p;
+      p->next = NULL;
+    }
+    else {
+      printf("Error: ready queue tail is NULL but ready_queue_head is not\n");
+      exit(1);
+    }
+  else {
+    ready_queue_tail->next = p;
+    ready_queue_tail = p;
+  }
+}
+
+
+
+
+//removes and returns PID from front of ready queue
+
+PID_type dequeue_ready_process()
+{
+  if (ready_queue_head == NULL)
+    if (ready_queue_tail == NULL)
+      return IDLE_PROCESS;        // indicates no active process is ready
+    else {
+      printf("Error: ready_queue_head is NULL but ready_queue_tail is not\n");
+      exit(1);
+    }
+  else {      
+    READY_QUEUE_ELT *p = ready_queue_head;
+    ready_queue_head = ready_queue_head->next;
+    if (ready_queue_head == NULL)
+      ready_queue_tail = NULL;
+    return p->pid;
+  }
+}
+
+
+/* This procedure is automatically called when the 
+   (simulated) machine boots up */
+
+void initialize_kernel()
+{
+  // Put any initialization code you want here.
+  // Remember, the process 0 will automatically be
+  // executed after initialization (and current_pid
+  // will automatically be set to 0), 
+  // so the your process table should reflect that fact.
+}

Makefile

@@ -0,0 +1,15 @@
+# Simple Makefile for Project 1
+
+srcdir  = .
+
+CC      = gcc
+EXE	= 
+CFLAGS  = -m32
+
+TARGETS = system$(EXE)
+
+all: $(TARGETS)
+
+system$(EXE): $(srcdir)/kernel.o $(srcdir)/drivers.o $(srcdir)/hardware.o
+	$(CC) -o system$(EXE) $(CFLAGS) $(srcdir)/kernel.o  $(srcdir)/hardware.o $(srcdir)/drivers.o
+

ben_system

@@ -0,0 +1,32 @@
+
+#define DISK_READ_OVERHEAD 50  /* 50 ms read overhead */
+
+#define BLOCK_READ_TIME 1 /* 1 ms per disk block */
+
+/* The disk read takes an overhead of 50ms + (1ms * size of data) */
+
+/* This is the driver routine to call to issue a
+   (blocking) disk read request. An interrupt will automatically
+   occur when the read has completed */
+
+extern void disk_read_req(PID_type pid, int size); 
+
+/* For our purposes, the reading the keyboard
+   buffer takes 100 milliseconds */
+
+#define KEYBOARD_READ_OVERHEAD 100
+
+/* This is the driver routine to call to issue a
+   (blocking) keyboard read. An interrupt will automatically
+   occur when the read has completed */
+
+extern void keyboard_read_req(PID_type pid);
+
+
+/* This is the driver routine to call to issue a
+   (non-blocking) disk write. It returns immediately
+   (i.e. the write is assumed to take 0 time). */
+
+extern void disk_write_req(PID_type pid);
+
+

drivers.h

@@ -0,0 +1,117 @@
+
+typedef int BOOL;
+#define TRUE 1
+#define FALSE 0
+
+/* A PID is just an int */
+
+typedef int PID_type;
+
+/* This is the variable (e.g. a special register) containing 
+   the PID of the process that is currently running */
+
+extern PID_type current_pid;
+
+
+/* This defines the maximum number of processes that can
+   be supported on this machine */
+   
+#define MAX_NUMBER_OF_PROCESSES 20
+
+/* When there is no process ready to run, the current_pid
+   should be set to the pid of the "idle process", 
+   i.e IDLE_PROCESS (with a pid of -1). */
+
+#define IDLE_PROCESS -1
+
+
+/* Time is kept as an unsigned int, in units of 
+   milliseconds */
+
+typedef unsigned int CLOCK_TIME; /* time in ms */
+
+
+/* These are the machine's registers that are used
+   to store information about trap or interrupt
+   that has occurred (see below). */
+
+extern int R1, R2, R3, R4; /* registers for holding 
+                              trap or interrupt info */
+
+
+/* This is the clock holding the current time (in ms).
+   Only the hardware can change the value of it, do
+   not write to it! */
+
+extern CLOCK_TIME clock;  /* system clock in ms */
+
+/* A clock interrupt is generated by the hardware every 10 ms.
+   Note that this may be shorter than the quantum given to
+   each process. */
+
+#define CLOCK_INTERRUPT_PERIOD 10
+
+
+
+/* These are the interrupt numbers for various different interrupts (including
+   a trap). IMPORTANT: An interrupt number corresponds to the element in the 
+   INTERRUPT_TABLE containing a pointer to the interrupt handler */
+
+
+/* A Trap is interrupt 0. Note the description below about the state of 
+   the registers when a trap occurs, in order to determine why the trap
+   occurred (disk read request, keyboard request, etc.) */
+
+#define TRAP 0
+
+
+/* The clock interrupt is interrupt 1. */
+
+#define CLOCK_INTERRUPT 1 
+
+
+/* A disk interrupt, issued by the hardware when a requested disk read
+   operation has completed, is interrupt 2. The PID of process that requested the 
+   disk read is placed in R1 by the hardware */
+
+#define DISK_INTERRUPT 2   
+
+
+/* A keyboard interrupt, issued by the hardware when a requested keyboard read
+   operation has completed, is interrupt 2. The PID of process that requested the 
+   keyboard read is placed in R1 by the hardware */
+
+#define KEYBOARD_INTERRUPT 3  /* occurs when requested keyboard buffer is available */
+
+
+/* The various kinds of TRAPs are listed below. When a trap occurs (via 
+   interrupt 0, see above) register R1 will contain one of the following
+   values. Register R2 will, in some of the cases as described below,
+   contain a value as well. */
+
+#define DISK_READ 0  /* Size of data should be placed in R2 */
+#define DISK_WRITE 1  /* non-blocking write to disk */
+#define KEYBOARD_READ 2 /* Blocking read of keyboard buffer */
+#define FORK_PROGRAM 3  /* PID of new process will be in R2 */
+#define END_PROGRAM 4 /* PID of ending processing will be in R2 */
+
+
+/* The interrupt table, INTERRUPT_TABLE, is an array of pointers 
+   to functions (with no arguments and no return type). For
+   example, if the handler for a trap is the function defined by
+
+   void handle_trap() { ... }
+
+   then the appropriate element of the interrupt table can be assigned 
+   as follows:
+
+   INTERRUPT_TABLE[TRAP] = handle_trap;
+
+   When a trap occurs (due to a system call by the running process), 
+   the function that INTERRUPT_TABLE[TRAP] points to will automatically
+   be called.  */
+
+typedef void (*FN_TYPE)();
+
+extern FN_TYPE INTERRUPT_TABLE[];
+