CS170 Operating Systems. Discussion Section Week 4 Project 2 - Thread

Transcription

1 CS170 Operating Systems Discussion Section Week 4 Project 2 - Thread

2 Project-1 feedback

3 How to compile 1. create threads.h and threads.c 2. include "threads.h" in your test.c file 3. gcc -c -o threads.o threads.c 4. gcc test.c threads.o 5../a.out 6. implement step3 in your makefile.

4 Implementation Steps 1. include <pthread.h> 2. define TCB (thread control block) 3. write function pthread_create 4. schedule threads 5. write function pthread_exit 6. write function pthread_self 7. test

5 #include <pthread.h> Reason: To access pthread_t or pthread_attr_t int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

6 Implementation Steps 1. include <pthread.h> 2. define TCB (thread control block) 3. write function pthread_create 4. schedule threads 5. write function pthread_exit 6. write function pthread_self 7. test

7 TCB (thread control block) struct _thread{... }; What all do you need in your TCB?

8 TCB (thread control block) struct _thread{... }; 1. Thread id 2. Current state of thread => {Runnable,Exited} 3. Save the state of thread in jmp_buf 4. Stack space Also, keep track of currently running thread outside TCB.

9 Implementation Steps 1. include <pthread.h> 2. define TCB (thread control block) 3. write function pthread_create 4. schedule threads 5. write function pthread_exit 6. write function pthread_self 7. test

10 pthread_create function int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg); func pthread_create(){ 1. if first time called, initialize a scheduler thread; 2. initialize a thread for current Task Function; 3. insert this new thread into runnable queue; }

11 Initialize a scheduler thread When pthread_create is called first time: 1. create a scheduler thread; Does not require stack space or need to save state. 2. you need a queue that holds all runnable threads; 3. add thread 1 into the array/list; 4. set up a timer 5. Calls scheduler and exits from main

12 How to set up a timer (Use sigaction) func timer(){ struct sigaction sigact; sigemptyset( &sigact.sa_mask ); sigact.sa_flags = SA_NODEFER; sigact.sa_handler = handle_clock_tick; sigaction(sigalrm, &sigact, NULL); } if (ualarm(cs_timer, CS_TIMER) < 0) perror("timer");

13 pthread_create function func pthread_create(){ 1. if no thread, initialize a scheduler thread; 2. initialize a thread for current Task Function; 3. insert this new thread into runnable queue; }

14 Initializing new thread Give it a thread_id Set its state to Runnable Create a stack space using malloc Manipulate jmp_buf associated with thread to save state

15 Set up stack and SP n->stack = (void *) malloc(stack_size); esp = n->stack + STACK_SIZE ; /* set esp to top of stack */ esp[ 0] = (unsigned int) arg; esp[-1] = (unsigned int) &pthread_exit_implicit; esp -= 1;

16 Initializing new thread Give it a thread_id Set its state to Runnable Create a stack space using malloc Manipulate jmp_buf associated with thread to save state

17 Manipulating jmp_buf to save state libc defines the following constants as the six integer elements of this structure: #define JB_BX 0 #define JB_SI 1 #define JB_DI 2 #define JB_BP 3 #define JB_SP 4 #define JB_PC 5 We can see that the stack pointer has index 4 and the program counter has index 5 into the jmp_buf. This allows us to easily write the new values for ESP and EIP into a jmp_buf.

18 Manipulating jmp_buf to save state Unfortunately, we need to encrypt the new values before insert them into jmpbuf static int ptr_mangle(int p) { unsigned int ret; asm(" movl %1, %%eax;\n" " xorl %%gs:0x18, %%eax;" " roll $0x9, %%eax;" " movl %%eax, %0;" : "=r"(ret) : "r"(p) : "%eax" ); return ret; }

19 Manipulating jmp_buf to save state While saving state, *(((unsigned int *) &mythread->env)+jb_sp) = ptr_mangle((unsigned int)esp) *(((unsigned int *) &mythread->env)+jb_pc) = ptr_mangle((unsigned int) start_routine)

20 pthread_create function func pthread_create(){ 1. if no thread, initialize a scheduler thread; 2. initialize a thread for current Task Function; 3. insert this new thread into runnable queue; } You can maintain a queue of runnable threads for scheduling

21 Implementation Steps 1. include <pthread.h> 2. define TCB (thread control block) 3. write function pthread_create 4. schedule threads 5. write function pthread_exit 6. write function pthread_self 7. test

22 What is setjmp and longjmp (Wiki) #include <stdio.h> #include <setjmp.h> static jmp_buf buf; void second(void) { printf("second\n"); // prints longjmp(buf,1); // jumps back to where setjmp was called - making setjmp now return 1 } void first(void) { second(); printf("first\n"); // does not print } int main() { if (! setjmp(buf) ) { first(); // when executed, setjmp returns 0 } else { // when longjmp jumps back, setjmp returns 1 printf("main\n"); // prints } return 0; }

23 handle_clock_tick (scheduling function) if current==null { current = find_next_runnable(); longjmp(current->state, 1); //activate it } else{ if(setjmp(current->state) == 0){ current = find_next_runnable(); } longjmp(current->state, 1); }

24 Implementation Steps 1. include <pthread.h> 2. define TCB (thread control block) 3. write function pthread_create 4. write function pthread_exit 5. write function pthread_self 6. test

25 pthread_exit function { } Change the status to exit; Remove it from runnable queue; Free its space; schedule() ; after step 2

26 Implementation Steps 1. include <pthread.h> 2. define TCB (thread control block) 3. write function pthread_create 4. write function pthread_exit 5. write function pthread_self 6. test

27 phread_self pthread_t pthread_self(void) { return current->id; }

28 Implementation Steps 1. include <pthread.h> 2. define TCB (thread control block) 3. write function pthread_create 4. write function pthread_exit 5. write function pthread_self 6. test

29 Test Create few sample inputs to work with. Start by having a main in your program Will post sample input and output soon.

30 Important consideration Think about set of instructions that needs to be atomic. What happens if a signal occurs in the middle of updating/performing?

31 Important consideration Think about set of instuctions that needs to be atomic. What happens if a signal occurs in the middle of updating/performing? a. When schedule is taking place b. When a new thread is being added c. When a thread is being removed

32 Sigprocmask Used to mask signals by the calling process #include <signal.h> int sigprocmask(int how, const sigset_t *set, sigset_t *oset); how: SIG_BLOCK or SIG_UNBLOCK Example: sigprocmask(sig_block, &sig, NULL);

33 Write lock() and unlock() lock() blocks SIGALRM when important updates are taking place and unlock() unblocks it func lock(){ sigset_t sig; sigemptyset(&sig); sigaddset(&sig, SIGALRM); sigprocmask(sig_block, &sig, NULL); }

34 Happy Threading!!!