1 Rajkumar Buyya School of Computer Science and Software Engineering Monash Technology Melbourne, Australia Email: rajkumar@ieee.org URL: rajkumar.

Rajkumar BuyyaSchool of Computer Science and Software Engineering

Monash Technology

Melbourne, Australia

Email: rajkumar@ieee.org

URL: http://www.dgs.monash.edu.au/~rajkumar

Concurrent Programming with Threads

Objectives

Explain the parallel computing right from architecture, OS, programming paradigm, and applications

Explain the multithreading paradigm, and all aspects of how to use it in an applicationCover all basic MT conceptsExplore issues related to MTContrast Solaris, POSIX, Java threadsLook at the APIs in detailExamine some Solaris, POSIX, and Java code

examples Debate on: MPP and Cluster Computing

Agenda

Overview of Computing Operating Systems Issues Threads Basics Multithreading with Solaris and POSIX threads Multithreading in Java Distributed Computing Grand Challenges Solaris, POSIX, and Java example code

P PP P P PMicrokernelMicrokernel

Multi-Processor Computing System

Threads InterfaceThreads Interface

Hardware

Operating System

ProcessProcessor ThreadPP

Applications

Computing Elements

Programming paradigms

Architectures Compilers Applications P.S.Es Architectures Compilers

Applications P.S.Es

SequentialEra

ParallelEra

1940 50 60 70 80 90 2000 2030

Two Eras of Computing

Commercialization R & D Commodity

History of Parallel Processing

PP can be traced to a tablet dated around 100 BC.

Tablet has 3 calculating positions. Infer that multiple positions:

Reliability/ Speed

Motivating Factors

d d d Just as we learned to fly, not by constructing a machine that flaps its wings like birds, but by applying aerodynamics principles demonstrated by nature...

We modeled PP after those of biological species.

Aggregated speed with

which complex calculations

carried out by individual neurons

response is slow (ms) - demonstrate

feasibility of PP

Motivating Factors

Why Parallel Processing?

Computation requirements are ever increasing -- visualization, distributed databases, simulations, scientific prediction (earthquake), etc..

Sequential architectures reaching physical limitation (speed of light, thermodynamics)

Technical Computing

Solving technology problems using

computer modeling, simulation and analysis

Life SciencesLife Sciences

Mechanical Design & Analysis (CAD/CAM)Mechanical Design & Analysis (CAD/CAM)

AerospaceAerospace

GeographicInformationSystems

No. of Processors

1 2 . . . .

Computational Power Improvement

Multiprocessor

Uniprocessor

5 10 15 20 25 30 35 40 45 . . . .

Computational Power Improvement

Vertical Horizontal

The Tech. of PP is mature and can be exploited commercially; significant R & D work on development of tools & environment.

Significant development in Networking technology is paving a way for heterogeneous computing.

Hardware improvements like Pipelining, Superscalar, etc., are non-scalable and requires sophisticated Compiler Technology.

Vector Processing works well for certain kind of problems.

Parallel Program has & needs ...

Multiple “processes” active

simultaneously solving a given

problem, general multiple processors.

Communication and synchronization

of its processes (forms the core of

parallel programming efforts).

Processing Elements Architecture

Simple classification by Flynn: (No. of instruction and data streams)

SISD - conventional SIMD - data parallel, vector computing MISD - systolic arrays MIMD - very general, multiple

approaches.

Current focus is on MIMD model, using general purpose processors.

(No shared memory)

Processing Elements

SISD : A Conventional Computer

Speed is limited by the rate at which computer can transfer information internally.

ProcessorProcessorData Input Data Output

Instru

ctions

Ex:PC, Macintosh, Workstations

The MISDArchitecture

More of an intellectual exercise than a practical configuration. Few built, but commercially not available

Data InputStream

Data OutputStream

Processor

InstructionStream A

InstructionStream B

Instruction Stream C

SIMD Architecture

Ex: CRAY machine vector processing, Thinking machine cm*

Ci<= Ai * Bi

InstructionStream

Processor

Data Inputstream A

Data Inputstream B

Data Inputstream C

Data Outputstream A

Data Outputstream B

Data Outputstream C

Unlike SISD, MISD, MIMD computer works asynchronously.

Shared memory (tightly coupled) MIMD

Distributed memory (loosely coupled) MIMD

MIMD Architecture

Processor

Data Inputstream A

Data Inputstream B

Data Inputstream C

Data Outputstream A

Data Outputstream B

Data Outputstream C

InstructionStream A

InstructionStream B

InstructionStream C

MEMORY

Shared Memory MIMD machine

Comm: Source PE writes data to GM & destination retrieves it Easy to build, conventional OSes of SISD can be easily be ported Limitation : reliability & expandability. A memory component or

any processor failure affects the whole system. Increase of processors leads to memory contention.

Ex. : Silicon graphics supercomputers....

MEMORY

Global Memory SystemGlobal Memory System

ProcessorA

ProcessorB

ProcessorC

MEMORY

Distributed Memory MIMD

Communication : IPC on High Speed Network. Network can be configured to ... Tree, Mesh, Cube, etc. Unlike Shared MIMD

easily/ readily expandable Highly reliable (any CPU failure does not affect the whole

system)

ProcessorA

ProcessorB

ProcessorC

MEMORY

MemorySystem A

MemorySystem B

MemorySystem C

channel

Laws of caution.....

Speed of computers is proportional to the square of their cost. i.e.. cost = Speed

Speedup by a parallel computer increases as the logarithm of the number of processors.

log 2P

(speed = cost2)

Speedup = log2(no. of processors)

Caution....

Very fast development in PP and related area

have blurred concept boundaries, causing lot of

terminological confusion : concurrent computing/

programming, parallel computing/ processing,

multiprocessing, distributed computing, etc..

It’s hard to imagine a field that changes as rapidly as

computing.

Computer Science is an Immature Science.

(lack of standard taxonomy, terminologies)

Caution....

There is no strict delimiters for contributors to the area of parallel processing : CA, OS, HLLs, databases, computer networks, all have a role to play.

This makes it a Hot Topic of Research

Caution....

Parallel Programming Paradigms

Multithreading

Task level parallelism

Serial Vs. Parallel

QPlease

COUNTER

COUNTER 1

COUNTER 2

High Performance Computing

Parallel Machine : MPP

function1( ){ //......function stuff}

function2( ){ //......function stuff}

Serial Machine

function1 ( ): function2 ( ): Single CPUTime : add (t1, t2)

function1( ) || function2 ( ) massively parallel system containing thousands of CPUsTime : max (t1, t2)

Single and Multithreaded

Processes

Single-threaded Process

Single instruction stream Multiple instruction stream

Multiplethreaded ProcessThreads of

Execution

CommonAddress Space

OS:Multi-Processing, Multi-Threaded

Application

Application Application

Application

Better Response Times in Multiple Application Environments

Higher Throughput for Parallelizeable Applications

CPU CPU CPU

Threaded Libraries, Multi-threaded I/OThreaded Libraries, Multi-threaded I/O

Multi-threading, continued...Multi-threaded OS enables parallel, scalable I/O

Application

CPU CPU CPU

Application

OS KernelMultiple, independent I/O requests can be satisfied simultaneously because all the major disk, tape, and network drivers have been multi-threaded, allowing any given driver to run on multiple CPUs simultaneously.

Shared memory

segments, pipes,

open files or

mmap’d files

Shared memory

segments, pipes,

open files or

mmap’d files

Basic Process Model

DATADATA

TEXTTEXT

DATADATA

TEXTTEXT

processesprocessesShared Memory

maintained by kernel

Shared Memorymaintained by kernel processesprocesses

What are Threads?

Thread is a piece of code that can execute in concurrence with other threads.

It is a schedule entity on a processor

Local stateGlobal/ shared statePCHard/Software Context

RegistersRegisters

HardwareContext

Status WordStatus Word

Program CounterProgram Counter

Running Thread Object

Threaded Process Model

THREAD STACK

THREAD DATA

THREAD TEXT

SHARED MEMORY

Threads within a process

Independent executables All threads are parts of a process hence communication easier and simpler.

Code-GranularityCode ItemLarge grain(task level)Program

Medium grain(control level)Function (thread)

Fine grain(data level)Loop

Very fine grain(multiple issue)With hardware

Code-GranularityCode ItemLarge grain(task level)Program

Medium grain(control level)Function (thread)

Fine grain(data level)Loop

Very fine grain(multiple issue)With hardware

Levels of Parallelism

Task i-lTask i-l Task iTask i Task i+1Task i+1

func1 ( ){........}

func2 ( ){........}

func3 ( ){........}

a ( 0 ) =..b ( 0 ) =..

a ( 1 )=..b ( 1 )=..

a ( 2 )=..b ( 2 )=..

++ xx LoadLoad

Task Control Data Multiple Issue

Simple Thread ExampleSimple Thread Example

void *func ( ){

/* define local data */- - - - - - - - - - - - - - - - - - - - - - /* function code */- - - - - - - - - - -thr_exit(exit_value);

main ( ){

thread_t tid;int exit_value;- - - - - - - - - - -thread_create (0, 0, func (), NULL, &tid);- - - - - - - - - - -thread_join (tid, 0, &exit_value);- - - - - - - - - - -

void *func ( ){

/* define local data */- - - - - - - - - - - - - - - - - - - - - - /* function code */- - - - - - - - - - -thr_exit(exit_value);

main ( ){

thread_t tid;int exit_value;- - - - - - - - - - -thread_create (0, 0, func (), NULL, &tid);- - - - - - - - - - -thread_join (tid, 0, &exit_value);- - - - - - - - - - -

Few Popular Thread Models

POSIX, ISO/IEEE standard

Mach C threads, CMU

Sun OS LWP threads, Sun Microsystems

PARAS CORE threads, C-DAC

Java-Threads, Sun Microsystems

Chorus threads, Paris

OS/2 threads, IBM

Windows NT/95 threads, Microsoft

POSIX, ISO/IEEE standard

Mach C threads, CMU

Sun OS LWP threads, Sun Microsystems

PARAS CORE threads, C-DAC

Java-Threads, Sun Microsystems

Chorus threads, Paris

OS/2 threads, IBM

Windows NT/95 threads, Microsoft

Multithreading - Uniprocessors

Concurrency Vs Parallelism Concurrency Vs Parallelism

ConcurrencyConcurrency ConcurrencyConcurrency

Number of Simulatneous execution units > no of CPUs

Multithreading - Multithreading - MultiprocessorsMultiprocessorsMultithreading - Multithreading - MultiprocessorsMultiprocessors

Concurrency Vs Parallelism Concurrency Vs Parallelism Concurrency Vs Parallelism Concurrency Vs Parallelism

No of execution process = no of CPUsNo of execution process = no of CPUs

Computational ModelComputational Model

Parallel Execution due to : Concurrency of threads on Virtual Processors Concurrency of threads on Physical Processor

True Parallelism :threads : processor map = 1:1

Parallel Execution due to : Concurrency of threads on Virtual Processors Concurrency of threads on Physical Processor

True Parallelism :threads : processor map = 1:1

User Level ThreadsUser Level Threads

Virtual ProcessorsVirtual Processors

Physical ProcessorsPhysical Processors

User-Level Schedule (User)

Kernel-Level Schedule (Kernel)

General Architecture ofThread Model

Hides the details of machine architecture

Maps User Threads to kernel threads

Process VM is shared, state change in VM by one thread visible to other.

Hides the details of machine architecture

Maps User Threads to kernel threads

Process VM is shared, state change in VM by one thread visible to other.

Process ParallelismProcess Parallelism

int add (int a, int b, int & result)// function stuffint sub(int a, int b, int & result)// function stuff

pthread t1, t2;

pthread-create(&t1, add, a,b, & r1);

pthread-create(&t2, sub, c,d, & r2);

pthread-par (2, t1, t2);

pthread t1, t2;

pthread-create(&t1, add, a,b, & r1);

pthread-create(&t2, sub, c,d, & r2);

pthread-par (2, t1, t2);

MISD and MIMD ProcessingMISD and MIMD Processing

abr1cdr2

addadd

subsub

Processor

do““

dn2/+1

““dn

SortSort

Data ParallelismData Parallelism

sort( int *array, int count)

//......

sort( int *array, int count)

//......

pthread-t, thread1, thread2;““pthread-create(& thread1, sort, array, N/2);pthread-create(& thread2, sort, array, N/2);pthread-par(2, thread1, thread2);

SIMD ProcessingSIMD Processing

SortSort

Processor

PurposePurpose Threads Model

Threads Model

Process Model

Start execution of a new thread

Creation of a new thread

Wait for completion of thread

Exit and destroy the thread

thr_join()thr_join()wait( )wait( )

exec( )exec( )

exit( )exit( )

fork ( )fork ( )

[ thr_create() builds the new thread and starts the execution

thr_create( )thr_create( )

thr_exit()thr_exit()

Process and Threaded models

Code ComparisonCode Comparison

Segment (Process)

main ( )

fork ( );

Segment (Process)

main ( )

fork ( );

Segment(Thread)

main()

thread_create(0,0,func(),0,0);

Segment(Thread)

main()

thread_create(0,0,func(),0,0);

Printing ThreadPrinting Thread

Editing Thread

Independent ThreadsIndependent Threadsprinting()

- - - - - - - - - - - -

editing()

- - - - - - - - - - - -

main()

- - - - - - - - - - - -

id1 = thread_create(printing);

id2 = thread_create(editing);

thread_run(id1, id2);

- - - - - - - - - - - -

printing()

- - - - - - - - - - - -

editing()

- - - - - - - - - - - -

main()

- - - - - - - - - - - -

id1 = thread_create(printing);

id2 = thread_create(editing);

thread_run(id1, id2);

- - - - - - - - - - - -

Cooperative threads - File Copy

reader()

- - - - - - - - - -

lock(buff[i]);

read(src,buff[i]);

unlock(buff[i]);

- - - - - - - - - -

reader()

- - - - - - - - - -

lock(buff[i]);

read(src,buff[i]);

unlock(buff[i]);

- - - - - - - - - -

writer()

- - - - - - - - - -

lock(buff[i]);

write(src,buff[i]);

unlock(buff[i]);

- - - - - - - - - -

writer()

- - - - - - - - - -

lock(buff[i]);

write(src,buff[i]);

unlock(buff[i]);

- - - - - - - - - -

buff[0]buff[0]

buff[1]buff[1]

Cooperative Parallel Synchronized Threads

RPC CallRPC Call

func(){

/* Body */}

func(){

/* Body */}

RPC(func)RPC(func)

................

ClientClient

ServerServer

Network

ServerThreads

Message PassingFacility

Server ProcessClient Process

Client Process

User Mode

Kernel Mode

Multithreaded Server

Compiler Thread

Preprocessor Thread

Multithreaded Compiler

SourceCode

ObjectCode

Thread Programming models

1. The boss/worker model

2. The peer model

3. A thread pipeline

taskXtaskX

taskYtaskY

taskZtaskZ

main ( )main ( )

WorkersProgram

Resources

Databases

SpecialDevices

Input (Stream)

The boss/worker model

Examplemain() /* the boss */

forever {

get a request;

switch( request )

case X: pthread_create(....,taskX);

taskX() /* worker */

perform the task, sync if accessing shared resources

taskY() /* worker */

--Above runtime overhead of creating thread can be solved by thread pool

* the boss thread creates all worker thread at program initialization

and each worker thread suspends itself immediately for a wakeup call

from boss

The peer model

taskXtaskX

taskYtaskY

WorkersProgram

Resources

Databases

SpecialDevices

taskZtaskZ

Input(static)

Examplemain()

pthread_create(....,thread1...task1);

pthread_create(....,thread2...task2);

signal all workers to start

wait for all workers to finish

do any cleanup

task1() /* worker */

wait for start

task2() /* worker */

wait for start

A thread pipeline

Resources Files

Databases

Special Devices

Databases

Special Devices

Databases

Special Devices

Stage 1Stage 1 Stage 2Stage 2 Stage 3Stage 3

Program Filter Threads

Input (Stream)

Examplemain()

pthread_create(....,stage1);

pthread_create(....,stage2);

wait for all pipeline threads to finish

do any cleanup

stage1() {

get next input for the program

do stage 1 processing of the input

pass result to next thread in pipeline

stage2(){

get input from previous thread in pipeline

do stage 2 processing of the input

pass result to next thread in pipeline

stageN()

get input from previous thread in pipeline

do stage N processing of the input

pass result to program output.

Multithreaded Matrix Multiply...

C[1,1] = A[1,1]*B[1,1]+A[1,2]*B[2,1]..….C[m,n]=sum of product of corresponding elements in row of A and column of B.

Each resultant element can be computed independently.

Multithreaded Matrix Multiplytypedef struct {

int id; int size;

int row, column;

matrix *MA, *MB, *MC;

} matrix_work_order_t;

main()

int size = ARRAY_SIZE, row, column;

matrix_t MA, MB,MC;

matrix_work_order *work_orderp;

pthread_t peer[size*zize];

/* process matrix, by row, column */

for( row = 0; row < size; row++ )

for( column = 0; column < size; column++)

id = column + row * ARRAY_SIZE;

work_orderp = malloc( sizeof(matrix_work_order_t));

/* initialize all members if wirk_orderp */

pthread_create(peer[id], NULL, peer_mult, work_orderp);

/* wait for all peers to exist*/ for( i =0; i < size*size;i++)

pthread_join( peer[i], NULL );

Multithreaded Server...

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

int server_socket, client_socket, clilen;

struct sockaddr_in serv_addr, cli_addr;

int one, port_id;

#ifdef _POSIX_THREADS

pthread_t service_thr;

#endif

port_id = 4000; /* default port_id */

if( (server_socket = socket( AF_INET, SOCK_STREAM, 0 )) < 0 )

printf("Error: Unable to open socket in parmon server.\n");

exit( 1 );

memset( (char*) &serv_addr, 0, sizeof(serv_addr));

serv_addr.sin_family = AF_INET;

serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

serv_addr.sin_port = htons( port_id );

setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof(one));

Multithreaded Server...

if( bind( server_socket, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0 )

printf( "Error: Unable to bind socket in parmon server->%d\n",errno );

exit( 1 );

listen( server_socket, 5);

while( 1 )

clilen = sizeof(cli_addr);

client_socket = accept( server_socket, (struct sockaddr *)&serv_addr, &clilen );

if( client_socket < 0 )

{ printf( "connection to client failed in server.\n" ); continue;

#ifdef POSIX_THREADS

pthread_create( &service_thr, NULL, service_dispatch, client_socket);

thr_create( NULL, 0, service_dispatch, client_socket, THR_DETACHED, &service_thr);

#endif

Multithreaded Server

// Service function -- Thread Funtion

void *service_dispatch(int client_socket)

…Get USER Request

if( readline( client_socket, command, 100 ) > 0 )

…IDENTI|FY USER REQUEST

….Do NECESSARY Processing

…..Send Results to Server

…CLOSE Connect and Terminate THREAD

close( client_socket );

#ifdef POSIX_THREADS

pthread_exit( (void *)0);

#endif

The Value of MT

• Program structure• Parallelism• Throughput• Responsiveness• System resource usage• Distributed objects• Single source across platforms (POSIX)• Single binary for any number of CPUs

To thread or not to thread

Improve efficiency on uniprocessor systems

Use multiprocessor Hardware

Improve Throughput Simple to implement Asynchronous I/O

Leverage special features of the OS

Use multiprocessor Hardware

Improve Throughput Simple to implement Asynchronous I/O

To thread or not to thread

If all operations are CPU intensive do not go far on multithreading

Thread creation is very cheap, it is not free thread that has only five lines of

code would not be useful

If all operations are CPU intensive do not go far on multithreading

Thread creation is very cheap, it is not free thread that has only five lines of

code would not be useful

DOS - The Minimal OS

UserSpace

KernelSpace

DOSData

Stack & Stack Pointer Program Counter

UserCode

GlobalData

DOSCode

Hardware

Multitasking OSs

Process

UserSpace

KernelSpace

Hardware

Process Structure

(UNIX, VMS, MVS, NT, OS/2 etc.)

Multitasking Systems

Hardware

The Kernel

P1 P2 P3 P4

Processes

(Each process is completely independent)

Multithreaded Process

UserCode

GlobalData

The Kernel

Process Structure

(Kernel state and address space are shared)

T1’s SP T3’sPC T1’sPC T2’sPC

T1’s SP

T2’s SP

Kernel Structures

Process ID

UID GID EUID EGID CWD.

PrioritySignal MaskRegistersKernel Stack

CPU State

File Descriptors

Signal Dispatch Table

Memory Map

Process ID

UID GID EUID EGID CWD.

File Descriptors

Signal Dispatch Table

Memory Map

Traditional UNIX Process Structure Solaris 2 Process Structure

LWP 2 LWP 1

Scheduling Design Options

M:1HP-UNIX

1:1DEC, NT, OS/1, AIX. IRIX

2-level

SunOS Two-Level Thread Model

Proc 1 Proc 2 Proc 3 Proc 4 Proc 5

Traditionalprocess

LWPsKernelthreads

Kernel

Hardware Processors

Thread Life Cycle

main() main(){ ... { pthread_create( func, arg); thr_create( ..func..,arg..); ... ...} }void * func(){ ....}

pthread_exit()

pthread_create(...func...)

POSIX Solaris

Waiting for a Thread to Exit

main() main(){ ... { pthread_join(T2); thr_join( T2,&val_ptr); ... ...} }void * func(){ ....}

pthread_exit()

pthread_join()

POSIX Solaris

Scheduling States: Simplified View of Thread State

Transitions

RUNNABLE

SLEEPINGSTOPPED

ACTIVE

Continue

Preempt Stop

Stop Sleep

Wakeup

Preemption

The process of rudely interrupting a thread and forcing it to relinquish its LWP (or CPU) to another.

CPU2 cannot change CPU3’s registers directly. It can only issue a hardware interrupt to CPU3. It is up to CPU3’s interrupt handler to look at CPU2’s request and decide what to do.Higher priority threads always preempt lower priority threads.

Preemption ! = Time slicingAll of the libraries are preemptive

EXIT Vs. THREAD_EXIT

The normal C function exit() always causes the process to exit. That means all of the process -- All the threads.The thread exit functions:

UI : thr_exit()POSIX : pthread_exit()OS/2 : DosExitThread() and _endthread()NT : ExitThread() and endthread()

all cause only the calling thread to exit, leaving the process intact and all of the other threads running. (If no other threads are running, then exit() will be called.)

Cancellation

Cancellation is the means by which a thread can tell another thread that it should exit.

main() main() main(){... {... {...pthread_cancel (T1); DosKillThread(T1); TerminateThread(T1)} } }There is no special relation between the killer of a thread and the victim. (UI threads must “roll their own” using signals)

(pthread exit)

(pthread cancel()

POSIX OS/2 Windows NT

Cancellation State and Type

State PTHREAD_CANCEL_DISABLE (Cannot be cancelled) PTHREAD_CANCEL_ENABLE (Can be cancelled, must consider

Type PTHREAD_CANCEL_ASYNCHRONOUS (any

time what-so-ever) (not generally used)

PTHREAD_CANCEL_DEFERRED (Only at cancellation points)

(Only POSIX has state and type)(OS/2 is effectively always “enabled

asynchronous”)(NT is effectively always “enabled asynchronous”)

Cancellation is Always Complex!

It is very easy to forget a lock that’s being held or a resource that should be freed.

Use this only when you absolutely require it.

Be extremely meticulous in analyzing the possible thread states.

Document, document, document!

Returning Status

POSIX and UI A detached thread cannot be “joined”. It cannot

return status. An undetached thread must be “joined”, and can

return a status.

OS/2 Any thread can be waited for No thread can return status No thread needs to be waited for.

NT No threads can be waited for Any thread can return status

Suspending a Thread

main()

... thr_suspend(T1); ... thr_continue(T1); ...}

continue()

suspend()

Solaris:

* POSIX does not support thread suspension

Proposed Uses of

Suspend/Continue

Garbage Collectors Debuggers Performance Analysers Other Tools?These all must go below the API, so they don’t

count. Isolation of VM system “spooling” (?!) NT Services specify that a service should b

suspendable (Questionable requirement?)

Be Careful

Do NOT Think about Scheduling!

Think about Resource AvailabilityThink about SynchronizationThink about Priorities

Ideally, if you’re using suspend/ continue, you’re making a mistake!

Synchronization

Websters: “To represent or arrange events to indicate coincidence or coexistence.”

Lewis : “To arrange events so that they occur in a specified order.”

* Serialized access to controlled resources.

Synchronization is not just an MP issue. It is not even strictly an MT issue!

Threads Synchronization : On shared memory : shared variables -

semaphores On distributed memory :within a task : semaphores Across the tasks : By passing

messages

Threads Synchronization : On shared memory : shared variables -

semaphores On distributed memory :within a task : semaphores Across the tasks : By passing

messages

Unsynchronized Shared Data is a Formula for

Disaster

Thread1 Thread2

temp = Your - > BankBalance;

dividend = temp * InterestRate;

newbalance = dividend + temp;

Your->Dividend += dividend; Your->BankBalance+= deposit;

Your->BankBalance = newbalance;

Atomic Actions

An action which must be started and completed with no possibility of interruption.A machine instruction could need to be

atomic. (not all are!)A line of C code could need to be atomic. (not

all are)An entire database transaction could need to

be atomic. All MP machines provide at least one complex

atomic instruction, from which you can build anything.

A section of code which you have forced to be atomic is a Critical Section.

Critical Section(Good Programmer!)

reader()

- - - - - - - - - -

lock(DISK);

...........

unlock(DISK);

- - - - - - - - - -

reader()

- - - - - - - - - -

lock(DISK);

...........

unlock(DISK);

- - - - - - - - - -

writer()

- - - - - - - - - -

lock(DISK);

..............

unlock(DISK);

- - - - - - - - - -

writer()

- - - - - - - - - -

lock(DISK);

..............

unlock(DISK);

- - - - - - - - - -

Shared Data

Critical Section(Bad Programmer!)

reader()

- - - - - - - - - -

lock(DISK);

...........

unlock(DISK);

- - - - - - - - - -

reader()

- - - - - - - - - -

lock(DISK);

...........

unlock(DISK);

- - - - - - - - - -

writer()

- - - - - - - - - -

..............

- - - - - - - - - -

writer()

- - - - - - - - - -

..............

- - - - - - - - - -

Shared Data

Lock Shared Data!

Globals Shared data structures Static variables

(really just lexically scoped global variables)

Mutexes

item = create_and_fill_item();

mutex_lock( &m );

item->next = list;

list = item;

mutex_unlock(&m);

mutex_lock( &m );

this_item = list;

list = list_next;

mutex_unlock(&m);

.....func(this-item);

POSIX and UI : Owner not recorded, block in priority order.

OS/2 and NT. Owner recorded, block in FIFO order.

Thread 1 Thread2

Synchronization Variables in Shared Memory (Cross

Process)

Process 1 Process 2

S SShared MemoryS

SynchronizationVariable

Thread

SynchronizationProblems

Deadlocks

lock( M1 );

lock( M2 );

lock( M1 );

Thread 1 Thread 2

Thread1 is waiting for the resource(M2) locked by Thread2 andThread2 is waiting for the resource (M1) locked by Thread1

Avoiding Deadlocks Establish a hierarchy : Always lock Mutex_1 before Mutex_2, etc..,. Use the trylock primitives if you must violate the hierarchy.

while (1)

{ pthread_mutex_lock (&m2);

if( EBUSY |= pthread mutex_trylock (&m1))

break;

{ pthread _mutex_unlock (&m1);

wait_around_or_do_something_else();

do_real work(); /* Got `em both! */

} Use lockllint or some similar static analysis program to scan your

code for hierarchy violations.

Race Conditions

A race condition is where the results of a program are different depending upon the timing of the events within the program.

Some race conditions result in different answers and are clearly bugs.

Thread 1 Thread 2

mutex_lock (&m) mutex_lock (&m)

v = v - 1; v = v * 2;mutex_unlock (&m) mutex_unlock (&m)

--> if v = 1, the result can be 0 or 1based on which thread gets chance to enter CR first

Operating System Issues

Library Goals

Make it fast! Make it MT safe! Retain UNIX semantics!

Are Libraries Safe ?

getc() OLD implementation: extern int get( FILE * p )

/* code to read data */

getc() NEW implementation: extern int get( FILE * p )

pthread_mutex_lock(&m);

/* code to read data */

pthread_mutex_unlock(&m);

In UNIX, the distinguished variable errno is used to hold the error code for any system calls that fail.

Clearly, should two threads both be issuing system calls around the same time, it would not be possible to figure out which one set the value for errno.

Therefore errno is defined in the header file to be a call to thread-specific data.

This is done only when the flag_REENTRANT (UI)

_POSIX_C_SOURCE=199506L (POSIX) is passed to the compiler, allowing older, non-MT programs to continue to run.

There is the potential for problems if you use some libraries which are not reentrant. (This is often a problem when using third party libraries.)

Are Libraries Safe?

MT-Safe This function is safe MT-Hot This function is safe and fast MT-Unsafe This function is not MT-safe,

but was compiled with _REENTRANT

Alternative Call This function is not safe, but there is a similar function (e.g. getctime_r())

MT-Illegal This function wasn’t even compiled with _REENTRANT and therefore can only be called from the main thread.

Threads Debugging Interface

Debuggers Data inspectors Performance monitors Garbage collectors Coverage analyzers

Not a standard interface!

The APIs

Different Thread Specifications

Functionality UI Threads POSIX Thteads NT Threads OS/2 Threads

Design Philosophy Base Near-Base Complex ComplexPrimitives Primitives Primitives

PrimitivesScheduling Classes Local/ Global Local/Global Global GlobalMutexes Simple Simple Complex ComplexCounting Semaphores Simple Simple Buildable BuildableR/W Locks Simple Buildable Buildable BuildableCondition Variables Simple Simple Buildable BuildableMultiple-Object Buildable Buildable Complex ComplexSynchronizationThread Suspension Yes Impossible Yes YesCancellation Buildable Yes Yes YesThread-Specific Data Yes Yes Yes YesSignal-Handling Primitives Yes Yes n/a n/aCompiler Changes

Required No No Yes NoVendor Libraries MT-safe? Moat Most All? All?ISV Libraries MT-safe? Some Some Some Some

POSIX and Solaris API Differences

thread cancellation

scheduling policies

sync attributes

thread attributes

continue

suspend

semaphore vars

concurrency setting

reader/ writer vars

daemon threads

exit key creation

priorities sigmask create

thread specific data

mutex vars kill

condition vars

POSIX API Solaris API

Error Return Values

Many threads functions return an error value which can be looked up in errno.h.

Very few threads functions set errno(check man pages).

The “lack of resources” errors usually mean that you’ve used up all your virtual memory, and your program is likely to crash very soon.

Attribute Objects

UI, OS/2, and NT all use flags and direct arguments to indicate what the special details of the objects being created should be. POSIX requires the use of “Attribute objects”:

thr_create(NULL, NULL, foo, NULL, THR_DETACHED);

pthread_attr_t attr;

pthread_attr_init(&attr);

pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);

pthread_create(NULL, &attr, foo, NULL);

Attribute Objects

Although a bit of pain in the *** compared to passing all the arguments directly, attribute objects allow the designers of the threads library more latitude to add functionality without changing the old interfaces. (If they decide they really want to, say, pass the signal mask at creation time, they just add a function pthread_attr_set_signal_mask() instead of adding a new argument to pthread_create().)There are attribute objects for:Threads

stack size, stack base, scheduling policy, scheduling class, scheduling scope, scheduling inheritance, detach state.Mutexes

Cross process, priority inheritanceCondition Variables

Cross process

Attribute Objects

Attribute objects must be:

Allocated

Initialized

Values set (presumably)

Destroyed (if they are to be free’d)

pthread_attr_t attr;

pthread_attr_init (&attr);

pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)’

pthread_create(NULL, &attr, foo, NULL);

pthread_attr_destroy (&attr);

Thread Attribute Objects

pthread_attr_t;Thread attribute object type:

pthread_attr_init (pthread_mutexattr_t *attr)pthread_attr_destroy (pthread_attr_t *attr)

pthread_attr_getdetachstate (pthread_attr_t *attr, in *state)

pthread_attr_setdetachstate (pthread_attr_t *attr, int state)

Can the thread be joined?:pthread_attr_getscope(pthread_attr_t *attr, in *scope)pthread_attr_setscope(pthread_attr_t *attr, int scope)

pthread_attr_getinheritpolicy(pthread_attr_t *attr, int *policy)pthread_attr_setinheritpolicy(pthread_attr_t *attr, int policy)

Will the policy in the attribute object be used?pthread_attr_getschedpolicy(pthread_attr_t *attr, int *policy)pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy)

Will the scheduling be RR, FIFO, or OTHER?pthread_attr_getschedparam(pthread_attr_t *attr, struct sched

param *param)pthread_attr_setschedparam(pthread attr_t *attr, struct sched

param *param);What will the priority be?

pthread_attr_getinheritsched(pthread_attr_t *attr, int *inheritsched)

pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched)

Will the policy in the attribute object be used?

pthread_attr_getstacksize(pthread_attr_t *attr, int *size)

pthread_attr_setstacksize(pthread_attr_t *attr, int size)

How big will the stack be?

pthread_attr_getstackaddr (pthread_attr_t *attr, size_t *base)

pthread_attr_setstackaddr(pthread_attr_t *attr, size_t base)

What will the stack’s base address be?

Mutex Attribute Objects

pthread_mutexattr_t;

mutex attribute object type

pthread_mutexattr_init(pthread_mutexattr_t *attr)

pthread_mutexattr_destroy(pthread_mutexattr_t *attr)

pthread_mutexattr_getshared(pthread_mutexattr_t*attr, int shared)

pthread_mutexattr_setpshared (pthread_mutex attr_t *attr,

int shared)

Will the mutex be shared across processes?

Mutex Attribute Objects

pthread_mutexattr_getprioceiling(pthread_mutexattr_t

*attr, int *ceiling)pthread_mutexattr_setprioceiling(pthread_mutexattr_t

*attr, int *ceiling)What is the highest priority the thread owning this mutex can acquire?

pthread_mutexattr_getprotocol (pthread_mutexattr_t*attr, int *protocol)

pthread_mutexattr_setprotocol (pthread_mutexattr_t*attr, int protocol)

Shall the thread owning this mutex inherit priorities from waiting threads?

Condition Variable Attribute Objects

pthread_condattr_t;CV attribute object type

pthread_condattr_init(pthread_condattr_t * attr)pthread_condattr_destroy(pthread_condattr_t *attr)pthread_condattr_getpshared (pthread_condattr_t

*attr, int *shared)pthread_condattr_setpshared (pthread_condattr_t

*attr, int shared)

Will the mutex be shared across processes?

Creation and Destruction (UI & POSIX)

int thr_create(void *stack_base, size_t stacksize,

void *(*start_routine) (void *), void

* arg, long flags, thread_t thread);

void thr_exit (void *value_ptr);

int thr_join (thread_t thread, void **value_ptr);

int pthread_create (pthread_t *thread, const

pthread_attr_t *attr, void *

(*start_routine) (void *), void *arg);

void pthread_exit (void *value_ptr);

int pthread_join (pthread_t thread, void

**value_ptr);

int pthread_cancel (pthread_t thread);

Suspension (UI & POSIX)

int thr_suspend (thread_t target)

int thr_continue (thread_t target)

Changing Priority (UI & POSIX)

int thr_setpriority(thread_t thread, int priority)

int thr_getpriority(thread_t thread, int *priority)

int pthread_getschedparam(pthread_t thread, int

*policy, struct sched param

*param)

int pthread_setschedparam(pthread_t thread, int

policy, struct sched param *param)

Readers / Writer Locks (UI)

int rwlock_init (rwlock_t *rwlock, int type, void *arg);

int rw_rdlock (rwlock_t *rwlock);

int rw_wrlock (rwlock_t *rwlock);

int rw_tryrdlock (rwlock_t *rwlock);

int rw_trywrlock (rwlock_t *rwlock);

int rw_unlock (rwlock_t *rwlock);

int rw_destroy (rwlock_t *rwlock);

(Counting) Semaphores (UI & POSIX)

int sema_init (sema_t *sema,

unsigned int sema_count,

int type, void *arg)

int sema_wait (sema_t *sema)

int sema_post (sema_t *sema)

int sema_trywait (sema_t *sema)

int sema_destroy (sema_t *sema)

int sem_init (sem_t *sema, int pshared, unsigned int count)

int sem_post (sem_t *sema)

int sem_trywait (sem_t *sema)

int sem_destroy (sem_t *sema)

(POSIX semaphores are not part of pthread. Use the libposix4.so and posix4.h)

Condition Variables (UI & POSIX)

int cond_init(contd_t *cond, int type, void *arg)int cond_wait(cond_t *cond, mutex_t *mutex);int cond_signal(cond_t *cond)int cond_broadcast(cond_t *cond)int cond_timedwait(cond_t *cond, mutex_t *mutex, timestruc_t

*abstime)int cond_destroy (cond_t *cond)

int pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *attr)int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t

*mutex)int pthread_cond_signal (pthread_cond_t *cond)int pthread_cond_broadcast(pthread_cond_t *cond, pthread_mutex_t

*mutex, struct timespec *abstime)int pthread_cond_destroy(pthread_cond_t *cond)

Signals (UI & POSIX)

int thr_sigsetmask(int how, const sigset_t *set, sigset_t *oset);

int thr_kill(thread_t target thread, int sig)

int sigwait(sigset_t *set)

int pthread_sigmask(int how, const sigset_t *set, sigset_t *oset);

int pthread_kill(thread_t target_thread, int sig)

int sigwait(sigset_t *set, int *sig)

Cancellation (POSIX)

int pthread_cancel (pthread_thread_t thread)

int pthread cleanup_pop (int execute)

int pthread_cleanup_push (void (*funtion) (void *),

void *arg)

int pthread_setcancelstate (int state, int *old_state)

int pthread_testcancel (void)

Other APIs

thr_self(void)thr_yield()

int pthread_atfork(void (*prepare) (void),void (*parent) (void),void (*child) (void)

pthread_equal (pthread_thread_t tl, pthread_thread_t t2)

pthread_once (pthread_once_t *once_control, void(*init_routine) (void))

pthread_self (void)

pthread_yield()

(Thread IDs in Solaris recycle every 2^32 threads, or about once a month if you do create/exit as fast as possible.)

Compiling

Solaris Libraries

Solaris has three libraries: libthread.so, libpthread.so, libposix4.so

Corresponding new include files: synch.h, thread.h, pthread.h, posix4.h

Bundled with all O/S releasesRunning an MT program requires no extra

effortCompiling an MT program requires only a

compiler (any compiler!)Writing an MT program requires only a

compiler (but a few MT tools will come in very handy)

Compiling UI under Solaris

Compiling is no different than for non-MT programs libthread is just another system library in /usr/lib Example:

%cc -o sema sema.c -lthread -D_REENTRANT%cc -o sema sema.c -mt

All multithreaded programs should be compiled using the _REENTRANT flag Applies for every module in a new application If omitted, the old definitions for errno, stdio would

be used, which you don’t want All MT-safe libraries should be compiled using

the _REENTRANT flag, even though they may be used single in a threaded program.

Compiling POSIX under Solaris

Compiling is no different than for non-MT programs libpthread is just another system library in /usr/lib Example :

%cc-o sema sema.c -lpthread -lposix4 -D_POSIX_C_SOURCE=19956L

All multithreaded programs should be compiled using the _POSIX_C_SOURCE=199506L flag Applies for every module in a new application If omitted, the old definitions for errno, stdio

would be used, which you don’t want All MT-safe libraries should be compiled using

the _POSIX_C_SOURCE=199506L flag, even though they may be used single in a threaded program

Compiling mixed UI/POSIX under Solaris

If you just want to use the UI thread functions (e.g., thr_setconcurrency())

%cc-o sema sema.c -1thread -1pthread -1posix4 D_REENTRANT -

_POSIX_PTHREAD_SEMANTICS

If you also want to use the UI semantics for fork(), alarms, timers, sigwait(), etc.,.

Summary

Threads provide a more natural programming paradigm

Allows to take full advantage of multiprocessor Hardware

Improve Throughput: simple to implement asynchronous I/O

Many applications are already multithreaded

MT is not a silver bullet for all programming problems.

Threre is already standard for multithreading--POSIX

Multithreading support already available in the form of language syntax--Java

Threads allows to model the real world object (ex: in Java)

Threads provide a more natural programming paradigm

Allows to take full advantage of multiprocessor Hardware

Improve Throughput: simple to implement asynchronous I/O

Many applications are already multithreaded

MT is not a silver bullet for all programming problems.

Threre is already standard for multithreading--POSIX

Multithreading support already available in the form of language syntax--Java

Threads allows to model the real world object (ex: in Java)

Multithreading in Java

Java - An Introduction

Java - The new programming language from Sun Microsystems

Java -Allows anyone to publish a web page with Java code in it

Java - CPU Independent language Created for consumer electronics Java - James , Arthur Van , and others Java -The name that survived a patent

search Oak -The predecessor of Java Java is “C++ -- ++ “

Object Oriented Languages -A

comparisonFeature C++ Objective

CAda Java

Encapsulation Yes Yes Yes YesInheritance Yes Yes No YesMultiple Inherit. Yes Yes No NoPolymorphism Yes Yes Yes YesBinding (Early or Late) Both Both Early LateConcurrency Poor Poor Difficult YesGarbage Collection No Yes No YesGenericity Yes No Yes NoClass Libraries Yes Yes Limited Yes

Sun defines Java as:

Simple and PowerfulSimple and Powerful SafeSafe Object OrientedObject Oriented RobustRobust Architecture Neutral and PortableArchitecture Neutral and Portable Interpreted and High PerformanceInterpreted and High Performance Threaded Threaded DynamicDynamic

Java Integrates

Power of Compiled Languages

Flexibility of Interpreted Languages

Classes and Objects

Classes and Objects Method Overloading Method Overriding Abstract Classes Visibility modifiers

default

public

protected

private protected , private

Threads

Java has built in thread support for Multithreading

Synchronization Thread Scheduling Inter-Thread Communication:

currentThread start setPriority

yield run getPriority

sleep stop suspend

resume Java Garbage Collector is a low-priority

thread

Ways of Multithreading in Java

Create a class that extends the Thread class Create a class that implements the Runnable interface

1st Method: Extending the Thread class class MyThread extends Thread

public void run()

// thread body of execution

} Creating thread:

MyThread thr1 = new MyThread(); Start Execution:

thr1.start();

2nd method: Threads by implementing Runnable interface

class ClassName implements Runnable

public void run()

// thread body of execution

} Creating Object:

ClassName myObject = new ClassName(); Creating Thread Object:

Thread thr1 = new Thread( myObject ); Start Execution:

thr1.start();

Thread Class Members...public class java.lang.Thread extends java.lang.Object

implements java.lang.Runnable

// Fields

public final static int MAX_PRIORITY;

public final static int MIN_PRIORITY;

public final static int NORM_PRIORITY;

// Constructors

public Thread();

public Thread(Runnable target);

public Thread(Runnable target, String name);

public Thread(String name);

public Thread(ThreadGroup group, Runnable target);

public Thread(ThreadGroup group, Runnable target, String name);

public Thread(ThreadGroup group, String name);

// Methods

public static int activeCount();

public void checkAccess();

public int countStackFrames();

public static Thread currentThread();

public void destroy();

public static void dumpStack();

public static int enumerate(Thread tarray[]);

public final String getName();

...Thread Class Members.public final int getPriority(); // 1 to 10 priority-pre-emption at mid.

public final ThreadGroup getThreadGroup();

public void interrupt();

public static boolean interrupted();

public final boolean isAlive();

public final boolean isDaemon();

public boolean isInterrupted();

public final void join();

public final void join(long millis);

public final void join(long millis, int nanos);

public final void resume();

public void run();

public final void setDaemon(boolean on);

public final void setName(String name);

public final void setPriority(int newPriority);

public static void sleep(long millis);

public static void sleep(long millis, int nanos);

public void start();

public final void stop();

public final void stop(Throwable obj);

public final void suspend();

public String toString();

public static void yield();

Manipulation of Current Thread// CurrentThreadDemo.java

class CurrentThreadDemo {

public static void main(String arg[]) {

Thread ct = Thread.currentThread();

ct.setName( "My Thread" );

System.out.println("Current Thread : "+ct);

for(int i=5; i>0; i--) {

System.out.println(" " + i);

Thread.sleep(1000);

catch(InterruptedException e) {

System.out.println("Interrupted."); }

Current Thread : Thread[My Thread,5,main]

Creating new Thread...

// ThreadDemo.java

class ThreadDemo implements Runnable

ThreadDemo()

Thread ct = Thread.currentThread();

System.out.println("Current Thread : "+ct);

Thread t = new Thread(this,"Demo Thread");

t.start();

Thread.sleep(3000);

catch(InterruptedException e)

System.out.println("Interrupted.");

System.out.println("Exiting main thread.");

...Creating new Thread.public void run() {

for(int i=5; i>0; i--) {

System.out.println(" " + i);

Thread.sleep(1000);

catch(InterruptedException e) {

System.out.println("Child interrupted.");

System.out.println("Exiting child thread.");

public static void main(String args[]) {

new ThreadDemo();

Current Thread : Thread[main,5,main]

Exiting main thread.

Exiting child thread.

Thread Priority...// HiLoPri.java

class Clicker implements Runnable {

int click = 0;

private Thread t;

private boolean running = true;

public Clicker(int p)

t = new Thread(this);

t.setPriority(p);

public void run()

while(running)

click++;

public void start()

t.start();

public void stop()

running = false;

...Thread Priorityclass HiLoPri

public static void main(String args[])

Thread.currentThread().setPriority(Thread.MAX_PRIORITY);

Clicker Hi = new Clicker(Thread.NORM_PRIORITY+2);

Clicker Lo = new Clicker(Thread.NORM_PRIORITY-2);

Lo.start();

Hi.start();

Thread.sleep(10000);

catch (Exception e)

Lo.stop();

Hi.stop();

System.out.println(Lo.click + " vs. " + Hi.click);

Run1: (on Solaris)

0 vs. 956228

Run2: (Window 95)

304300 vs. 4066666

The Java monitor model

Method 1

Method 2

Block 1Key

Threads

Monitor (synchronised) solves race-condition problem

Threads Synchronisation...// Synch.java: race-condition without synchronisation

class Callme {

// Check synchronized and unsynchronized methods

/* synchronized */ void call(String msg)

System.out.print("["+msg);

Thread.sleep(1000);

catch(Exception e)

System.out.println("]");

class Caller implements Runnable

String msg;

Callme Target;

public Caller(Callme t, String s)

Target = t;

msg = s;

new Thread(this).start();

...Threads Synchronisation. public void run() {

Target.call(msg);

class Synch {

Callme Target = new Callme();

new Caller(Target, "Hello");

new Caller(Target, "Synchronized");

new Caller(Target, "World");

Run 1: With unsynchronized call method (race condition)

[Hello[Synchronized[World]

Run 2: With synchronized call method

[Hello]

[Synchronized]

[World]

Run3: With Synchronized object

synchronized(Target)

{ Target.call(msg); }

The output is the same as Run2

Queue (no inter-threaded communication)...

// pc.java: produce and consumer

class Queue

int n;

synchronized int get()

System.out.println("Got : "+n);

return n;

synchronized void put(int n)

this.n = n;

System.out.println("Put : "+n);

class Producer implements Runnable

Queue Q;

Producer(Queue q)

Q = q;

new Thread( this, "Producer").start();

Queue (no inter-threaded communication)...

public void run()

int i = 0;

while(true)

Q.put(i++);

class Consumer implements Runnable

Queue Q;

Consumer(Queue q)

Q = q;

new Thread( this, "Consumer").start();

public void run()

while(true)

Q.get();

...Queue (no inter-threaded communication).

class PC

public static void main(String[] args)

Queue Q = new Queue();

new Producer(Q);

new Consumer(Q);

Put: 1

Got: 1

Put: 2

Put: 3

Got: 3

Queue (interthread communication)...

// PCnew.java: produce-consumenr with interthread communication

class Queue

int n;

boolean ValueSet = false;

synchronized int get()

if(!ValueSet)

wait();

System.out.println("Got : "+n);

ValueSet = false;

notify();

return n;

synchronized void put(int n)

if(ValueSet)

wait();

this.n = n;

System.out.println("Put : "+n);

ValueSet = true;

notify();

class Producer implements Runnable

Queue Q;

Producer(Queue q)

Q = q;

new Thread( this, "Producer").start();

public void run()

int i = 0;

while(true)

Q.put(i++);

class Consumer implements Runnable

Queue Q;

Consumer(Queue q)

Q = q;

new Thread( this, "Consumer").start();

public void run()

while(true)

Q.get();

...Queue (no interthread communication).

class PCnew

public static void main(String[] args)

Queue Q = new Queue();

new Producer(Q);

new Consumer(Q);

Put : 0

Got : 0

Put : 1

Got : 1

Put : 2

Got : 2

Put : 3

Got : 3

Put : 4

Got : 4

Deadlock...

// DeadLock.java

class A

synchronized void foo(B b)

String name = Thread.currentThread().getName();

System.out.println(name + " entered A.foo");

Thread.sleep(1000);

catch(Exception e)

System.out.println(name + " trying to call B.last()");

b.last();

synchronized void last()

System.out.println("Inside A.last");

Deadlock...

class B

synchronized void bar(A a)

String name = Thread.currentThread().getName();

System.out.println(name + " entered B.bar");

Thread.sleep(1000);

catch(Exception e)

System.out.println(name + " trying to call A.last()");

a.last();

synchronized void last()

System.out.println("Inside B.last");

...Deadlock.class DeadLock implements Runnable {

A a = new A();

B b = new B();

DeadLock() {

Thread.currentThread().setName("Main Thread");

new Thread(this).start();

a.foo(b);

System.out.println("Back in the main thread.");

public void run() {

Thread.currentThread().setName("Racing Thread");

b.bar(a);

System.out.println("Back in the other thread");

new DeadLock();

Main Thread entered A.foo

Racing Thread entered B.bar

Main Thread trying to call B.last()

Racing Thread trying to call A.last()

Grand Challenges (Is PP Practical?)

Need OS and Compiler support to use multiprocessor machines.

Ideal would be for the user to be unaware if the problem is running on sequential or parallel hardware - a long way to go.

With Highspeed Networks and improved microprocessor performance, multiple stand-alone machines can also be used as a parallel machine - a Popular Trend. (appealing vehicle for parallel computing)

Language standards have to evolve. (Portability). Re-orientation of thinking

Sequential Parallel

Need OS and Compiler support to use multiprocessor machines.

Ideal would be for the user to be unaware if the problem is running on sequential or parallel hardware - a long way to go.

With Highspeed Networks and improved microprocessor performance, multiple stand-alone machines can also be used as a parallel machine - a Popular Trend. (appealing vehicle for parallel computing)

Language standards have to evolve. (Portability). Re-orientation of thinking

Sequential Parallel

Grand Challenges (Is PP Practical?)

Language standards have to evolve. (Portability).

Re-orientation of thinkingSequential Parallel

Language standards have to evolve. (Portability).

Re-orientation of thinkingSequential Parallel

Breaking High Performance Computing BarriersBreaking High Performance Computing Barriers

21002100 2100 2100 2100

2100 2100 2100 2100

Single

Processor

Shared

Memory

LocalParallelCluster

GlobalParallelCluster

Thank You ...Thank You ...

1 Rajkumar Buyya School of Computer Science and Software Engineering Monash Technology Melbourne, Australia Email: rajkumar@ieee.org URL: rajkumar.

cluster computing slide

parallel computing

reliability speed slide

posix threads

cpus cpu slide

java threads c look

threads basics

java example code slide

Documents

PARMON A Comprehensive Cluster Monitoring System PARMON Team...

Grid Resource Management: Challenges, Approaches, &...

Simulation Modelling Practice and...

Convergence Characteristics for Clusters, Grids, and P2P...

Mastering Cloud Computing - Rajkumar Buyya

1 Introduction to Software Engineering Rajkumar Buyya Grid.....

Rajkumar Buyya, David Abramson, Jon Giddy

Computer organization and arChiteCture Designing for...

Cluster and Grid Computing Information Session /...

Nimrod-G and Virtual Lab Tools for Data Intensive Computing....

Rajkumar Buyya (1,2), Chee Shin Yeo (1), and Srikumar...

Virtual Laboratory: Data Intensive Science during Holiday @....

Assignment 2 – Team Project: Distributed System and...

GridSim:Java-based Modelling and Simulation of Deadline and....

1 Inter-Process Communication: Network Programming using TCP...

Client/Server Computing (the wave of the future) Rajkumar...