M6: Threads and Concurrency Control - Managing Multiple Tasks at the Same Time

Question 1

Open file descriptor table:

Answer 1

contains all the files that have been opened by a

process; stored in the PCB

Question 2

Page table:

Answer 2

contains all the mappings from virtual to physical address space;
a pointer to the page table is stored in the process PCB

Question 3

Thread

Answer 3

created within a process;
enables splitting an executing program into multiple simultaneously or pseudo-simultaneously running tasks to keep the CPU cores busy by having them run in parallel;
each thread has its own execution context, though the heap memory, static data segment, and code segment of the virtual memory, as well as the open files, are shared with the process

Question 4

Thread table:

Answer 4

stores the execution context of the threads, which includes the thread processor registers, stack pointer, program counter, MMU, general registers, and stack memory segments

Question 5

Thread pool:

Answer 5

where you pre-create a number of threads in the system, and what you do is whenever a client comes in, you take one of the idle threads to service the client; after the client request has been serviced, then the thread is returned to the pool and it’s available for servicing future clients

Question 6

Thread affinity:

Answer 6

CPU cores have caches and in multicore systems, if threads keep getting run on the same core, then their data will be more likely to be cached; thus, threads should always run on a specific core

Question 7

User level threads:

Answer 7

the thread library is located in user space; the OS does is not aware of the threads

Question 8

Kernel level threads:

Answer 8

the thread library is located in kernel space; each

thread is handled and scheduled individually

Question 9

Virtual dynamic shared objects

Answer 9

allows user space to handle certain kernel space routines, to reduce the need for context switching; memory allocated in user space

Question 10

Concurrency control:

Answer 10

managing the interleaved execution of multiple

processes that access the same shared states, to produce the correct results

Question 11

Race conditions

Answer 11

two or more threads or processes attempt to access and update the same data at the same time; the result of a computation depends on the exact timing of the multiple processes or threads being executed

Question 12

Synchronization

Answer 12

implementing coordination between processes

Question 13

Critical section:

Answer 13

a portion of code that involves an access or

modification of shared state

Question 14

Mutual exclusion

Answer 14

enforcing that only one process is in any given

critical section at a time

Question 15

Progress :

Answer 15

if no process is currently in the critical section, and at least one process wants to enter it, some process will eventually be able to enter

If no process is executing in its critical section and
some processes want to enter their corresponding
critical sections, then
1. Only those processes that are waiting to enter
can participate in the competition (to enter
their critical sections) and no other processes
can influence this decision.
2. This decision cannot be postponed indefinitely
(i.e., finite decision time). Thus, one of the
waiting processes can enter its critical section.

Question 16

Bounded waiting

Answer 16

a process that is waiting in line to enter the critical
section will not be waiting indefinitely, and is guaranteed to have an opportunity to enter

 After a process made a request to enter its
critical section and before it is granted the
permission to enter, there exists a bound on
the number of turns that other processes are
allowed to enter.

Question 17

Busy-wait:

Answer 17

a loop checking the same condition repeatedly; the process busy-waiting cannot proceed until the condition becomes true; consumes CPU resources inefficiently

Question 18

Disabling interrupts:

Answer 18

an overly powerful approach to implementing
synchronization that prevents the OS from performing all context switches, which are caused by interrupts
In case of multicore would need to disable interrupts for all CPUs

Question 19

Atomic statements:

Answer 19

the compiler can translate such a statement to one line

of assembly language, thus making this an uninterruptible statement

Question 20

Deadlock

Answer 20

processes are waiting for each other, such that none of them can proceed

Question 21

For what is Process Abstraction useful

Answer 21

The process abstraction allows the operating system to track and switch between many running processes.

Question 22

What is stored per Thread in Thread Table

Answer 22

PC
SP
Stack
Global
Registers
MMU

Question 23

Difference between pthread_exit and return

Answer 23

If pthread_exit is called in main, the main thread terminates, while other threads (if any) will continue. This is different from calling return or exit from main, where all other threads will also be terminated.

Question 24

Aspects a solution to handle a Critical Section must have

Answer 24

• Mutual Exclusion
• Progress -> no Deadlock
• Bounded Waiting -> no Starvation

Question 25

Roles of processes

Answer 25

1. Container of resources: memory/open files, isolation of one process from another
2. Execution context: bookmark for process, i.o. to resume later/context switch

Question 26

If at no time two processes are in a critical section simultaneously, would there be race conditions?

Answer 26

No

Question 27

Impact of Disabling Interrupts

Answer 27

Avoids race conditions. However clock interrupt is also turned off and therefore scheduler cannot be invoked.
Hence, all process are blocked, also the ones that do not want to enter Critical Section.