submission

sthreads/Makefile

 ASFLAGS = -g
 
 
-all: test
+all: test test_arg test_ret
 
+test_arg: sthread.o queue.o glue.o test_arg.o
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^
+
+test_ret: sthread.o queue.o glue.o test_ret.o
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^
 
 # The simple test program
 test: sthread.o queue.o glue.o test.o
 
 # pseudo-target to clean up
 clean:
-	$(RM) -f *.o core* *~ test
+	$(RM) -f *.o core* *~ test test_arg test_ret
 
 
 .PHONY: all clean

sthreads/glue.s

 __sthread_switch:
 
         # Save the process state onto its stack
-        # TODO
+        pushq   %rax
+        pushq   %rbx
+        pushq   %rcx
+        pushq   %rdx
+        pushq   %rsi
+        pushq   %rdi
+        pushq   %rbp
+
+        pushq   %r8
+        pushq   %r9
+        pushq   %r10
+        pushq   %r11
+        pushq   %r12
+        pushq   %r13
+        pushq   %r14
+        pushq   %r15
+
+        pushf
 
         # Call the high-level scheduler with the current context as an argument
         movq    %rsp, %rdi
         # Restore the context to resume the thread.
 __sthread_restore:
 
-        # TODO
+        # returned context is new stack
+        movq %rax, %rsp
+
+        popf 
+
+        popq   %r15
+        popq   %r14
+        popq   %r13
+        popq   %r12
+        popq   %r11
+        popq   %r10
+        popq   %r9
+        popq   %r8
+
+        popq   %rbp
+        popq   %rdi
+        popq   %rsi
+        popq   %rdx
+        popq   %rcx
+        popq   %rbx
+        popq   %rax
 
         ret
 
         .globl __sthread_initialize_context
 __sthread_initialize_context:
 
-        # TODO
-
-        # TODO - Make sure you completely document every part of your
-        #        thread context; what it is, and why you set each value
-        #        to what you choose.
+        # %rdi - stackp, %rsi - f, %rdx - arg
+        # return value in %rax is the stack pointer,
+        # leave 144 bytes for thread context details and return address.
+        movq    %rdi, %rax
+        subq    $144, %rax
+
+        leaq    __sthread_finish(%rip), %rdi      
+        movq    %rdi,  136(%rax)          # kill thread when done with f
+        movq    %rsi,  128(%rax)          # address of f to come back to
+        movq    $0,    120(%rax)          # rax = 0
+        movq    $0,    112(%rax)          # rcx = 0
+        movq    $0,    96(%rax)           # rdx = 0
+        movq    $0,    88(%rax)           # rsi = 0
+        movq    %rdx,  80(%rax)           # rdi = arg
+        movq    $0,    72(%rax)           # rbp = 0
+        movq    $0,    64(%rax)           # r9  = 0
+        movq    $0,    48(%rax)           # r10 = 0
+        movq    $0,    40(%rax)           # r11 = 0
+        movq    $0,    32(%rax)           # r12 = 0
+        movq    $0,    24(%rax)           # r13 = 0
+        movq    $0,    16(%rax)           # r14 = 0
+        movq    $0,    8(%rax)            # r15 = 0
+        movq    $0,    (%rax)             # rflags = 0
 
         ret
 

sthreads/sthread.c

  */
 ThreadContext *__sthread_scheduler(ThreadContext *context) {
 
-    /* TODO:  Replace these lines with your implementation */
-    /* TODO */ assert(0); /* TODO */
+    if (context != NULL) {
+        /* Save the context argument into the current thread. */
+        current->context = context;
+        /* Either queue up or deallocate the current thread, based on its state. */
+        switch(current->state) {
+            case ThreadRunning:
+                current->state = ThreadReady; //change to ready and enqueue
+                enqueue_thread(current);
+                break;
+            case ThreadBlocked:
+                enqueue_thread(current); // enqueue to blocked queue
+                break;
+            case ThreadFinished:
+                __sthread_delete(current); // delete thread
+                break;
+            default:
+                fprintf(stderr, "Thread state has been corrupted: %d\n",
+                    current->state);
+                exit(1);
+        }
+    }
+
+    Thread *next = queue_take(&ready_queue); // get next ready thread
+    // if next exists set current to next and set it to running
+    if (next != NULL) { 
+        current = next;
+        current->state = ThreadRunning;
+    } else {
+        // otherwise if no blocked threads done, if blocked threads deadlock
+        if (queue_empty(&blocked_queue)) {
+            printf("All threads completed successfully\n");
+            exit(0);
+        } else {
+            fprintf(stderr, "System deadlock\n");
+            exit(1);
+        }
+    }
 
     /* Return the next thread to resume executing. */
     return current->context;
  * structure, and it adds the thread to the Ready queue.
  */
 Thread * sthread_create(void (*f)(void *arg), void *arg) {
-    /* TODO:  Replace this function's body with your implementation */
-    /* TODO */ assert(0); /* TODO */
-    return NULL;
+    // allocate stack space for thread
+    void *memory = (void *) malloc(DEFAULT_STACKSIZE);
+    if (memory == NULL) {
+        fprintf(stderr, "No memory to allocate thread stack\n");
+        exit(1);
+    }
+
+    // allocate thread struct
+    Thread *threadp = (Thread *) malloc(sizeof(Thread));
+    if (threadp == NULL) {
+        fprintf(stderr, "No memory to allocate thread struct\n");
+        free(memory); // no leaks
+        exit(1);
+    }
+
+    // set state and memory
+    threadp->state = ThreadReady;
+    threadp->memory = memory;
+
+    // stack pointer at start of region allocated for stack
+    void *stackp = (void *) ((char *) memory + DEFAULT_STACKSIZE);
+    threadp->context = __sthread_initialize_context(stackp, f, arg);
+    // enqueue to ready queue
+    enqueue_thread(threadp);
+    
+    return threadp;
 }
 
 
  * context, as well as the memory for the Thread struct.
  */
 void __sthread_delete(Thread *threadp) {
-    /* TODO:  Replace this function's body with your implementation */
-    /* TODO */ assert(0); /* TODO */
+    // free memory for context
+    free(threadp->memory);
+    // free thread struct 
+    free(threadp);
 }
 
 

sthreads/test_arg.c

+#include <stdio.h>
+#include <stdint.h>
+#include "sthread.h"
+
+/* thread prints int arg */
+static void test(void *arg) {
+	printf("%zd\n", (intptr_t) arg);
+}
+
+int main(int argc, char **argv) {
+    sthread_create(test, (void *) 3);
+    sthread_start();
+    return 0;
+}
\ No newline at end of file

sthreads/test_ret.c

+#include <stdio.h>
+#include <stdint.h>
+#include "sthread.h"
+
+/* print HELLO! arg times yield thread each time */
+static void loop(void *arg) {
+	int i;
+	for (i = 0; i < (intptr_t) arg; i++) {
+		printf("HELLO!\n");
+		sthread_yield();
+	}
+}
+
+int main(int argc, char **argv) {
+	/* threads with different lifetimes */
+	sthread_create(loop, (void *) 1);
+	sthread_create(loop, (void *) 2);
+	sthread_create(loop, (void *) 3);
+	sthread_create(loop, (void *) 4);
+	sthread_start();
+    return 0;
+}
\ No newline at end of file