Threading

errorhandleSoftware and s/w Development

Nov 18, 2013 (3 years and 11 months ago)

82 views

Cosc 4740

Chapter 4 & 5


Threads & Scheduling

Motivation


Threads run within application (process)


Multiple tasks with the application can be implemented
by separate threads


Update display


Fetch data


Spell checking


Answer a network request


Process creation is heavy
-
weight while thread creation is
light
-
weight


Can simplify code, increase efficiency


Kernels are generally multithreaded

Single and Multithreaded
Processes

Benefits


Responsiveness



Resource Sharing



Economy



Scalability



Utilization of MP Architectures

Limitations


Schedulers view a process, not threads of a
process


If 1 thread blocks for I/O or a signal, the
schedulers switches to a different process


All threads in that process are blocked!


This is especially true in java with the jvm
process


Scheduler allocates same amount of CPU
time for a 100 thread process as 2 thread
process

Multithreaded Server Architecture

More “light weight” then doing the same with processes.

User Threads


Thread management done by user
-
level
threads library



Three primary thread libraries:



POSIX Pthreads



Win32 threads



Java threads

User Thread (2)


Call special library functions


develop multiple threads of controls in our
programs that run concurrently


Fast switching
: switching among peer threads
does not incur an interrupt to the kernel


No short
-
term scheduler, no address change


Only PC & stack
-
address changed.

Kernel Threads


Supported by the Kernel



Examples


Windows XP/2000 +


Solaris


Linux


Tru64 UNIX


Mac OS X

Multi
-
thread Kernel


Kernel is a task of multiple threads, so


Threads supported directly by the O/S.


Fair scheduling


Solve the limitations of the user threads


Increased Kernel utilization


While 1 kernel thread is waiting on I/O, the kernel
can accept another request


Multithreading Models


Many
-
to
-
One



One
-
to
-
One



Many
-
to
-
Many


Many
-
to
-
One


Many user
-
level threads mapped to single
kernel thread


Limitations, all threads access a single kernel
thread, so unable to run in parallel on
multiprocessors


Examples:


Solaris Green Threads


GNU Portable Threads

One
-
to
-
One


Each user
-
level thread maps to kernel
thread


Examples


Windows NT/XP/2000 +, Linux, Solaris 9 and
later

One
-
to
-
One


Benefits


More concurrency then many
-
to
-
one


Allows parallel processing


Limitations


Most implementations restrict the number of
threads


Creating kernel threads is burden to the application
and O/S

Many
-
to
-
Many Model


Allows many user level threads to be mapped
to many kernel threads


Allows the operating system to create a
sufficient number of kernel threads


Examples


Solaris prior to version 9


Windows NT/2000 with the
ThreadFiber

package

Many
-
to
-
Many Model

Many
-
to
-
Many Model (3)


Benfits


Allows threads to block on IO, while allowing
other threads to be scheduled


Fewer kernel threads, so doesn’t burden
application and OS


Limitations


While still being done parallel on
multiprocessors, not every thread that can
execute will.

Two
-
level Model


Similar to M:M, except that it
allows a user thread to be
bound

to
kernel thread


Examples


IRIX


HP
-
UX


Tru64 UNIX


Solaris 8 and earlier

Two
-
level Model

Threading Issues


Semantics of
fork()

and
exec()

system
calls


Thread cancellation


Signal handling


Thread pools


Thread specific data


Scheduler activations

Semantics of fork() and exec()


Does
fork()

duplicate only the calling
thread or all threads?

Thread Cancellation


Terminating a thread before it has
finished


Two general approaches:


Asynchronous cancellation

terminates
the target thread immediately


Deferred cancellation

allows the target
thread to periodically check if it should
be cancelled



Signal Handling


Signals are used in UNIX systems to notify a process
that a particular event has occurred


A
signal handler

is used to process signals

1.
Signal is generated by particular event

2.
Signal is delivered to a process

3.
Signal is handled


Options:


Deliver the signal to the thread to which the signal applies


Deliver the signal to every thread in the process


Deliver the signal to certain threads in the process


Assign a specific thread to receive all signals for the process

Thread Pools


Create a number of threads in a pool
where they await work


Advantages:


Usually slightly faster to service a request
with an existing thread than create a new
thread


Allows the number of threads in the
application(s) to be bound to the size of the
pool

Thread Specific Data


Allows each thread to have its own
copy of data


Useful when you do not have control
over the thread creation process (i.e.,
when using a thread pool)

Scheduler Activations


Both M:M and Two
-
level models require
communication to maintain the appropriate
number of kernel threads allocated to the
application


Scheduler activations provide
upcalls



a communication mechanism from the kernel to
the thread library


This communication allows an application to
maintain the correct number kernel threads

Pthreads


A POSIX standard (IEEE 1003.1c)
API for thread creation and
synchronization


API specifies behavior of the thread
library, implementation is up to
development of the library


Common in UNIX operating
systems (Solaris, Linux, Mac OS X)


Pthreads Example

Pthreads Example (Cont.)

Windows XP Threads


Implements the one
-
to
-
one mapping


Each thread contains


A thread id


Register set


Separate user and kernel stacks


Private data storage area


The register set, stacks, and private storage area are
known as the
context
of the threads


The primary data structures of a thread include:


ETHREAD (executive thread block)


KTHREAD (kernel thread block)


TEB (thread environment block)


Win32 API Multithreaded C
Program

Win32 API Multithreaded C Program (Cont.)

Linux Threads


Linux refers to them as
tasks

rather than
threads


Thread creation is done through
clone()

system call


clone()

allows a child task to share the address
space of the parent task (process)

Java Threads


Java threads are managed by the
JVM



Java threads may be created by:



Extending Thread class


Implementing the Runnable interface


Java Thread States

Java Multithreaded Program

Java Multithreaded Program (Cont.)

Java Thread Scheduling


JVM Uses a Preemptive, Priority
-
Based
Scheduling Algorithm




FIFO Queue is Used if There Are Multiple
Threads With the Same Priority

Java Thread Scheduling (cont)

JVM Schedules a Thread to Run When:


1.
The Currently Running Thread Exits the
Runnable State

2.
A Higher Priority Thread Enters the Runnable
State


* Note


the JVM Does Not Specify Whether
Threads are Time
-
Sliced or Not

Time
-
Slicing

Since the JVM Doesn’t Ensure Time
-
Slicing, the yield()
Method

May Be Used:



while (true) {



// perform CPU
-
intensive task



. . .



Thread.yield();


}


This Yields Control to Another Thread of Equal Priority

Thread Priorities

Priority



Comment

Thread.MIN_PRIORITY


Minimum Thread Priority

Thread.MAX_PRIORITY


Maximum Thread Priority

Thread.NORM_PRIORITY


Default Thread Priority



Priorities May Be Set Using setPriority() method:


setPriority(Thread.NORM_PRIORITY + 2);

Thread Scheduling


Distinction between user
-
level and kernel
-
level threads



When threads supported, threads scheduled, not processes



Many
-
to
-
one and many
-
to
-
many models, thread library
schedules user
-
level threads to run on LWP


Known as
process
-
contention scope (PCS)
since scheduling
competition is within the process


Typically done via priority set by programmer



Kernel thread scheduled onto available CPU is
system
-
contention scope (SCS)


competition among all threads in
system

Pthread Scheduling


API allows specifying either PCS or SCS
during thread creation


PTHREAD_SCOPE_PROCESS schedules
threads using PCS scheduling


PTHREAD_SCOPE_SYSTEM schedules
threads using SCS scheduling


Can be limited by OS


Linux and Mac OS
X only allow
PTHREAD_SCOPE_SYSTEM

Pthread Scheduling API

#include <pthread.h>

#include <stdio.h>

#define NUM THREADS 5

int main(int argc, char *argv[])

{


int i;


pthread t tid[NUM THREADS];


pthread attr t attr;


/* get the default attributes */


pthread attr init(&attr);


/* set the scheduling algorithm to PROCESS or SYSTEM */


pthread attr setscope(&attr, PTHREAD SCOPE SYSTEM);


/* set the scheduling policy
-

FIFO, RT, or OTHER */


pthread attr setschedpolicy(&attr, SCHED OTHER);


/* create the threads */


for (i = 0; i < NUM THREADS; i++)



pthread create(&tid[i],&attr,runner,NULL);

Pthread Scheduling API


/* now join on each thread */


for (i = 0; i < NUM THREADS; i++)



pthread join(tid[i], NULL);

}


/* Each thread will begin control in this function */

void *runner(void *param)

{


printf("I am a thread
\
n");


pthread exit(0);

}

Q

A

&