Threads - PowerPoint PPT Presentation

View by Category
About This Presentation
Title:

Threads

Description:

Being able to count the threads developers are using on the fingers of one hand ... Threads. Process used to group resources together ... – PowerPoint PPT presentation

Number of Views:66
Avg rating:3.0/5.0
Slides: 39
Provided by: georgejgr
Learn more at: http://people.sju.edu
Category:
Tags: threads

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: Threads


1
Threads
2
Progressing With Parallel Processing eWeek
(09/18/06) Vol. 23, No. 37, P. D5 Multithreading
skills are becoming essential as parallel
processing hardware proliferates, and developers
ignore at their own peril indications of this
trend such as Intel's investments in college
curriculum and resources for multithread
development training. The Java programming
language supports the expression of concurrency
in the same language developers are already
employing for application logic, while powerful
abstractions for C are also offered by
concurrency toolkits and frameworks. Being able
to count the threads developers are using on the
fingers of one hand is folly, according to
principal author of "Java Concurrency in
Practice" Brian Goetz. He and his five co-authors
note that "The need for thread safety is
contagious," because "frameworks may create
threads on your behalf, and code called from
these threads must be thread-safe." It is the
authors' contention that developers should never
lose sight of the application state and avoid
becoming overwhelmed by threading mechanisms.
Developers must also keep in mind that careless
habits that are acceptable in single-thread
environments may be exposed in multithread
environments.
3
2.2 Threads
  • Process address space code execution
  • There is no law that states that a process cannot
    have more than one line of execution.
  • Threads single address space many threads of
    execution
  • Shared global variables, stack address space,
    open files, signals, child processes, etc.

4
Threads
  • Process used to group resources together
  • Threads entities scheduled for execution on CPU
  • Sometimes called lightweight processes
  • Multithreading multiple threads in the same
    process

5
2
3
6
(No Transcript)
7
(No Transcript)
8
Thread functions
  • Create threads
  • include ltpthread.hgt
  • int pthread_create (
  • pthread_t thread,
  • pthread_attr_t attr,
  • void (start_routine)(void ),
  • void arg )

9
Thread termination
  • void pthread_exit ( void retval )
  • int pthread_cancel ( pthread_t thread )

10
Why threads?
  • Easier to create a thread than a process
  • Share resources
  • Compute and I/O within a single process on a
    single processor can be overlapped
  • Compute and compute within a single process on a
    multiprocessor can be overlapped

11
Example word processor
  • Multiple threads
  • User interaction
  • Document reformatting
  • Automatic saving/backups
  • Alternative is everything else stops when (2) or
    (3) occurs.

12
Example web server
  • Dispatcher handles incoming requests
  • Workers performs request
  • Checks cache
  • Reads from disk if necessary
  • Adds to cache

13
Threads and alternatives
  • Threads retain the simple sequential, blocking
    model while allowing for parallelism.
  • The single threaded server retains the simple
    sequential, block model but performance suffers
    (no parallelism).
  • Finite state machine each computation has a
    saved state and there exists some set of events
    that can occur to change the state
  • High performance through parallelism
  • Uses nonblocking calls and interrupts (not
    simple)
  • May be in user space or kernel.

14
Threads
  • Thread types
  • Detached
  • Joinable
  • (also popup)
  • Implementations
  • User space
  • Kernel
  • Hybrid

15
Pitfall global variables
  • include ltstdio.hgt
  • bool err false
  • void t1 ( void p )
  • err true
  • if (err) puts( hello ) //may never get
    here!
  • void t2 ( void p )
  • err false
  • int main ( int argc, char argv )
  • if (err) puts( something bad happened. )

16
Pitfalls global variables
17
Pitfall global variables
  • Solution dont use em.
  • Solution create thread-wide globals (using your
    own libraries)
  • Solution (other mechanisms that we will explore
    in the future)

18
Other pitfalls
  • Libraries may not be reentrant
  • Solution rewrite the library
  • Solution wrap each library call with a wrapper
  • Signals, alarms, and I/O may not be thread
    specific.

19
Other pthread functions
  • int thread_yield ( )
  • int pthread_join (
  • pthread_t th,
  • void thread_return )
  • Many, many others

20
Multithreaded example 1
21
  • /
  • file pt1.cpp
  • date 23-sep-2005
  • author george j. grevera, ph.d.
  • compile g -o pt1.exe pt1.cpp -lpthread -lm
  • desc. shell of a multithreaded app
  • /
  • include ltmath.hgt
  • include ltpthread.hgt
  • include ltstdio.hgt
  • //global variables
  • const int N 10 //max number of threads
  • pthread_t threadN //for thread id storage
  • //------------------------------------------------
    ----------------------

22
  • //------------------------------------------------
    ----------------------
  • //program execution begins here.
  • int main ( const int argc, const char const
    argv )
  • //create N threads
  • for (int i0 iltN i)
  • pthread_create( threadi, 0,
    start_routine, (void)i )
  • printf( "main thread d created. \n",
    threadi )
  • //wait for the N threads to finish
  • for (int i0 iltN i)
  • void v
  • printf( "main waiting \n" )
  • pthread_join( threadi, v )
  • printf( "main returning \n" )
  • return 0

23
  • //------------------------------------------------
    ----------------------
  • //example worker thread function. this function
    does a lot of "work"
  • // (i.e., computation).
  • double doWork ( const int whoAmI )
  • double sum 0.0
  • for (int i0 ilt10000000 i)
  • sum sin( i ) cos( i )
  • return sum
  • //------------------------------------------------
    ----------------------
  • //main thread function
  • void start_routine ( void p )
  • int whoAmI (int)p
  • printf( "d processing \n", whoAmI )
  • doWork( whoAmI )
  • printf( "d exit \n", whoAmI )

24
  • /
  • file pt1.cpp
  • date 23-sep-2005
  • author george j. grevera, ph.d.
  • compile g -o pt1.exe pt1.cpp -lpthread -lm
  • desc. shell of a multithreaded app
  • /
  • include ltmath.hgt
  • include ltpthread.hgt
  • include ltstdio.hgt
  • //global variables
  • const int N 10 //max number of threads
  • pthread_t threadN //for thread id storage
  • //------------------------------------------------
    ----------------------
  • //example worker thread function. this function
    does a lot of "work"
  • // (i.e., computation).
  • double doWork ( const int whoAmI )
  • double sum 0.0

25
Multithreading discussion
  • pthread_create only allows a single parameter to
    be passed to the thread
  • pthread_join only allows a single parameter to be
    returned from a thread
  • How can we pass and return many parameters?

26
Multithreading advanced topic
  • We know that process memory is shared among all
    threads.
  • We know that the stack is part of the process
    memory.
  • Therefore the stack is part of the memory that is
    shared among the threads.
  • How can we demonstrate that the stack is shared
    among threads?

27
  • /
  • This program demonstrates that, although stack
    variables are not
  • shared among threads, stack memory (_all_ process
    memory) is indeed
  • shared by threads.
  • g -o sharedStack.exe sharedStack.cpp -lpthread
    -lm -lrt
  • /
  • include ltiostreamgt
  • include ltmath.hgt
  • include ltpthread.hgt
  • include ltsched.hgt
  • include ltunistd.hgt
  • using namespace std
  • const int N 2 //max number of threads
  • //this will be a pointer to a local variable in
    thread 0.
  • static int whoAmIPointer NULL

From where are local variables allocated?
28
  • //------------------------------------------------
    ----------------------
  • int main ( const int argc, const char const
    argv )
  • pthread_t threadN //for thread id
    storage
  • //create N threads
  • for (int i0 ilt N i)
  • pthread_create( threadi, 0,
    start_routine, (void)i )
  • cout ltlt "main thread " ltlt i ltlt " created
    with id" ltlt threadi
  • ltlt endl
  • //wait for the N threads to finish
  • for (int i0 ilt N i)
  • void v
  • cout ltlt "main wait" ltlt endl
  • pthread_join( threadi, v )
  • cout ltlt "main returning" ltlt endl
  • return 0

Nothing new here.
29
  • //------------------------------------------------
    ----------------------
  • void start_routine ( void p )
  • int whoAmI (int)p
  • int whoAmICopy whoAmI
  • cout ltlt whoAmI ltlt " processing" ltlt endl
  • if (whoAmI0) //is this thread 0?
  • //make the global var point to my local
    var
  • whoAmIPointer whoAmI
  • sched_yield()
  • sleep( 5 )
  • else
  • //this is not thread 0 so wait until
    thread 0 sets the global var
  • // that points to thread 0's local var.
  • while (whoAmIPointerNULL)
  • sched_yield()
  • //change thread 0's local var
  • whoAmIPointer 92

What does mean in C?
30
  • //------------------------------------------------
    ----------------------
  • void start_routine ( void p )
  • int whoAmI (int)p
  • int whoAmICopy whoAmI
  • cout ltlt whoAmI ltlt " processing" ltlt endl
  • if (whoAmI0) //is this thread 0?
  • //make the global var point to my local
    var
  • whoAmIPointer whoAmI
  • sched_yield()
  • sleep( 5 )
  • else
  • //this is not thread 0 so wait until
    thread 0 sets the global var
  • // that points to thread 0's local var.
  • while (whoAmIPointerNULL)
  • sched_yield()
  • //change thread 0's local var
  • whoAmIPointer 92

What does mean in C? is the C scope
resolution operator. In this case, it refers to
a global variable.
31
  • //------------------------------------------------
    ----------------------
  • void start_routine ( void p )
  • int whoAmI (int)p
  • int whoAmICopy whoAmI
  • cout ltlt whoAmI ltlt " processing" ltlt endl
  • if (whoAmI0) //is this thread 0?
  • //make the global var point to my local
    var
  • whoAmIPointer whoAmI
  • sched_yield()
  • sleep( 5 )
  • else
  • //this is not thread 0 so wait until
    thread 0 sets the global var
  • // that points to thread 0's local var.
  • while (whoAmIPointerNULL)
  • sched_yield()
  • //change thread 0's local var
  • whoAmIPointer 92

32
  • //------------------------------------------------
    ----------------------
  • void start_routine ( void p )
  • int whoAmI (int)p
  • int whoAmICopy whoAmI
  • cout ltlt whoAmI ltlt " processing" ltlt endl
  • if (whoAmI0) //is this thread 0?
  • //make the global var point to my local
    var
  • whoAmIPointer whoAmI
  • sched_yield()
  • sleep( 5 )
  • else
  • //this is not thread 0 so wait until
    thread 0 sets the global var
  • // that points to thread 0's local var.
  • while (whoAmIPointerNULL)
  • sched_yield()
  • //change thread 0's local var
  • whoAmIPointer 92

33
  • //------------------------------------------------
    ----------------------
  • void start_routine ( void p )
  • int whoAmI (int)p
  • int whoAmICopy whoAmI
  • cout ltlt whoAmI ltlt " processing" ltlt endl
  • if (whoAmI0) //is this thread 0?
  • //make the global var point to my local
    var
  • whoAmIPointer whoAmI
  • sched_yield()
  • sleep( 5 )
  • else
  • //this is not thread 0 so wait until
    thread 0 sets the global var
  • // that points to thread 0's local var.
  • while (whoAmIPointerNULL)
  • sched_yield()
  • //change thread 0's local var
  • whoAmIPointer 92

34
  • //------------------------------------------------
    ----------------------
  • void start_routine ( void p )
  • int whoAmI (int)p
  • int whoAmICopy whoAmI
  • cout ltlt whoAmI ltlt " processing" ltlt endl
  • if (whoAmI0) //is this thread 0?
  • //make the global var point to my local
    var
  • whoAmIPointer whoAmI
  • sched_yield()
  • sleep( 5 )
  • else
  • //this is not thread 0 so wait until
    thread 0 sets the global var
  • // that points to thread 0's local var.
  • while (whoAmIPointerNULL)
  • sched_yield()
  • //change thread 0's local var
  • whoAmIPointer 92

35
  • //------------------------------------------------
    ----------------------
  • void start_routine ( void p )
  • int whoAmI (int)p
  • int whoAmICopy whoAmI
  • cout ltlt whoAmI ltlt " processing" ltlt endl
  • if (whoAmI0) //is this thread 0?
  • //make the global var point to my local
    var
  • whoAmIPointer whoAmI
  • sched_yield()
  • sleep( 5 )
  • else
  • //this is not thread 0 so wait until
    thread 0 sets the global var
  • // that points to thread 0's local var.
  • while (whoAmIPointerNULL)
  • sched_yield()
  • //change thread 0's local var
  • whoAmIPointer 92

How could this ever be true (if threads didnt
share stack memory)?
36
  • /
  • This program demonstrates that, although stack
    variables are not
  • shared among threads, stack memory (_all_ process
    memory) is indeed
  • shared by threads.
  • g -o sharedStack.exe sharedStack.cpp -lpthread
    -lm -lrt
  • /
  • include ltiostreamgt
  • include ltmath.hgt
  • include ltpthread.hgt
  • include ltsched.hgt
  • include ltunistd.hgt
  • using namespace std
  • const int N 2 //max number of threads
  • //this will be a pointer to a local variable in
    thread 0.
  • static int whoAmIPointer NULL

37
Win32 thread functions
  • CreateThread
  • ExitThread
  • TerminateThread
  • WaitForSingleObject
  • GetExitCodeThread

38
Win32 threads fibers
  • Fibers (in win32 not available in Linux)
  • A lightweight thread
  • Owned by thread
  • Threads are preemptively scheduled
  • Fibers are not preemptively scheduled
  • When thread is preempted, so is fiber
  • When thread is resumed, so is fiber
  • May be scheduled by owning thread
About PowerShow.com