1 / 28

CSE451 Section 3: Winter 2k7

CSE451 Section 3: Winter 2k7. Welcome to the world of concurrency! Kurtis Heimerl(kheimerl@cs) Aaron Kimball (ak@cs). Threads & synchronization. A rite of passage All undergrad OS courses do The most fun part Will feel like being a GURU  The craziest part

alvis
Download Presentation

CSE451 Section 3: Winter 2k7

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. CSE451 Section 3:Winter 2k7 Welcome to the world of concurrency! Kurtis Heimerl(kheimerl@cs) Aaron Kimball (ak@cs)

  2. Threads & synchronization • A rite of passage • All undergrad OS courses do • The most fun part • Will feel like being a GURU  • The craziest part • Will be sick of synchronization  • Start early & read thoroughly • Grab a big picture first! • Discuss your design with • Fellow students • TAs

  3. User-level threads: to do • First submission(Feb 2nd 10:00am) • user-level thread manager • common synchronization primitives • simple synchronization problem • Second submission(Feb 14 10:00am) • Preemption • Multithreaded web server to test your thread package • Analyze your design and report test results

  4. Dependency Part 1: Thread manager Part 2: Synchronization primitives Part 4: Preemption Part 3: Synchronization problem Part 6: Report Part 5: Multithreaded web server pthread compatible You can work concurrently! 

  5. Simplethreads code structure test/*.c Web server (web/sioux.c) Other apps include/sthread.h You write this lib/sthread_user.c lib/sthread_user.h lib/sthread_queue.h lib/sthread_ctx.h lib/sthread_preempt.h lib/sthread_queue.c lib/sthread_ctx.c lib/sthread_preempt.c lib/sthread_switch.S sthread_switch_i386.h sthread_switch_powerpc.h From Section 3 – Winter 2006

  6. Sthread: thread interface • void sthread_init(void) • Initialize thread system(or manager) • sthread_t sthread_create(sthread_start_func_t start_routine,void *arg,int joinable) • Spawn a new thread • The new thread runs start_routine with given arg • void sthread_exit(void *ret) • Exit caller thread with ret as exit value • ret is actually return value of start_routine • void sthread_yield(void) • Yield execution of caller thread • void *sthread_join(sthread_t t) • Join thread t which is created as joinable • Return value is the return value of start_routine of t • Refer sthread.h

  7. Synchronization • Problem: Controlling access from threads to limited resources. • Solutions?

  8. Synchronization • Problem: Controlling access from threads to limited resources. • Solutions? • Disable Interrupts (hardware) • Atomic Instructions (hardware) • Semaphores (OS) • Condition Variables (OS) • Monitors (PL) • We will be implementing the OS level primitives with the support of the hardware level primitives.

  9. Disabling/Enabling Interrupts Thread A: disable_interrupts() critical_section() enable_interrupts() Thread B: disable_interrupts() critical_section() enable_interrupts() • Prevents context-switches during execution of CS • Sometimes necessary • E.g. to prevent further interrupts during interrupt handling • Problems?

  10. Hardware support • Atomic instructions: • Test and set • Swap • Compare-exchange (x86) • Load-linked store conditional (MIPS, Alpha, PowerPC) • Use these to implement higher-level primitives • E.g. test-and-set on x86 (given to you for part 5) is written using compare-exchange. • compare_exchange(lock_t *x,int y,int z): if(*x == y) *x = z; return y;else return *x; • test_and_set(lock_t *l) { return compare_exchange(l,0,1); }

  11. Sthread: mutex interface • sthread_mutex_t sthread_mutex_init() • Create a new-unlocked mutex • void sthread_mutex_free(sthread_mutex_t lock) • Release resources held by given mutex • void sthread_mutex_lock(sthread_mutex_t lock) • Returned thread is guaranteed to acquire lock • void sthread_mutex_unlock(sthread_mutex_t lock) • Release lock • Refer sthread.h

  12. Sthread: condition variable • sthread_cond_t sthread_cond_init() • Create a new condition variable • void sthread_cond_free(sthread_cond_t cond) • Release resources held by given condition variable • void sthread_cond_signal(sthread_cond_t cond) • Wake-up one waiting thread if there is any • void sthread_cond_broadcast(sthread_cond_t cond) • Wake-up all waiting threads • void sthread_cond_wait(sthread_cond_t cond, sthread_mutex_t lock) • Wait for given condition variable • Returning thread is guaranteed to hold the lock • Refer sthread.h

  13. Sample multithreaded program int main(int argc, char **argv) { int i; sthread_init(); if (sthread_create(thread_start, (void*)i) == NULL) { printf("sthread_create failed\n"); exit(1); } sthread_yield(); //yield main thread to our new thread printf("back in main\n"); return 0; } void *thread_start(void *arg) { printf("In thread_start, arg = %d\n", (int)arg); return 0; } • Output? (assume no preemption)

  14. Managing contexts (given) • Thread context = thread stack + stack pointer • sthread_new_ctx(func_to_run) • Gives a new thread context that can be switched to • sthread_free_ctx(some_old_ctx) • Deletes the supplied context • sthread_switch(oldctx, newctx) • Puts current context into oldctx • Takes newctx and makes it current

  15. From Section 3 – Winter 2006 How sthread_switch works Thread 1 TCB … SP Thread 2 TCB … SP Xsthread_switch: pusha movl %esp,(%eax) movl %edx,%esp popa ret Thread 2 registers CPU ESP Thread 1 running Thread 2 ready Thread 1 regs Want to switch to thread 2…

  16. From Section 3 – Winter 2006 Push old context Thread 1 TCB … SP Thread 2 TCB … SP Xsthread_switch: pusha movl %esp,(%eax) movl %edx,%esp popa ret Thread 1 registers Thread 2 registers CPU ESP Thread 1 running Thread 2 ready Thread 1 regs

  17. From Section 3 – Winter 2006 Save old stack pointer Thread 1 TCB … SP Thread 2 TCB … SP Xsthread_switch: pusha movl %esp,(%eax) movl %edx,%esp popa ret Thread 1 registers Thread 2 registers CPU ESP Thread 1 running Thread 2 ready Thread 1 regs

  18. From Section 3 – Winter 2006 Change stack pointers Thread 1 TCB … SP Thread 2 TCB … SP Xsthread_switch: pusha movl %esp,(%eax) movl %edx,%esp popa ret Thread 1 registers Thread 2 registers CPU ESP Thread 1 ready Thread 2 running Thread 1 regs

  19. From Section 3 – Winter 2006 Pop off new context Thread 1 TCB … SP Thread 2 TCB … SP Xsthread_switch: pusha movl %esp,(%eax) movl %edx,%esp popa ret Thread 1 registers CPU ESP Thread 1 ready Thread 2 running Thread 2 regs

  20. From Section 3 – Winter 2006 Done; return Thread 1 TCB … SP Thread 2 TCB … SP Xsthread_switch: pusha movl %esp,(%eax) movl %edx,%esp popa ret Thread 1 registers • What got switched? • SP • PC (how?) • Other registers CPU ESP Thread 1 ready Thread 2 running Thread 2 regs

  21. From Section 3 – Winter 2006 Adjusting the PC Thread 1 TCB … SP Thread 2 TCB … SP • ret pops off the new return address! Thread 1 registers ra=0x400 ra=0x800 CPU ESP Thread 1 (stopped): switch(t1,t2); 0x400: printf(“test 1”); Thread 2 running: switch(t2,...); 0x800: printf(“test 2”); PC

  22. Join! Exciting new construct! • Wait until another thread terminates and get its return value • Convenient way to synchronize threads • Assumption • A joinable thread is guaranteed to be joined by another thread (not threads!) • Join can be called only one time at any time in the life-cycle of a joinable thread • Behavior of multiple calls of join on a single joinable thread is undefined

  23. Think about • How do you start a new thread? • How do you pass an argument to the start function? • How do you deal the main(or initial) thread? • When & how do you reclaim resources of a terminated thread? • Where does sthread_switch() return? • Who should call sthread_switch() and when? • What should be in struct _sthread(TCB)? • How do you identify current thread? • How do you block a thread? • What should be in struct _sthread_mutex? • What should be in struct _sthread_cond?

  24. Hints • Read project descriptions & given codes • There are many hints already  • pthread manual pages may be helpful • Design first • Answer questions in previous slides • Write your algorithms and verify them • Program • Don’t forget to comment your code! • Test, test, test, … • Write your own test programs • Pick the right tree • This project is not a lot of code. If you’re writing a lot of code, you’re probably confused. • Keep in mind, we might have different definitions of “a lot of code” • This is an easy project to do, but a really f’n hard project to do right.

  25. CVS • Make your project concurrent just like your programs  • Refer any CSE303 course material • http://www.cs.washington.edu/education/courses/cse303/05au/syllabus/11-14-files/ • http://www.cs.washington.edu/education/courses/cse303/06wi/lec19.pdf

  26. Scenario • Your team has two members • dumb • dumber • UNIX group of your team is cse451x • dumber is going to maintain the repository • The name of repository is cse451x

  27. Import source code • Copy simplethreads-1.30.tar.gz • Type following % tar zxf simplethreads-1.30.tar.gz % cd simplethreads-1.30 % cvs –d $USER@attu:/projects/.instr/CurrentQtr/cse451/cse451x import –m “initial skeleton code” simplethreads SIMPLETHREADS SIMPLETHREADS_1_30 % cd .. % rm –rf simplethreads-1.30 • Now you can check out using simplethreads as a module name

  28. Set CVSROOT & CVS_RSH • You want to access the repository remotely! • Bash • export CVS_RSH=ssh • export CVSROOT=$USER@attu:/projects/.instr/CurrentQtr/cse451/cse451x • Csh/tcsh • setenv CVS_RSH ssh • setenv CVSROOT $USER@attu:/projects/.instr/CurrentQtr/cse451/cse451x • To check your shell, % echo $SHELL

More Related