The first step is to read and understand the code for the thread system. Pintos already implements thread creation and thread completion, a simple scheduler to switch between threads, and synchronization primitives (semaphores, locks, condition variables, and optimization barriers).
Some of this code might seem slightly mysterious. You can read through parts of the source code to see what’s going on. If you like, you can add calls to
printf() almost anywhere, then recompile and run to see what happens and in what order. You can also run the kernel in a debugger and set breakpoints at interesting spots, step through code and examine data, and so on.
When a thread is created, the creator specifies a function for the thread to run, as one of the arguments to
thread_create(). The first time the thread is scheduled and runs, it starts executing from the beginning of that function. When the function returns, the thread terminates. Each thread, therefore, acts like a mini-program running inside Pintos, with the function passed to
thread_create() acting like
At any given time, exactly one thread runs and the rest become inactive. The scheduler decides which thread to run next. (If no thread is ready to run, then the special “idle” thread runs.) The mechanics of a context switch are in
threads/switch.S, which is x86 assembly code. It saves the state of the currently running thread and restores the state of the next thread onto the CPU.
Using GDB, try tracing through a context switch to see what happens. You can set a breakpoint on
schedule() to start out, and then single-step from there (use “step” instead of “next”). Be sure to keep track of each thread’s address and state, and what procedures are on the call stack for each thread (try “backtrace”). You will notice that when one thread calls
switch_threads(), another thread starts running, and the first thing the new thread does is to return from
switch_threads(). You will understand the thread system once you understand why and how the
switch_threads() that gets called is different from the
switch_threads() that returns.