Skip to content

GitLab

An error occurred while fetching the assigned milestone of the selected merge_request.
Merged
Created by Adam Blank@blankOwner

Revert "Merge branch 'submit' into 'master'"

Compare
and
9 files
+ 18
- 187
sthr‎eads‎
Make‎file‎ +2 -7
glu‎e.s‎ +7 -62
sthr‎ead.c‎ +7 -67
test_‎arg.c‎ +0 -14
test_‎ret.c‎ +0 -22
sysc‎alls‎
Make‎file‎ +0 -3
gree‎ting‎ +0 -0
greet‎ing.c‎ +2 -1
outp‎ut.s‎ +0 -11
sthreads/Makefile
+ 2
- 7
Show all unchanged lines Show 20 lines
ASFLAGS = -g
all: test test_arg test_ret
all: test
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
Show 20 lines Show all unchanged lines Show 20 lines
# pseudo-target to clean up
clean:
$(RM) -f *.o core* *~ test test_arg test_ret
$(RM) -f *.o core* *~ test
.PHONY: all clean
Show 20 lines Show all unchanged lines
sthreads/glue.s
+ 7
- 62
Show all unchanged lines Show 20 lines
__sthread_switch:
# Save the process state onto its stack
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
# TODO
# Call the high-level scheduler with the current context as an argument
movq %rsp, %rdi
Show 20 lines Show all unchanged lines Show 20 lines
# Restore the context to resume the thread.
__sthread_restore:
# 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
# TODO
ret
Show 20 lines Show all unchanged lines Show 20 lines
.globl __sthread_initialize_context
__sthread_initialize_context:
# %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
# 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.
ret
Show 20 lines Show all unchanged lines
sthreads/sthread.c
+ 7
- 67
Show all unchanged lines Show 20 lines
*/
ThreadContext *__sthread_scheduler(ThreadContext *context) {
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);
}
}
/* TODO: Replace these lines with your implementation */
/* TODO */ assert(0); /* TODO */
/* Return the next thread to resume executing. */
return current->context;
Show 20 lines Show all unchanged lines Show 20 lines
* structure, and it adds the thread to the Ready queue.
*/
Thread * sthread_create(void (*f)(void *arg), void *arg) {
// 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;
/* TODO: Replace this function's body with your implementation */
/* TODO */ assert(0); /* TODO */
return NULL;
}
Show 20 lines Show all unchanged lines Show 20 lines
* context, as well as the memory for the Thread struct.
*/
void __sthread_delete(Thread *threadp) {
// free memory for context
free(threadp->memory);
// free thread struct
free(threadp);
/* TODO: Replace this function's body with your implementation */
/* TODO */ assert(0); /* TODO */
}
Show 20 lines Show all unchanged lines
sthreads/test_arg.c deleted 100644 → 0
+ 0
- 14
#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 deleted 100644 → 0
+ 0
- 22
#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