5. MULTITHREADING

POINTS TO BE COVERED..

• THREAD

• PTHREAD API FOR THREAD MANAGEMENT

• THREAD SCHEDULING AND PRIORITIES

• THREAD CONTENTION SCOPE

WHAT IS MULTI-CORE PROCESSOR?

• A MULTI-CORE PROCESSOR IS A SINGLE COMPUTING COMPONENT WITH TWO OR MORE INDEPENDENT ACTUAL CPUS (CALLED "CORES").

• THE INSTRUCTIONS ARE ORDINARY CPU INSTRUCTIONS SUCH AS ADD, MOVE DATA, AND BRANCH, BUT THE MULTIPLE CORES CAN RUN MULTIPLE INSTRUCTIONS AT THE SAME TIME, INCREASING OVERALL SPEED FOR PROGRAMS LEADING TO PARALLEL COMPUTING.

• THE MULTIPLE CORES ARE INTEGRATED ON A SINGLE INTEGRATED CIRCUIT DIE (KNOWN AS A CHIP MULTIPROCESSOR OR CMP).

• A MULTI-CORE PROCESSOR IMPLEMENTS MULTIPROCESSING IN A SINGLE PHYSICAL PACKAGE.

CMP

EXAMPLES OF CMPS:

• E.G. A DUAL-CORE PROCESSOR HAS TWO CORES (E.G. AMD PHENOM II X2, INTEL CORE DUO).

• A QUAD-CORE PROCESSOR CONTAINS FOUR CORES (E.G. AMD PHENOM II X4, INTEL'S QUAD-CORE PROCESSORS,  I5 AND I7 AT INTEL CORE),

• A 6-CORE PROCESSOR CONTAINS SIX CORES (E.G. AMD PHENOM II X6, INTEL CORE I7 EXTREME EDITION 980X),

• AN 8-CORE PROCESSOR CONTAINS EIGHT CORES (E.G. INTEL XEON E7-2820, AMD FX-8350),

• A 10-CORE PROCESSOR CONTAINS TEN CORES (E.G. INTEL XEON E7-2850),

• A 12-CORE PROCESSOR CONTAINS TWELVE CORES.

•  

WHAT IS A PROCESS AND A THREAD?

• A PROCESS IS AN INSTANCE OF A RUNNING (OR SUSPENDED) PROGRAM.

• IT HAS ITS OWN ADDRESS SPACE/MEMORY.

• A THREAD IS A SEQUENCE OR STREAM OF EXECUTABLE CODE OR STREAM OF INSTRUCTIONS WITHIN A PROCESS.

• THE OPERATING SYSTEM SCHEDULES IT FOR EXECUTION ON A PROCESSOR OR CORE.

• A PROCESS MAY HAVE ONE OR MORE THREADS I.E. ONE OR MORE FLOWS OF CONTROLS.

• IT IS A LIGHT WEIGHT PROCESS WITH LESS OVERHEAD THAN A PROCESS.

• EACH THREAD OF A PROGRAM / PROCESS EXECUTES INDEPENDENTLY OR CONCURRENTLY.

• A PROCESS WITH MULTIPLE THREADS IS MULTITHREADED PROCESS.

• THE THREADS OF SAME PROCESS ARE CALLED PEER THREADS.

PROPERTIES OF THREADS1) THREADS EXECUTE INDEPENDENT CONCURRENT TASKS

OF A PROGRAM.

2) MULTIPLE THREADS OF A PROCESS CAN BE CREATED, MANAGED, MAINTAINED EASILY AS COMPARED TO A SINGLE PROCESS.

3) THREADS USE MINIMAL RESOURCES SHARED IN THE ADDRESS SPACE OF A SINGLE PROCESS AS COMPARED TO AN APPLICATION.

4) THREADS CAN IMPROVE THE THROUGHPUT AND PERFORMANCE OF THE APPLICATION IF USED CORRECTLY.

5) EACH THREAD CAN BE ASSIGNED A PRIORITY SHOWING IMPORTANCE OF THE SUBTASK IT IS EXECUTING.

TERMINOLOGY

• CONCURRENT COMPUTING – A PROGRAM IS ONE IN WHICH MULTIPLE TASKS CAN BE IN PROGRESS AT ANY INSTANT.

• PARALLEL COMPUTING – A PROGRAM IS ONE IN WHICH MULTIPLE TASKS COOPERATE CLOSELY TO SOLVE A PROBLEM

• DISTRIBUTED COMPUTING – A PROGRAM MAY NEED TO COOPERATE WITH OTHER PROGRAMS TO SOLVE A PROBLEM.

COORDINATION

• CORES USUALLY NEED TO COORDINATE THEIR WORK.

• COMMUNICATION – ONE OR MORE CORES SEND THEIR CURRENT PARTIAL RESULTS TO ANOTHER CORE.

• LOAD BALANCING – SHARE THE WORK EVENLY AMONG THE CORES SO THAT ONE IS NOT HEAVILY LOADED.

• SYNCHRONIZATION – BECAUSE EACH CORE WORKS AT ITS OWN PACE, MAKE SURE CORES DO NOT GET TOO FAR AHEAD OF THE REST.

1) USER LEVEL THREADS

• JHXAKXAJKX

• IN USER MODE , A PROCESS OR THREAD IS EXECUTING INSTRUCTIONS IN THE PROGRAM OR LINKED LIBRARY.

• THEY ARE NOT MAKING ANY CALLS TO THE OPERATING SYSTEM KERNEL.

• IN KERNEL MODE , THE PROCESS OR THREAD IS MAKING SYSTEM CALLS SUCH AS ACCESSING RESOURCES OR THROWING EXCEPTIONS. ALSO, IN KERNEL MODE, THE PROCESS OR THREAD CAN ACCESS OBJECTS THAT ARE DEFINED IN KERNEL SPACE.

• IN FIG, USER - LEVEL THREADS RESIDE IN USER SPACE OR MODE.

• THE LIBRARY SCHEDULER CHOOSES A THREAD FROM THE MULTIPLE THREADS OF A PROCESS, AND THAT THREAD IS ASSOCIATED WITH THE ONE KERNEL THREAD ALLOWED FOR THAT PROCESS.

• THAT KERNEL THREAD WILL BE ASSIGNED TO A PROCESSOR CORE BY THE OPERATING SYSTEM SCHEDULER.

• USER -LEVEL THREADS ARE CONSIDERED A “ MANY - TO - ONE ” THREAD MAPPING.

• KERNEL - LEVEL THREADS RESIDE IN KERNEL SPACE AND ARE KERNEL OBJECTS

• WITH KERNEL THREADS, EACH USER THREAD IS MAPPED TO OR BOUND TO A KERNEL THREAD TILL IT GETS TERMINATED.

• THIS IS CALLED A “ ONE - TO - ONE ” THREAD MAPPING.

• THE OPERATING SYSTEM SCHEDULER MANAGES, SCHEDULES,

AND DISPATCHES THESE THREADS.

• THE RUNTIME LIBRARY REQUESTS A KERNEL - LEVEL THREAD FOR EACH OF THE USER – LEVEL THREADS.

PROCESS CONTEXT

• THE OPERATING SYSTEM MANAGES THE EXECUTION OF MANY PROCESSES.

• WHEN ONE PROCESS IS REMOVED FROM A CORE AND ANOTHER PROCESS BECOMES ACTIVE, A CONTEXT SWITCH TAKES PLACE BETWEEN THOSE PROCESSES.

• OS KEEPS TRACK OF THE INFORMATION ABOUT THE PROCESSES I.E. WHICH PROCESS NEEDS TO BE RESTARTED, WHICH SHOULD BE NEWLY EXECUTED, ETC.

• THIS INFORMATION IS CALLED AS A “CONTEXT”.

• CONTEXT DESCRIBES THE PRESENT STATE OF A PROCESS.

• CONTEXT TAKES MANY SYSTEM RESOURCES TO SWITCH FROM ONE PROCESS TO OTHER.

THREAD CONTEXT COND…

• CONTEXT OF PROCESS INCLUDES:

• PROCESS ID

• POINTER TO EXECUTABLE THE STACK

• MEMORY FOR VARIABLES

• PROCESS REGISTERS

• THREADS ALSO HAVE A CONTEXT.

• THREADS OF SAME PROCESS SHARE THE SAME ADDRESS SPACE

• THREADS HAVE THEIR OWN UNIQUE, LOCAL INFORMATION LIKE:• THREAD ID, WHEN IT IS CREATED

• PROCESS REGISTERS (E.G. PROGRAM COUNTER, STACK POINTER)

• STATE AND PRIORITY OF THREAD

• THREAD -SPECIFIC DATA LIKE PRIVATE COPIES OF A PROCESS’S GLOBAL DATA.

PROCESS AND THREAD CONTEXT

HARDWARE AND SOFTWARE THREADS

• THREADS CAN BE IMPLEMENTED IN H/W AS WELL AS IN S/W.

• CORES WITH MULTIPLE HARDWARE THREADS ARE CALLED “SIMULTANEOUS MULTITHREADED (SMT)CORES”.

• SMT – ENABLED PROCESSORS EXECUTE MANY SOFTWARE THREADS OR PROCESSES CONCURRENTLY.

• DUE TO THAT, EFFICIENCY INCREASES DUE TO LESS WAIT TIME FOR I/O.

• EXAMPLES: SUN’S ULTRASPARC T1, IBM’S CELL BROADBAND ENGINE CBE, AND VARIOUS INTEL MULTICORE PROCESSORS.

• THEY UTILIZE SMT OR CHIP - LEVEL MULTITHREADING (CMT), HAVING 2 TO 8 THREADS PER CORE.

THREAD RESOURCES• THREADS SHARE MOST OF THEIR RESOURCES

LIKE PROCESSORS, MEMORY, AND FILE DESCRIPTORS WITH OTHER THREADS OF THE SAME PROCESS.

• THREADS OF THE SAME PROCESS COMPETE THESE DESCRIPTORS.

• ALL THE RESOURCES OF PEER THREADS IN COMBINATION MUST NOT EXCEED THE RESOURCE LIMIT OF THE PROCESS.

• A THREAD SHOULD NOT LEAVE THE RESOURCES UNSTABLE.

• IT SHOULD PERFORM SOME CLEANUP.

SOME ISSUES: COMPARING THREADS TO PROCESSES

1) CONTEXT SWITCHING:

• WITH LOW PROCESSOR AVAILABILITY OR A SINGLE CORE, CONCURRENTLY EXECUTING PROCESSES INVOLVE HEAVY OVERHEAD BECAUSE OF THE CONTEXT SWITCHING REQUIRED.

• BUT WITH THREADS, CONTEXT SWITCH OCCURS, WHEN THE THREAD OF DIFFERENT PROCESS IS THE NEXT THREAD TO BE ASSIGNED TO PROCESSOR.

2) THROUGHPUT:

• INCREASES WITH MULTIPLE THREADS.

• PROCESS WITH ONE THREAD CAN HALT ENTIRE PROCESS, IF THE THREAD WAITS FOR I/O REQUEST.

• PROCESS WITH MULTIPLE THREADS DOES NOT HALT THE ENTIRE PROCESS, AS ONE OF THE THREADS WAITS FOR I/O REQUEST, OTHER THREADS WORK.

3) COMMUNICATION:

• THREADS DON’T REQUIRE A SPECIAL MECHANISM FOR COMMUNICATION.

• CAN DIRECTLY PASS AND RECEIVE DATA FROM OTHER PEER THREADS.

• CAN COMMUNICATE BY USING MEMORY WHICH IS SHARED WITHIN THE ADDRESS SPACE OF PROCESS.

• PROCESSES CAN COMMUNICATE BY SHARED MEMORY WHICH EXISTS OUTSIDE THE ADDRESS SPACES OF THE PROCESSES.

• MESSAGE QUEUE USED TO COMMUNICATE BETWEEN THEM.

4) CORRUPTED PROCESS DATA:

• SYNCHRONIZATION OF THREADS IS NEEDED, OTHERWISE WHEN THREADS CAN CORRUPT THE DATA EASILY WHEN THEY SHARE THE SAME ADDRESS.

• ACCESS TO SAME PIECE OF DATA CAN CAUSE DATA RACE.

• PROCESSES HAVE THEIR OWN ADDRESS SPACES, WHICH PROTECT THE DATA FROM CORRUPTION.

5) REUSE BY OTHER PROGRAMS:

• THREADS ARE DEPENDENT , AND CAN NOT BE SEPARATED FROM THEIR PROCESSES.

• PROCESSES ARE MORE INDEPENDENT.

• AN APPLICATION IS DIVIDED INTO VARIOUS PROCESSES AND THOSE CAN BE PACKAGED INTO MODULES TO REUSE.

• THREADS CAN’T EXIST OUTSIDE PROCESS, SO CAN’T BE REUSED.

SIMILARITIES BETWEEN THREADS AND PROCESSES

• BOTH HAVE AN ID, SET OF REGISTERS, STATE, PRIORITY, AND SCHEDULING POLICY.

• BOTH HAVE ATTRIBUTES THAT DESCRIBE THE ENTITY TO THE OS.

• BOTH HAVE AN INFORMATION BLOCK.

• BOTH SHARE RESOURCES WITH THE PARENT PROCESS.

• BOTH FUNCTION AS INDEPENDENT ENTITIES FROM THE PARENT PROCESS.

• THE CREATOR CAN EXERCISE SOME CONTROL OVER THE THREAD OR PROCESS.

• BOTH CAN CHANGE THEIR ATTRIBUTES.

• BOTH CAN CREATE NEW RESOURCES.

• NEITHER CAN ACCESS THE RESOURCES OF ANOTHER PROCESS DIRECTLY.

DIFFERENCES BETWEEN THREADS AND PROCESSES

• THREADS SHARE THE ADDRESS SPACE OF THE CREATOR; PROCESSES HAVE THEIR OWN ADDRESS SPACE.

• THREADS HAVE DIRECT ACCESS TO THE DATA SEGMENT OF THEIR PROCESS; PROCESSES HAVE THEIR OWN COPY OF THE DATA SEGMENT OF THE PARENT PROCESS.

• THREADS CAN DIRECTLY COMMUNICATE WITH OTHER THREADS OF THEIR PROCESS; PROCESSES MUST USE INTER-PROCESS COMMUNICATION TO COMMUNICATE WITH SIBLING PROCESSES.

• THREADS HAVE ALMOST NO OVERHEAD; PROCESSES HAVE CONSIDERABLE OVERHEAD.

• NEW THREADS ARE EASILY CREATED; NEW PROCESSES REQUIRE DUPLICATION OF THE PARENT PROCESS.

• THREADS CAN MONITOR CONTROL OVER THREADS OF THE SAME PROCESS; PROCESSES CAN MONITOR CONTROL ONLY OVER CHILD PROCESSES.

• CHANGES TO THE MAIN THREAD (CANCELLATION, PRIORITY CHANGE, AND SO ON) MAY AFFECT THE BEHAVIOUR OF THE OTHER THREADS OF THE PROCESS; CHANGES TO THE

PARENT PROCESS DO NOT AFFECT CHILD PROCESSES.

THREAD ATTRIBUTES• THREADS HAVE THEIR OWN ATTRIBUTES.

• THOSE ATTRIBUTES GIVES THE UNIQUE IDENTITY TO EACH THREAD.

• THE ATTRIBUTES CAN RECONSTRUCT THREAD’S ENVIRONMENT.

• FOLLOWING ATTRIBUTES ARE THERE:

• CONTENTION SCOPE

• STACK SIZE

• STACK ADDRESS

• DETACHED STATE

• PRIORITY

• SCHEDULING POLICY AND PARAMETERS

• POSIX THREAD LIBRARY DEFINES THREAD ATTRIBUTE OBJECT TO ENCAPSULATE THE SUBSET OF THE PROPERTIES.

THREAD ATTRIBUTE OBJECT:

• IT ENCAPSULATES THE SUBSET OF THE PROPERTIES OF A THREAD.

• IT IS ASSOCIATED WITH ONE OR MULTIPLE THREADS.

• IT IS A PROFILE THAT GIVES BEHAVIOR OF ONE OR GROUP OF THREADS.

• IT SHOULD BE CREATED AND INITIALIZED.

• ONCE CREATED AND INITIALIZED, WE CAN REFERENCE IT REPEATEDLY IN THREADS CREATION FUNCTION CALL.

• WHEN A THREAD IS CREATED USING THIS OBJECT, MOST ATTRIBUTES CAN’T BE CHANGED WHILE THREAD IS IN USE.

1) CONTENTION SCOPE:

• “SCOPE” DESCRIBES THAT WHICH THREAD OUT OF MANY, COMPETE WITH FOR RESOURCES.

• TWO CONTENTION SCOPES:

• PROCESS SCOPE

• SYSTEM SCOPE

PROCESS SCOPE:

• THREADS COMPETE WITH OTHER THREADS FOR PROCESSOR USAGE.

• THREADS COMPETE WITH OTHER THREADS WITHIN THE SAME PROCESS.

SYSTEM SCOPE:

• THREADS COMPETE FOR RESOURCES WITH THE THREADS OF OTHER PROCESSES ALLOCATED ACROSS THE SYSTEM.

• THREAD WITH SYSTEM SCOPE IS PRIORITIZED WITH RESPECT TO ALL OTHER SYSTEMWIDE THREADS.

2) STACK SIZE:

• EACH THREAD’S STACK SIZE AND LOCATION IS SET WHEN IT IS CREATED.

• IF NOT SPECIFIED, THEN DEFAULT STACK SIZE AND LOCATION IS ASSIGNED BY SYSTEM WHICH IS SYSTEM DEPENDENT.

• THREAD’S STACK SIZE MUST BE LARGE ENOUGH FOR ANY FUNCTION CALLS, FOR ANY EXTERNAL CODE LIKE LIBRARY CODE, LOCAL VARIABLE STORAGE, ETC.

• A PROCESS SHOULD HAVE STACK SEGMENT LARGE ENOUGH FOR ALL THREAD’S STACK.

• THE LOCATION OF A THREAD DOES NOT OVERLAP OTHER PEER THREAD’S STACKS.

3) DETACHED STATE:

• THESE THREADS ARE DETACHED FROM THEIR CREATOR.

• THEY ARE NOT SYNCHRONIZED WITH OTHER PEER THREADS OR THE PRIMARY THREAD.

• WHEN A THREAD TERMINATES, THE ID AND THE STATUS OF THE TERMINATED THREAD ARE SAVED BY THE SYSTEM, THE CREATOR IS NOTIFIED.

• THESE RESOURCES ARE IMMEDIATELY AVAILABLE FOR REUSE BY THE SYSTEM.

4) SCHEDULING POLICIES AND PARAMETERS:

• THE THREADS INHERIT SCHEDULING ATTRIBUTES FROM THE PROCESS.

• THE THREAD WITH THE HIGHEST PRIORITY IS EXECUTED BEFORE THREADS WITH LOWER PRIORITY.

• EXECUTING THREADS ARE PREEMPTED IF A THREAD OF HIGHER PRIORITY IS AVAILABLE.

• FIFO, ROUND ROBIN (RR), AND OTHER SCHEDULING POLICIES ARE AVAILABLE.

ARCHITECTURE OF A THREAD

THREADS STATES:

• RUNNABLE

• RUNNING

• STOPPED

• SLEEPING(BLOCKED)

SCHEDULING AND THREAD CONTENTION SCOPE

• THERE ARE TWO TYPES OF CONTENTION SCOPES FOR THREADS:

• PROCESS CONTENTION

• SYSTEM CONTENTION

• SCHEDULING POLICY AND PRIORITY:

1) A ROUND - ROBIN SCHEDULING POLICY:

• IT CONSIDERS ALL THREADS TO BE OF EQUAL PRIORITY, AND EACH THREAD IS GIVEN THE PROCESSOR FOR ONLY A TIME SLICE.

2) FIFO SCHEDULING:

• A THREAD WITH HIGH PRIORITY ASSIGNED TO A PROCESSOR

DOMINATES THE PROCESSOR UNTIL IT COMPLETES EXECUTION.

• THIS SCHEDULING POLICY CAN BE USED FOR APPLICATIONS WHERE A SET OF THREADS NEEDS TO COMPLETE AS SOON AS POSSIBLE.

3) THE “ OTHER ” SCHEDULING POLICY CAN BE A CUSTOMIZATION OF A SCHEDULING POLICY.

SHARED MEMORY AND DISTRIBUTED MEMORY

Shared Memory Environment

Distributed Memory Environment

POSIX THREADS(PORTABLE OPERATING SYSTEM INTERFACE)

• IT IS A STANDARD FOR UNIX-LIKE OPERATING SYSTEMS—FOR EXAMPLE, LINUX, MAC OS X, SOLARIS, HPUX.

• IT SPECIFIES AN APPLICATION PROGRAMMING INTERFACE (API) FOR MULTITHREADED PROGRAMMING.

• LIKE MPI, PTHREADS SPECIFIES A LIBRARY THAT CAN BE LINKED WITH C PROGRAMS.

A SIMPLE THREADED PROGRAMUSING NAMSPACE STD;

#INCLUDE < IOSTREAM >

#INCLUDE < PTHREAD.H >

VOID *TASK1(VOID *X) //DEFINE TASK TO BE EXECUTED BY THREADA

{

COUT < < “THREAD A COMPLETE” < < ENDL;

RETURN (NULL);

}

VOID *TASK2(VOID *X) //DEFINE TASK TO BE EXECUTED BY THREADB

{

COUT < < “THREAD B COMPLETE” < < ENDL;

RETURN (NULL);

}

INT MAIN(INT ARGC, CHAR *ARGV[ ])

{

PTHREAD_T THREADA, THREADB; // DECLARE THREADS

PTHREAD_CREATE( & THREADA, NULL, TASK1, NULL); // CREATE THREADS

PTHREAD_CREATE( & THREADB, NULL, TASK2, NULL);

// ADDITIONAL PROCESSING

PTHREAD_JOIN(THREADA, NULL); // WAIT FOR THREADS

PTHREAD_JOIN(THREADB, NULL);

RETURN (0); }

HOW TO COMPILE AND EXECUTE ?COMPILE:

G++ -O A.OUT TEST_THREAD.CPP –LPTHREAD

OR

G++ TEST_THREAD.CPP –LPTHREAD

RUN:

./A.OUT 2

OUTPUT:

THREAD A COMPLETE

THREAD B COMPLETE

1) INT PTHREAD_CREATE(

PTHREAD_T* THREAD_P,

CONST PTHREAD_ATTR_T* ATTR_P,

VOID* (*START_ROUTINE)(VOID*),

VOID* ARG_P);

• FIRST ARGUMENT IS POINTER TO PTHREAD_T OBJECT I.E. EACH THREAD.

• SECOND ARG. WE ARE NOT USING SO NULL.

• THIRD ARG. IS A FUNCTION THAT THE THREAD IS TO RUN.

• LAST ARG. IS POINTER TO THE ARGUMENT THAT IS PASSED TO FUNCTION THE THREAD IS RUNNING.

2) VOID * THREAD_FUNCTION(VOID * ARG_P);

• VOID*CAN POINT TO ANY POINTER TYPE IN C.

• ARG_P CAN POINT TO A LIST CONTAINING ONE OR MORE VALUES.

• SIMILARLY, RETURN TYPE OF FUNCTION CAN POINT TO A LIST CONTAINING ONE OR MORE VALUES.

the “master” thread

starting a thread

Is called forking

terminating a thread

Is called joining

•Second argument is used to receive any value computed by the thread.•Each thread executes return statement and eventually, main thread will call pthread_join().

INT PTHREAD_JOIN (PTHREAD_T THREAD, VOID** RET_VAL_P);

• THE FUNCTION FAILS IF THE TARGET THREAD IS NOT A JOINABLE THREAD OR DETACHED.

• IF TARGET THREAD RETURNS SUCCESSFULLY, ITS EXIT STATUS STORED IN RET_VAL_P.

PASSING ARGUMENTS TO MAIN()

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

SIMPLE PROGRAM

OUTPUT

FOR EXAMPLE, TO RUN THE PROGRAM WITH ONE THREAD, WE TYPE

$ ./PTH HELLO 1

AND THE OUTPUT WILL LOOK SOMETHING LIKE THIS:

HELLO FROM THE MAIN THREAD

HELLO FROM THREAD 0 OF 1

TO RUN THE PROGRAM WITH FOUR THREADS, WE TYPE

$ ./PTH HELLO 4

AND THE OUTPUT WILL LOOK SOMETHING LIKE THIS:

HELLO FROM THE MAIN THREAD

HELLO FROM THREAD 0 OF 4

HELLO FROM THREAD 1 OF 4

HELLO FROM THREAD 2 OF 4

HELLO FROM THREAD 3 OF 4

MATRIX - VECTOR MULTIPLICATION

The dot product of ith row and each element of x:y[i] =

Here, only row no. changes and not the column nos.

1

0

][*]][[n

j

jxjia

Assume ,m=n=6, and t (no. of threads =3)

So, computation divided into, 3 threads as mentioned above.

• TO COMPUTE FIRST AND LAST COMPONENT I.E.INDEX FOR EACH THREAD:

FIRST COMPONENT=Q*M/T

LAST COMPONENT=(Q+1)*(M/T)-1

WHERE, Q=THREAD NO., M=NO.OF ROWS, T=TOTAL NO.OF THREADS.

• SO, THE FUNCTION FOR EACH THREAD WILL BE:

GETTING THREAD IDS:

SYNTAX:

#INCLUDE < PTHREAD.H >

PTHREAD_T PTHREAD_SELF(VOID);

• WHEN A THREAD IS CREATED, THE THREAD ID IS RETURNED TO THE CALLING THREAD

E.G.

PTHREAD_T THREADID;

THREADID = PTHREAD_SELF();

COMPARING THREAD IDS:

SYNTAX:

#INCLUDE < PTHREAD.H >

INT PTHREAD_EQUAL(PTHREAD_T TID1, PTHREAD_T TID2);

• FUNCTION RETURNS A NONZERO VALUE, IF TWO THREAD IDS REFERENCE THE SAME THREAD,

• ELSE IT RETURNS ZERO VALUE.

USING PTHREAD ATTRIBUTE OBJECT

• “PTHREAD_ATTR_T” OBJECT CAN BE USED TO SET FOLLOWING THREAD ATTRIBUTES:

• SIZE OF THE THREAD ’ S STACK

• LOCATION OF THE THREAD ’ S STACK

• SCHEDULING INHERITANCE, POLICY, AND PARAMETERS

• WHETHER THE THREAD IS DETACHED OR JOINABLE

• SCOPE OF THE THREAD

•First function initializes a thread attribute object with default values for all attributes.

•Second function deletes any hidden storage associated with the thread attribute object.

CREATING DETACHED THREADS

• WHEN THREAD EXITS, SYSTEM STORES THREAD’S COMPLETION STATUS AND ID , WHEN IT JOINS OTHER THREAD.

• BUT, WHEN AN EXITING THREAD IS NOT JOINED WITH OTHER THREAD, THE EXITING THREAD IS CALLED A DETACHED THREAD.

“detachstate” parameter can have two values:

1) PTHREAD_CRTEATE_DETACHED2) PTHREAD_CRTEATE_JOINABLE

MANAGING THREADS

• MANAGING OPERATION CONSISTS OF :

• HOW TO CONTROL ANY THREAD BEHAVIOUR

• HOW THEY COMPETE FOR RESOURCES

• HOW TO SET AND MANAGE SCHEDULING POLICY AND PRIORITY

1) TERMINATING THREAD:

• THREAD TERMINATES EITHER• COMES AT THE END OF INSTRUCTION IN THE

ROUTINE

• TERMINATED BY ANOTHER THREAD PREMATURELY

• EFFECT OF THREAD TERMINATION:

• PTHREAD LIBRARY RECLAIMS SYSTEM RESOURCES.

• STORES IT’S EXIT STATUS

• THREE TYPES OF THREAD TERMINATION:

• SELF TERMINATION

• TERMINATING PEER THREADS

• CANCELLED BY ANOTHER PROCESS.

• SELF TERMINATION:

SYNRAX:

#INCLUDE < PTHREAD.H >

INT PTHREAD_EXIT(VOID *VALUE_PTR); //SELF TERMINATION• TERMINATING PEER THREADS:

#INCLUDE < PTHREAD.H >

INT PTHREAD_CANCEL(PTHREAD_T THREAD); // “THREAD” PARAMETER IS THE THREAD TO BE CANCELLED

• CANCELLED BY ANOTHER PROCESS:- IT IS A REQUEST TO CANCEL A THREAD.

#INCLUDE < PTHREAD.H >

INT PTHREAD_SETCANCELSTATE(INT STATE, INT *OLDSTATE);

INT PTHREAD_SETCANCELTYPE(INT TYPE, INT *OLDTYPE);

• THE CANCEL TYPE AND CANCEL STATE OF THE TARGET THREAD DETERMINES WHEN CANCELLATION ACTUALLY TAKES PLACE.

• THE CANCELABILITY STATE DESCRIBES THE CANCEL CONDITION OF A THREAD AS BEING “CANCELABLE OR UNCANCELABLE .”

• A THREAD ’ S CANCELABILITY TYPE DETERMINES THE THREAD ’ S ABILITY TO CONTINUE AFTER A CANCEL REQUEST.

• PTHREAD_SETCANCELSTATE() SETS THE CALLING THREAD TO THE CANCELABILITY STATE SPECIFIED BY STATE AND RETURNS THE PREVIOUS STATE IN OLDSTATE .

• PTHREAD_SETCANCELTYPE() SETS THE CALLING THREAD TO THE CANCELABILITY TYPE SPECIFIED BY TYPE AND RETURNS THE PREVIOUS STATE IN OLDTYPE .

• VALUES OF STATE AND OLDSTATE ARE:

PTHREAD_CANCEL_DISABLE

PTHREAD_CANCEL_ENABLE

THANK YOU!!