slides06

Question 1

lightweight multi-processing

Answer 1

• multi tasks within an application implemented by separate threads
• cheaper/faster to create and faster to switch

Question 2

motivation for lightweight multi-processing

Answer 2

• process creation is heavyweight: application can be slowed down by process creation, termination and management overhead
• use process pools to reduce overhead of creation on demand
• thread creation is more lightweight
• threads simplify code (modularization) and increase efficiency

Question 3

processes vs threads

Answer 3

PROCESSES
- create a new address space at process creation
- allocate resources at creation
- need IPC to share data - each process has its own address space
- deeper isolation for security and fault tolerance

THREADS
- same address space
- quicker creation times
- sharing through shared memory
- fault sharing between all threads within a process

Question 4

disadvantages of threads

Answer 4

• threads don’t have the same fault tolerance as processes
• overheard for handing client request to a thread

Question 5

benefits of multithreading

Answer 5

1. responsiveness: allows for continued execution if part of process is blocked
2. resource sharing: threads come with shared memory (no need for creation)
3. economy: cheaper than process creation, thread switching has lower overhead than context switching
4. scalability: process can take advantage of multiprocess architecture

Question 6

paralellism

Answer 6

system can perform more than one task simultaneously

Question 7

types of paralellism in multi-core programming

Answer 7

1. data paralellism:
   -distributes subsets of data across mulitple cores, same operation on each set of data
   - three steps: splitting -> solving sub-problems -> combininh
2. task parallelism: distributing threads across cores, each thread performs a unique operation

Question 8

threading models

Answer 8

1. user-level threads
2. kernel-level threads
3. hybrid threads

Question 9

user-level threads

Answer 9

• many-to-one
• many user-level threads mapped to a single kernel thread
• one thread blocking causes all to block
• multiple threads cannot run in parallel in multi-core system because kernel level has one thread

Question 10

kernel-level threads

Answer 10

• one-to-one
• each user-level thread maps to a kernel thread
• more concurrency
• number of threads per process restricted due to overhead

Question 11

hybrid threads

Answer 11

• many-to-many
• many user lvl threads mapped to many kernel threads
  locality of mapping is a concern

Question 12

asynchronous threading

Answer 12

• parent spawns child thread
• parent resumes execution
• parent/child run concurrently and independently of one another
• share little data

Question 13

synchronous threading

Answer 13

• parent spawns child and waits for child to terminate
• children exchance data with each other but none with parent

Question 14

thread pools

Answer 14

• create a fix set of threads ahead of time
• select available thread within pool to serve the next request
• queue request if there are no free threads in the pool
• creation overhead reduced

Question 15

thread cancellation

Answer 15

• using pthread_cancel()
• deferred cancellation: target thread periodically checks whether it should terminate in an orderly manner