1. CS414 Minithreads Project 1 Overview Adrian Bozdog (Adi) adrianb@cs.cornell.edu

2. CS414 Minithreads overview2 What you have to do  Implement Minithreads, a user-level threads package on Windows NT  Queues  Non-preemptive threads & FCFS scheduler  Semaphores  A simple application  The machine-specific parts (context switching, stack initialisation) are done for you  Optional for the adventurous: add preemption

3. CS414 Minithreads overview3 What we’ll cover  Structure of the OS and functions  How context switching works  How yielding between threads works  Minithread implementation hints

4. CS414 Minithreads overview4 Minithreads structure machineprimitives_x86.c machineprimitives.h machineprimitives.c minithread.h minithread.c synch.h synch.c queue.h queue.c interrupts.h interrupts.c

5. CS414 Minithreads overview5 Minithreads, step-by-step  Implement queues  Define struct minithread  Implement minithreads operations  fork and yield  system initialisation  termination and cleanup  start, stop  Implement semaphores (see Wednesday lecture)

6. CS414 Minithreads overview6 Queue alternatives  Implement by using enclosing structs (wrappers):  Or implement by using pointers in element types: head tail head tail

7. CS414 Minithreads overview7 Defining a minithread  What’s in a struct minithread (thread control block - TCB)?  stack top pointer  stack base pointer  numerical identifier ( int )  thread status  anything else you think necessary

8. CS414 Minithreads overview8 Minithread operations minithread_t minithread_fork(proc, arg) create thread and make it runnable minithread_t minithread_create(proc, arg) create a thread but don’t make it runnable void minithread_yield() stop this thread and run a new one from the run queue (make the scheduling decisions here) void minithread_start(minithread_t t) void minithread_stop() start another thread, stop yourself

9. CS414 Minithreads overview9 Threads and their stacks  NT gives you an initial stack  Subsequent minithread stacks are allocated on the process’s heap using minithread_allocate _stack() 0 2000 code stack heap 50000

10. CS414 Minithreads overview10 Context switching  minithread_switch(old_thread_ sp_ptr, new_thread_sp_ptr) is provided  Swap execution contexts with a thread from the run queue  registers  program counter  stack pointer

11. CS414 Minithreads overview11 Context switching old_thread_sp_ptrnew_thread_sp_ptr ESP ? new thread’s registers old thread TCBnew thread TCB

12. CS414 Minithreads overview12 Push on old context old_thread_sp_ptrnew_thread_sp_ptr ESP ? old thread’s registers new thread’s registers old thread TCBnew thread TCB

13. CS414 Minithreads overview13 Change stack pointers old_thread_sp_ptrnew_thread_sp_ptr ESP old thread’s registers new thread’s registers old thread TCBnew thread TCB

14. CS414 Minithreads overview14 Pop off new context old_thread_sp_ptrnew_thread_sp_ptr ESP old thread’s registers old thread TCBnew thread TCB

15. CS414 Minithreads overview15 Thread yield  Use minithread_switch to implement minithread_yield  What does a yield do?  Where does a yielding thread return to when it’s rescheduled?

16. CS414 Minithreads overview16 Thread yield ESP void thread1_proc() { printf("Running thread 1\n"); minithread_yield(); 0x40164 printf("Running thread 1 more\n");... } thread 1thread 2 STOPPEDRUNNING 0x85522 registers

17. CS414 Minithreads overview17 Push return address and call yield ESP thread 1thread 2 STOPPEDRUNNING 0x85522 registers 0x40164 void thread1_proc() { printf("Running thread 1\n"); minithread_yield(); 0x40164 printf("Running thread 1\n");... }

18. CS414 Minithreads overview18 Switch to new thread ESP void thread2_proc() { int x; for (;;) { minithread_yield(); 0x85522 printf("x is now %d.\n", x++); } thread 1thread 2 STOPPEDRUNNING 0x85522 registers 0x40164

19. CS414 Minithreads overview19 Return from yield into new context ESP thread 1thread 2 STOPPEDRUNNING registers 0x40164 void thread2_proc() { int x; for (;;) { minithread_yield(); 0x85522 printf("x is now %d.\n", x++); }

20. CS414 Minithreads overview20 Implementation details  How do we create a thread ?  Where do the stacks come from?  How do we initialise the system?

21. CS414 Minithreads overview21 Minithread creation  Two methods to choose from minithread_create(proc, arg) minithread_fork(proc, arg)  proc is a proc_t  typedef int (*proc_t)(arg_t)  e.g. int run_this_proc(int* x)  could cast any pointer to (int *)

22. CS414 Minithreads overview22 Minithread creation  Allocate a struct minithread (TCB)  Allocate and initialise a new stack minithread_allocate_stack(stackbase, stacktop) minithread_initialize_stack(stacktop, body_proc, body_arg, final_proc, final_arg)  Set the initial thread status  Whatever else is appropriate

23. CS414 Minithreads overview23 An initialized stack root_proc addr final_arg final_proc addr body_arg body_proc addr stack_top stack_base Stack must look as though minithread_switch has been called

24. CS414 Minithreads overview24 How a new thread starts  root_proc is popped off the stack after “return” from minithread_switch  It runs body_proc(body_arg) final_proc(final_arg)  Executes the user-provided function and allows thread cleanup  root_proc should not return

25. CS414 Minithreads overview25 When your program starts  NT has kernel threads  When your program starts:  one kernel thread of control  NT-provided execution stack 0 2000 50000 code stack heap

26. CS414 Minithreads overview26 Code example int proc(int* arg) { printf("Hello, world!\n"); return 0; } main() { minithread_system_initialize(proc, NULL); }

27. CS414 Minithreads overview27 Initializing the system  minithreads_system_initialize (proc_t mainproc,arg_t mainarg)  Starts up the system  First user thread runs mainproc(mainarg)  Should the initial minithread be the same as the kernel thread?

28. CS414 Minithreads overview28 Initializing the system  If main() returns, it will terminate the entire process!  Make minithread_system_init() not return  It should create the first user thread, which runs mainproc(mainarg)  Your kernel thread needn’t terminate

29. CS414 Minithreads overview29 Cleaning up threads  A minithread terminates when it reaches the end of its body_proc  A good solution will clean up its stack: minithread_free_stack(stackbase)  But a thread can’t destroy its stack itself: minithread_switch won’t work!

30. CS414 Minithreads overview30 Minithread destruction  A terminating thread T  runs its final_proc  “notifies the system that it wants to finish”  relinquishes the processor  Some other thread (cleaning thread)  sees T needs to be cleaned up  frees T ’s stack, etc

31. CS414 Minithreads overview31 A word of warning  Prevent memory leaks  The NT kernel thread has a stack  You must make a minithread out of it  But you can’t free the NT stack!  The threads package must not run out of memory  Write a clean and understandable code  Variables should have proper names  Provide meaningful but not excessive comments  Do not terminate when all threads are done  New zip file available for Visual Studio.NET !!  Due Date : Monday, February 10, 12 pm.

32. CS414 Minithreads overview32 Summary  Implement queues  Fork, initialisation, yield for 1 thread  Yielding between multiple threads  Thread cleanup  Implement semaphores  Implement “food services” problem