X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fthreads%2Fthread.h;h=7965c0607815eab3275da7babdf669177f18c8e2;hb=3edcfedb8e62970f3293fa676b6691f8658c3c11;hp=e8927def25ebc99594a541425096ddc6eff8c4e4;hpb=349cc721b17effa62c8b18a7dccc5defc44472d3;p=pintos-anon diff --git a/src/threads/thread.h b/src/threads/thread.h index e8927de..7965c06 100644 --- a/src/threads/thread.h +++ b/src/threads/thread.h @@ -1,54 +1,141 @@ -#ifndef HEADER_THREAD_H -#define HEADER_THREAD_H 1 +#ifndef THREADS_THREAD_H +#define THREADS_THREAD_H +#include +#include #include -#include "debug.h" -#include "list.h" -#ifdef USERPROG -#include "addrspace.h" -#endif - -enum thread_status +/* States in a thread's life cycle. */ +enum thread_status { - THREAD_RUNNING, - THREAD_READY, - THREAD_BLOCKED, - THREAD_DYING + THREAD_RUNNING, /* Running thread. */ + THREAD_READY, /* Not running but ready to run. */ + THREAD_BLOCKED, /* Waiting for an event to trigger. */ + THREAD_DYING /* About to be destroyed. */ }; -struct thread +/* Thread identifier type. + You can redefine this to whatever type you like. */ +typedef int tid_t; +#define TID_ERROR ((tid_t) -1) /* Error value for tid_t. */ + +/* Thread priorities. */ +#define PRI_MIN 0 /* Lowest priority. */ +#define PRI_DEFAULT 31 /* Default priority. */ +#define PRI_MAX 63 /* Highest priority. */ + +/* A kernel thread or user process. + + Each thread structure is stored in its own 4 kB page. The + thread structure itself sits at the very bottom of the page + (at offset 0). The rest of the page is reserved for the + thread's kernel stack, which grows downward from the top of + the page (at offset 4 kB). Here's an illustration: + + 4 kB +---------------------------------+ + | kernel stack | + | | | + | | | + | V | + | grows downward | + | | + | | + | | + | | + | | + | | + | | + | | + +---------------------------------+ + | magic | + | : | + | : | + | name | + | status | + 0 kB +---------------------------------+ + + The upshot of this is twofold: + + 1. First, `struct thread' must not be allowed to grow too + big. If it does, then there will not be enough room for + the kernel stack. Our base `struct thread' is only a + few bytes in size. It probably should stay well under 1 + kB. + + 2. Second, kernel stacks must not be allowed to grow too + large. If a stack overflows, it will corrupt the thread + state. Thus, kernel functions should not allocate large + structures or arrays as non-static local variables. Use + dynamic allocation with malloc() or palloc_get_page() + instead. + + The first symptom of either of these problems will probably be + an assertion failure in thread_current(), which checks that + the `magic' member of the running thread's `struct thread' is + set to THREAD_MAGIC. Stack overflow will normally change this + value, triggering the assertion. */ +/* The `elem' member has a dual purpose. It can be an element in + the run queue (thread.c), or it can be an element in a + semaphore wait list (synch.c). It can be used these two ways + only because they are mutually exclusive: only a thread in the + ready state is on the run queue, whereas only a thread in the + blocked state is on a semaphore wait list. */ +struct thread { - /* These members are owned by the thread_*() functions. */ + /* Owned by thread.c. */ + tid_t tid; /* Thread identifier. */ enum thread_status status; /* Thread state. */ char name[16]; /* Name (for debugging purposes). */ uint8_t *stack; /* Saved stack pointer. */ - list_elem rq_elem; /* Run queue list element. */ + int priority; /* Priority. */ + struct list_elem allelem; /* List element for all threads list. */ + + /* Shared between thread.c and synch.c. */ + struct list_elem elem; /* List element. */ #ifdef USERPROG - /* These members are owned by the addrspace_*() functions. */ + /* Owned by userprog/process.c. */ uint32_t *pagedir; /* Page directory. */ #endif - - /* Marker to detect stack overflow. */ - unsigned magic; /* Always set to THREAD_MAGIC. */ + + /* Owned by thread.c. */ + unsigned magic; /* Detects stack overflow. */ }; +/* If false (default), use round-robin scheduler. + If true, use multi-level feedback queue scheduler. + Controlled by kernel command-line option "-o mlfqs". */ +extern bool thread_mlfqs; + void thread_init (void); void thread_start (void); +void thread_tick (void); +void thread_print_stats (void); + typedef void thread_func (void *aux); -struct thread *thread_create (const char *name, thread_func *, void *); -#ifdef USERPROG -bool thread_execute (const char *filename); -#endif +tid_t thread_create (const char *name, int priority, thread_func *, void *); +void thread_block (void); void thread_unblock (struct thread *); -const char *thread_name (struct thread *); struct thread *thread_current (void); +tid_t thread_tid (void); +const char *thread_name (void); + void thread_exit (void) NO_RETURN; void thread_yield (void); -void thread_block (void); -#endif /* thread.h */ +/* Performs some operation on thread t, given auxiliary data AUX. */ +typedef void thread_action_func (struct thread *t, void *aux); +void thread_foreach (thread_action_func *, void *); + +int thread_get_priority (void); +void thread_set_priority (int); + +int thread_get_nice (void); +void thread_set_nice (int); +int thread_get_recent_cpu (void); +int thread_get_load_avg (void); + +#endif /* threads/thread.h */