1. Nachos Project 2 Lecturer: Hao-Hua Chu TA: Chun-Po Wang (Artoo) Date: 2008/10/14 Material Provided by Yuan-Hao Chang, Yung-Feng Lu

2. 2 Project 2 Implement Thread Scheduling –Default is FCFS –Priority scheduling + Round Robin

3. 3 Summary Motivation & Objective Nachos –Thread –Scheduler –Timesharing (Round-robin) Requirement Submission

4. 4 Motivation & Objective Modern operating systems should have the ability to schedule multiple threads. –Low waiting time, or –Low turnaround time, or –Avoid starvation

5. 5 Motivation & Objective (cont.) Be familiar with Nachos –Understand the inner structure –You’ll need to trace in this project Implement priority scheduling algorithms, combine it with built-in timer to achieve timesharing (Round-Robin)

6. 6 Nachos Threads Ready queue –A List object: a list of ready thread objects Thread state –READY The thread will be kept in readyList. –RUNNING The global variable currentThread always points the currently running thread. –BLOCKED The thread is blocked to wait for some event until the event takes place. A blocked thread is not in readyList. Instead, it would be put in other queues. –JUST_CREATED The thread is just created, but not ready to be put in readyList (not ready to run).

7. 7 Thread Life Cycle Thread::Thread() JUST_CREATED Thread::Fork() READY (use a readyList) RUNNING Call Scheduler:: Run() BLOCKED Call Scheduler:: ReadyToRun() Call Thread::Yield() Call Thread::Sleep() (Put thread to waiting queue) Event occurs, call Scheduler::ReadyToRun() (Move thread back to the ready queue) Note: Thread::Yield() invoks Scheduler::FindNextToRun() to select next thread to run.

8. 8 Thread Object Thread() –Constructor: sets the thread as JUST_CREATED status Fork() –Allocate stack, initialize registers. –Call Scheduler::ReadyToRun() to put the thread into readyList, and set its status as READY. Yield() –Suspend the calling thread and put it into readyList. –Call Scheduler::FindNextToRun() to select another thread from readyList. –Execute selected thread by Scheduler::Run(), which sets its status as RUNNING and call SWITCH() (in code/threads/switch.s) to exchange the running thread. Sleep() –Suspend the current thread and find other thread to run –Change its state to BLOCKED.

9. 9 Thread Object (Cont.) Thread *Thread(char *debugName) –The Thread constructor Setting status to JUST_CREATED, Initializing stack to NULL, and Given the thread name for debugging.

10. 10 Thread Object (Cont.) Fork(VoidFunctionPtr func, int arg) –Thread creation Allocating stack by invoking StackAllocate() function Put this thread into ready queue by calling Scheduler::ReadytoRun() –Argument func The address of a procedure where execution is to begin when the thread starts executing (The thread’s handler function) –Argument arg An argument that would be passed to thread handler function

11. 11 Thread Object (Cont.) void Yield() –Suspend the calling thread and select a new one for execution Find next ready thread by calling Scheduler::FindNextToRun(). Put current thread into ready list (waiting for rescheduling). Execute the next ready thread by invoking Scheduler::Run(). –If no other threads are ready to execute, continue running the current thread.

12. 12 Thread Object (Cont.) void Sleep (bool finishing) –Suspend the current thread and change its state to BLOCKED Run next ready thread Invoke interrupt->Idle() to wait for the next interrupt when readyList is empty –Sleep is called when the current thread needs to be blocked until some future event takes place. Eg. Waiting for a disk read interrupt It is called by Semaphore::P() in code/threads/synch.cc. Semaphore::V() will wake up one of the thread in the waiting queue (sleeping threads queue).

13. 13 Thread Object (Cont..…) void Finish() –Terminate the currently running thread. Call Sleep() and never wake up De-allocate the data structures of a terminated thread The newly scheduled thread examines the toBeDestroyed variable and finish this thread.

14. 14 Example: create thread void SelfTest() –Test whether thread implementation works. –Fork a new thread and yield current one to execute it static void SimpleThread(int which) –A procedure where execution is to begin when the thread starts executing Command line: nachos -K In this project, you can trace the above two functions as the starting point.

15. 15 The Flow to Invoke SelfTest() In main.cc –if (strcmp(argv[i], "-K") == 0) threadTestFlag = TRUE; –if (threadTestFlag) kernel->ThreadSelfTest(); // test threads and synchronization In Kernel::ThreadSelfTest() currentThread->SelfTest(); // test thread switching –In Thread::SelfTest() Thread *t = new Thread("forked thread"); t->Fork((VoidFunctionPtr) SimpleThread, (void *) 1); kernel->currentThread->Yield(); SimpleThread(0); >./nachos -K kernel->ThreadSelfTest() Thread::SelfTest() Fork(SimpleThread,1)

16. 16 Nachos Scheduler In code/threads/scheduler.cc, shceduler.h Decides which thread to run next. Invoked whenever current thread wishes to give up the CPU. (Eg. Call Yield()) Default scheduling policy: A FCFS readyList with round-robin fashion –RR is supported by Timer object, which generate interrupt every 100 ticks

17. 17 Nachos Scheduler ReadyToRun() –Change a thread’s status to READY and put it into the readyList. FindNextToRun() –Fetch the thread at the front of the readyList. Run() –Change the state of a thread to RUNNING. –Invoke SWITCH() to switch from the current thread to the selected thread. –If we switch threads because current thread called Thread::Finish(), terminate it. (indicated by the variable toBeDestroyed)

18. 18 Scheduler Object (Cont.) Scheduler *Scheduler() –The scheduler constructor Initialize the readyList, which is a List Object. Set thread status as JUST_CREATED.

19. 19 Scheduler Object (Cont.) void ReadyToRun(Thread *thread) –Make a thread as ready Set thread status as READY. Place it on the ready list. Invoked by Thread::Fork(), or Semaphore::V(). Note that ReadyToRun() doesn't actually start running the thread.

20. 20 Scheduler Object (Cont.) Thread *FindNextToRun() –Select a ready thread and return it Remove and return the thread at the front of the ready list

21. 21 Scheduler Object (Cont.) void Run(Thread *nextThread) –Suspend the current thread and switch to the new one. Set it as “toBeDestroyed” if it is a finished thread. Save the state of the old thread. Switch to the next thread by invoking SWITCH and set it as running. –SWITCH is defined in code/threads/switch.s CheckToBeDestroyed() -- check if the previous thread need to be clean up.

22. 22 Timesharing in Nachos Alarm object –code/threads/alarm.cc and alarm.h –Nachos create a Timer object which interrupts every “TimerTicks” ticks code/machine/timer.cc and timer.h When Timer interrupts, nachos calls its interrupt handler Timer::CallBack(), which resets the timer and call Alarm::CallBack() –Alarm::CallBack() Call interrupt->YieldOnReturn(), which would yield current thread in Interrupt::OneTick() after all interrupts are handled –“TimerTicks” is defined in code/machine/stats.h, default is 100

23. 23 Timesharing in Nachos (Cont.) Nachos initialize a Alarm object in Kernel::Initialize() Alarm generates interrupts every 100 ticks (default) Nachos yields current thread in Alarm interrupt handler In effect, no thread could run longer than 100 ticks (unless there is no other threads)

24. 24 Implementation We have 3 tasks: –Extend Nachos to read our schedule file and create threads –Implement a priority scheduling to replace default FCFS –Round-Robin mechanism is already built by Alarm object, but we can change its time slice The function names with bold font should be implemented by you

25. 25 Read schedule file Make Nachos support “-S” parameter. –E.g., >./nachos -S ParameterFile.txt –When executing Nachos with “-S” parameter, invoke our scheduler testing function: kernel->currentThread-> schedulingTest(param_file_name)

26. 26 Read schedule file (cont.) We do actual works in a new function in class Thread (Modify code/threads/thread.cc and thread.h) void Thread::SchedulingTest(char *ParameterFile) { … Thread *t; for(i=0;i<NumberOfThreadsDefinedInParemeterFile;i++) { t = new Thread(ThreadName[i]); t->setPriority(ThreadPriority[i]); t->Fork((voidFunctionPtr) threadBody, (void *) RemainingExecutionTicks[i]); } kernel->currentThread->Yield(); // Give up CPU in order to run new threads }

27. 27 Read schedule file (cont.) Sample schedule file: 4 A 2 7 B 1 3 C 3 5 D 2 4 –4 threads: A,B,C,D –Thread name, priority, remaining ticks –Priority = 1~10, 1 is the highest priority –Thread name is 10 characters (including NULL) or less, NOTE THAT you should provide a newly allocated space for name strings to Thread constructor because it only stores pointer. DON’T give it local variables.

28. 28 Read schedule file (cont.) Implement thread body: –We run a while loop, which loops tick_to_exec times. This parameter is supplied by Fork(…, (void*) RemainingExecutionTicks[i]) –Call kernel->interrupt->OneTick() to increase system execution ticks –Print thread info, including its name and remaining ticks void threadBody (int tick_to_exec) { while(tick_to_exec > 0) { tick_to_exec--; kernel->interrupt->OneTick(); printf("%s: remaining = %d\n", kernel->currentThread->getName(), tick_to_exec); }

29. 29 Priority scheduling Add required member variables and methods to Thread class (code/threads/thread.cc and thread.h) –void Thread::setPriority(int p) Set new priority p to this thread –int Thread::getPriority() Retrieve current priority –int priority A thread’s priority (private variable) Modify constructor to give default priority to new threads –Thread::Thread() In this project, we set default priority to 10 in order to avoid these threads’ effects when doing our scheduling

30. 30 Priority scheduling (cont.) Modify Scheduler class –code/threads/scheduler.cc and scheduler.h –How to do? Please figure it out yourself –You may need to use SortedList class –If two threads have the same priority, the first thread in the schedule file runs first (FCFS)

31. 31 SortedList SortedList inherits List class, except that it can insert an “item” into a list in increasing/decreasing order. When creating a new SortedList object, we have to register a “compare” function, which decides which element is bigger. SortedList ::Insert(T item) –Insert an “item” into a list by invoking the registered “compare” function to decide the place to put the “item” in the list. This is a template class, which can be used on different data types –Eg. SortedList is a SortedList class which stores pointers to Thread objects –The SortedList uses the “compare” function you implemented to determine which Thread object is “bigger”, or have higher priority

32. 32 Round-Robin Alarm class generates interrupts every TimerTicks ticks (default = 100) TimerTicks is defined in code/machine/stats.h You can change it, and watch the differences

33. 33 Sample scheduling result Time slice = 100 ticks Schedule file: 4 A 2 7 B 1 3 C 3 5 D 2 4 Why thread D run before A? –Timer interrupts B: remaining = 2 B: remaining = 1 B: remaining = 0 D: remaining = 3 D: remaining = 2 D: remaining = 1 D: remaining = 0 A: remaining = 6 A: remaining = 5 A: remaining = 4 C: remaining = 4 C: remaining = 3 C: remaining = 2 C: remaining = 1 C: remaining = 0 A: remaining = 3 A: remaining = 2 A: remaining = 1 A: remaining = 0 Machine halting!

34. 34 Requirement Implement priority scheduling Write a 2-page report –Don’t just paste your code, I’ll read it myself –Change time slice to 50 ticks, run nachos on test schedule we supply and explain the results –You may need to use “-d +” to trace the execution If your project submission can’t compile and execute on Linux in Workstation Room 217, we will consider it as fail. –Please contact me to apply a workstation account if you need it.

35. 35 Test files We supply a test schedule file “testThreads.txt” on our webpage –Your implementation should have the same results as the sample scheduling when time slice = 100 –We will use other schedules to test, so don’t cheat

36. 36 Submission Two people in one group (Write down the name and student ID of all members in the report) The file you need to send: 1.A report in.pdf or.doc 2.threads.cc, threads.h, scheduler.cc and scheduler.h Send your files –Tar your files to an archieve named: os_hw2_bXXXXXXXX_bOOOOOOOO.tar.gz –E-mail to artoo@csie.ntu.edu.tw with following title: [os_hw2] bXXXXXXXX_bOOOOOOOOartoo@csie.ntu.edu.tw –Please follow the format carefully or our auto- reply system will not work tar zcvf os_hw2_bXXXXXXXX_bOOOOOOOO.tar.gz report.doc exception.cc

37. 37 Submission (cont.) Deadline: 10/27 24:00 –For the delayed submission, deduct 5 points for each day DO NOT COPY!! Protect your code well!!