Lecture 4 - Multi-Threading

Question 1

Do most modern applications use multi-threading?

Answer 1

Yes.

Question 2

What’s the purpose of multiple threads within an application?

Answer 2

Multiple tasks can operate at the same time. (Like chrome browser)

Question 3

Why use threads rather than create a new process?

Answer 3

Process creating is heavy weight.
Thread creation is super light weight.
Simplify code, increase efficiency.

Question 4

What’s one advantage of processes over threads?

Answer 4

Processes are more isolated. If they crash, they don’t impact the other processes.

Question 5

Do threads share the same address space?

Answer 5

Yes.

Question 6

What do threads share?

Answer 6

The code, the data, and the files.

Question 7

What do threads not share?

Answer 7

Registers and Stacks.

Question 8

What are 4 benefits of threads?

Answer 8

1. Responsiveness: may allow continued execution if part of process is blocked, especially important for user interfaces.
2. Resource Sharing: threads share resources of process, easier than shared memory or message passing.
3. Economy: cheaper than process creation, thread switching lower overhead than context switching.
4. Scalability: process can take advantage of multiprocessor architectures

Question 9

What the challenge that multiprocessor systems put on programmers?

Answer 9

Dividing activities
Balance
Data slitting
Data dependency
Testing and debugging

Question 10

Define Parallelism.

Answer 10

Implies that a system can perform more than one task simultaneously.

Question 11

Define Concurrency.

Answer 11

Creating the illusion of parallelism with a single processor.

Question 12

Compare data parallelism vs task parallelism.

Answer 12

Data parallelism – distributes subsets of the same data across multiple cores, same operation on each.
Task parallelism – distributing threads across cores, each thread performing unique operation

Question 13

Define Amdahl’s Law

Answer 13

Identifies performance gains from adding additional cores to an application that has both serial and parallel portions
speedup <= 1/ (S+ (1-S)/N)

Resulting improvement from an enhancement is “limited” by the fraction of the task that can be improved.

Question 14

Explain what the Serial part and Parallel part of a process is.

Answer 14

Serial part = Can’t be threaded

Parallel = Can

Question 15

What’s the difference between User and Kernel threads?

Answer 15

User threads - management done by user-level threads library (GNU Pth), they are super fast.
Kernel threads - Supported by the Kernel (POSIX PThreads)

Question 16

Describe the Many-to-One multithreading model

Answer 16

Many user-level threads mapped to single kernel thread

One thread blocking causes all to block

Multiple threads may not run in parallel on multicore system because only one may be in kernel at a time

Used by few systems (Solaris Green, GNU Portable)

Question 17

What’s the best multi-threading model?

Answer 17

Many-to-Many

Question 18

Whats a Pthread? Is it user-level or kernel-level?

Answer 18

A Posix standard specification for threads (not implementation)
Can be both user and kernel-level.

Question 19

4 ways a thread terminates

Answer 19

A thread terminates for the following:

• The start() function performs a return
• Thread calls a pthread_exit() function
• Thread is cancelled using pthread_cancel()
• Any thread calls exit() or main thread returns

Question 20

How can you check if two threads are the same?

Answer 20

Compare their IDs with pthread_equal(pthread_t t1, pthread_t t2);

Question 21

How do we join a terminated thread?

Answer 21

pthread_join()

Question 22

Why do we need to use pthread_mutex_lock/unlock?

Answer 22

To protect shared variables. You have to use pthread_mutex_lock to lock the variables before accessing it to have exclusive variables. This enforces the other threads to wait for access. Otherwise the variables can become corrupt.

Question 23

What’s the difference between asynchronous cancellation and deferred cancellation for threads?

Answer 23

• Asynchronous cancellation: terminates the target thread immediately
• Deferred cancellation: allows the target thread to periodically check if it should be cancelled at cancellation points. (Best practice)

Question 24

4 Differences between Processes and Threads

Answer 24

Processes

• > Create a new address space at creation
• > Allocate resources at creation
• > Need IPC to share data
• > Deeper isolation for security and fault tolerance

Threads

• > Same address space
• > Quicker creation times –actual times depend on kernel versus user threads
• > Sharing through shared memory
• > Fault sharing between all threads within a process

Question 25

A application is 75% parallel and 25% serial. What’s the speedup that can be achieved by going from 1 to 2 cores?

Answer 25

1.6

Question 26

Describe a One-to-One multithreaded relationship

Answer 26

• > Each user-level thread maps to kernel thread
• > Creating a user-level thread creates a kernel thread
• > More concurrency than many-to-one
• > Number of threads per process sometimes restricted due to overhead
• > Examples: Windows, Linux, Solaris 9 and later

Question 27

Describe a Many-To-Many multithreading model

Answer 27

• > Allows many user level threads to be mapped to many kernel threads
• > Allows the operating system to create a sufficient number of kernel threads

Question 28

Define Thread library

+ 2 primary implementation methods

Answer 28

Provides programmer with API for creating and managing threads
Two primary ways of implementing
1. Library entirely in user space
2. Kernel-level library supported by the OS

Question 29

Does each thread have a specific stack?

Answer 29

Yes. This is the threads local storage.

Question 30

How do you create a pthread? Where does the thread continue? What about main?

Answer 30

int pthread_create(pthread_t *thread, const pthread_attr_t *atr, void (start) (void *), void *arg);

The thread continues at start()

The main continues after the statement.

Question 31

How can a thread optain its own id?

Answer 31

using pthread_self()

Question 32

What happens if you don’t join a thread that hasn’t been detached?

Answer 32

a “zombie” thread will be created.

Question 33

How do we detach a thread?
Why would we want to do this?
Is it possible to join a detached thread?

Answer 33

int pthread_detach(pthread_t thread);

Default –a thread is joinable –another thread is going to retrieve the return state

If no thread is interested in joining we need to detach the thread

No, it is not possible to join to a detached thread

Question 34

Define Fork-Join Parallelism in threads

Answer 34

Multiple threads (tasks) are forked, and then joined.

Question 35

What’s the purpose of Thread Attributes?

Answer 35

Attributes can be used to set properties of threads –such as detached

Question 36

Define Thread Cancellation

+ 2 general approaches

Answer 36

Terminating a thread before it has finished with
pthread_cancel(tid)

Asynchronous cancellation
-> terminates the target thread immediately
Deferred cancellation
-> allows the target thread to periodically check if it should be cancelled

Question 37

What are three modes threads can be in for cancellation? What’s the default type? How is thread cancellation handled in Linux?

Answer 37

Off
-> cancellation remains pending until thread enables it
Deferred (default)
-> cancellation only occurs when thread reaches cancellation point (thread_testcancel()), then cleanup handler is evoked
Asynchronous
-> thread cancelled immediately

Thread cancellation is handled through signals in Linux