Operating Systems

Implicit Threading

Dr. Elangovan G
Associate Professor
Department of Artificial Intelligence and Data Science
Koneru Lakshmaiah Education Foundation
(Deemed to be University)
Green fields, Vaddeswaram, AP-522502, India

Session : 12
 Implicit Threading
• Thread Pools
• Fork-Join
• OpenMP
• Grand Central Dispatch
• Intel Threading Building Blocks
• Threading Issues
• Signal Handling
• Thread Cancellation
• Thread-Local Storage
• Scheduler Activations
• Operating System Examples
8/24/2022 Operating Systems - CO2 2
 Implicit Threading
• Growing in popularity as numbers of threads increase, program
correctness more difficult with explicit threads
• Creation and management of threads done by compilers and run-
time libraries rather than programmers
• Five methods explored
– Thread Pools
– Fork-Join
– OpenMP
– Grand Central Dispatch
– Intel Threading Building Blocks
8/24/2022 Operating Systems - CO2 3
 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
– Separating task to be performed from mechanics of creating task
allows different strategies for running task
• i.e,Tasks could be scheduled to run periodically
• Windows API supports thread pools:

8/24/2022 Operating Systems - CO2 4

 Java Thread Pools
• Three factory methods for creating thread pools in Executors
class:

8/24/2022 Operating Systems - CO2 5

 Java Thread Pools (Cont.)

8/24/2022 Operating Systems - CO2 6

 Fork-Join Parallelism
• Multiple threads (tasks) are forked, and then joined.

8/24/2022 Operating Systems - CO2 7

 Fork-Join Parallelism
• General algorithm for fork-join strategy:

8/24/2022 Operating Systems - CO2 8

 Fork-Join Parallelism

8/24/2022 Operating Systems - CO2 9

 Fork-Join Parallelism in Java

8/24/2022 Operating Systems - CO2 10

 Fork-Join Parallelism in Java

8/24/2022 Operating Systems - CO2 11

 Fork-Join Parallelism in Java
• The ForkJoinTask is an abstract base class
• RecursiveTask and RecursiveAction classes extend
ForkJoinTask
• RecursiveTask returns a result (via the return value from the compute()
method)
• RecursiveAction does not return a result

8/24/2022 Operating Systems - CO2 12

 OpenMP
• Set of compiler directives and
an API for C, C++, FORTRAN
• Provides support for parallel
programming in shared-
memory environments
• Identifies parallel regions –
blocks of code that can run in
parallel
#pragma omp parallel
Create as many threads as there
are cores
8/24/2022 Operating Systems - CO2 13
 OpenMP
• Run the for loop in parallel

8/24/2022 Operating Systems - CO2 14

 Grand Central Dispatch
• Apple technology for macOS and iOS operating systems
• Extensions to C, C++ and Objective-C languages, API, and run-
time library
• Allows identification of parallel sections
• Manages most of the details of threading
• Block is in “^{ }” :

ˆ{ printf("I am a block"); }

• Blocks placed in dispatch queue

– Assigned to available thread in thread pool when removed from queue
8/24/2022 Operating Systems - CO2 15
 Grand Central Dispatch
• Two types of dispatch queues:
– serial – blocks removed in FIFO order, queue is per process,
called main queue
• Programmers can create additional serial queues within program
– concurrent – removed in FIFO order but several may be removed
at a time
• Four system wide queues divided by quality of service:
o QOS_CLASS_USER_INTERACTIVE
o QOS_CLASS_USER_INITIATED
o QOS_CLASS_USER_UTILITY
o QOS_CLASS_USER_BACKGROUND
8/24/2022 Operating Systems - CO2 16
 Grand Central Dispatch
• For the Swift language a task is defined as a closure – similar to
a block, minus the caret
• Closures are submitted to the queue using the
dispatch_async() function:

8/24/2022 Operating Systems - CO2 17

 Intel Threading Building Blocks (TBB)
• Template library for designing parallel C++ programs
• A serial version of a simple for loop

• The same for loop written using TBB with parallel_for

statement:

8/24/2022 Operating Systems - CO2 18

 Threading Issues
• Semantics of fork() and exec() system calls
• Signal handling
– Synchronous and asynchronous
• Thread cancellation of target thread
– Asynchronous or deferred
• Thread-local storage
• Scheduler Activations

8/24/2022 Operating Systems - CO2 19

 Semantics of fork() and exec()
• Does fork()duplicate only the calling thread or all
threads?
– Some UNIXes have two versions of fork
• exec() usually works as normal – replace the
running process including all threads

8/24/2022 Operating Systems - CO2 20

 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
• Signal is generated by particular event
• Signal is delivered to a process
• Signal is handled by one of two signal handlers:
• default
• user-defined
• Every signal has default handler that kernel runs when handling
signal
• User-defined signal handler can override default
• For single-threaded, signal delivered to process
8/24/2022 Operating Systems - CO2 21
 Signal Handling (Cont.)
• Where should a signal be delivered for multi-
threaded?
–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
8/24/2022
the process Operating Systems - CO2 22
 Thread Cancellation
• Terminating a thread before it has finished
• Thread to be canceled is target thread
• Two general approaches:
– Asynchronous cancellation terminates the target thread immediately
– Deferred cancellation allows the target thread to periodically check if
it should be cancelled
• Pthread code to create and cancel a thread:

8/24/2022 Operating Systems - CO2 23

 Thread Cancellation (Cont.)
• Invoking thread cancellation requests cancellation, but actual
cancellation depends on thread state

• If thread has cancellation disabled, cancellation remains pending until

thread enables it
• Default type is deferred
– Cancellation only occurs when thread reaches cancellation point
• i.e., pthread_testcancel()
• Then cleanup handler is invoked
• On Linux systems, thread cancellation is handled through signals
8/24/2022 Operating Systems - CO2 24
 Thread Cancellation in Java
• Deferred cancellation uses the interrupt() method,
which sets the interrupted status of a thread.

• A thread can then check to see if it has been interrupted:

8/24/2022 Operating Systems - CO2 25

 Thread-Local Storage
• Thread-local storage (TLS) 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)
• Different from local variables
• Local variables visible only during single function invocation
• TLS visible across function invocations
• Similar to static data
• TLS is unique to each thread
8/24/2022 Operating Systems - CO2 26
 Scheduler Activations
• Both M:M and Two-level models require
communication to maintain the appropriate
number of kernel threads allocated to the
application
• Typically use an intermediate data structure
between user and kernel threads – lightweight
process (LWP)
– Appears to be a virtual processor on which process can
schedule user thread to run
– Each LWP attached to kernel thread
– How many LWPs to create?
• Scheduler activations provide upcalls - a
communication mechanism from the kernel to the
upcall handler in the thread library
• This communication allows an application to
maintain the correct number kernel threads
8/24/2022 Operating Systems - CO2 27
 Operating System Examples
• Windows Threads
• Linux Threads

8/24/2022 Operating Systems - CO2 28

 Windows Threads
• Windows API – primary API for Windows applications
• Implements the one-to-one mapping, kernel-level
• Each thread contains
– A thread id
– Register set representing state of processor
– Separate user and kernel stacks for when thread runs in user mode or
kernel mode
– Private data storage area used by run-time libraries and dynamic link
libraries (DLLs)
• The register set, stacks, and private storage area are known as the
context of the thread
8/24/2022 Operating Systems - CO2 29
 Windows Threads (Cont.)
• The primary data structures of a thread include:
– ETHREAD (executive thread block) – includes pointer to
process to which thread belongs and to KTHREAD, in kernel
space
– KTHREAD (kernel thread block) – scheduling and
synchronization info, kernel-mode stack, pointer to TEB, in
kernel space
– TEB (thread environment block) – thread id, user-mode
stack, thread-local storage, in user space
8/24/2022 Operating Systems - CO2 30
 Windows Threads Data Structures

8/24/2022 Operating Systems - CO2 31

 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)
– Flags control behavior

• struct task_struct points to process data structures

(shared or unique)
8/24/2022 Operating Systems - CO2 32
 Implicit Threading
✓Thread Pools
✓Fork-Join
✓OpenMP
✓Grand Central Dispatch
✓Intel Threading Building Blocks
✓Threading Issues
✓Signal Handling
✓Thread Cancellation
✓Thread-Local Storage
✓Scheduler Activations
✓Operating System Examples
8/24/2022 Operating Systems - CO2 33