Concurrency

Question 1

What is multiprogramming?

Answer 1

It is the concurrent execution of multiple processes (tasks) on one CPU.

Question 2

Does each task run knowing there are other tasks running with them?

Answer 2

No, each task runs as if they are the only task running on the CPU

Question 3

What are the benefits of multiprogramming?

Answer 3

Increased efficiency: when one task is waiting for the I/O, another task can use the CPU so the processor can switch to another task.
The main goal of multiprogramming is to make use of the CPU time.

Question 4

What does a Python web-server do in terms of multiprogramming?

Answer 4

It handles web requests and creates/generates jobs.

Question 5

What does a multi-process C job-server do?

Answer 5

It processes the jobs in parallel. Then, workers in the job server compete to get jobs to process.

Question 6

How does the web-server and job-server communicate?

Answer 6

They communicate through the file system.

Question 7

What is the term when two processes attempt to get the same job?

Answer 7

Race condition

Question 8

How many workers can get the job?

Answer 8

Only one.

Question 9

Is it better to have two workers complete the same job or only one worker succeed in getting the job?

Answer 9

Only one worker getting and completing the job is better.

Question 10

Describe the architecture of a web application.

Answer 10

From the web browser, the user submits a HTTP get request, which is sent to the web-server (Python). The created list of jobs (files) are sent to the dick, which passes the jobs to the job-server (C). The workers in the job-server will look for jobs (files) on the disk and process them.

Question 11

If a worker finds a job that meets all the criteria, how does it secure the job so that no one else works on it?

Answer 11

The worker renames the filename by appending a “locked” to the front.

Question 12

Can renaming fail? Describe what happens.

Answer 12

Yes. If worker 1 and 2 both found the same file and worker 1 finished renaming first. When worker 2 tries to rename it, it will fail. This is racing condition because multiple processes are trying to access the same resources.

Question 13

Define race condition.

Answer 13

It is a situation where concurrent operations access data in a way where the output depends on the order of the operations’ execution. Which process will execute first is not guaranteed.

Question 14

Why do we want to avoid racing condition?

Answer 14

Because it causes very nasty bugs in concurrent systems and is often overlooked by programmers assuming the order of execution does not affect the output.

Question 15

Is racing condition a bug?

Answer 15

No, but it can cause bugs and/or unexpected behaviour. For example, in the web-app example, because ultimately the job is done, so two workers fighting to lock a file is not a bug but part of the process.

Question 16

What is a process in OS-sense?

Answer 16

It is OS abstraction of what is needed to run a single program. It is also known as “heavyweight process” because we need pipes to communicate between processes.

Question 17

Describe the two parts of a process.

Answer 17

The passive part contains protected resources: code, data, files. The main memory state which is the contents of address space is also here. The I/O state are the file descriptors.

The active part contains: registers, PC, stack, and the thread. The thread represents some code executing.

Question 18

When we fork a process, what parts of the process are the same between the parent and child?

Answer 18

They have the same passive part. The active part differs depending on order of execution.

Question 19

What is a heavyweight process? What is a lightweight process?

Answer 19

A process is heavyweight. A thread is lightweight.

Question 20

What is multithreading?

Answer 20

It is a single program made up of different concurrent activities. In other words, one process with multiple threads where each thread is executing a different task. It is also called “multitasking”.

Question 21

Which part is shared across all thread? What about the other part?

Answer 21

The passive part is shared, so the content of memory (global variables, heap) and the I/O state (file descriptors, etc). Each thread has its own active part, so their own registers, stack, PC.

Question 22

Do threads still need pipes to exchange data?

Answer 22

No.

Question 23

Can racing condition still happen to threads? Give an example with I/O.

Answer 23

Yes. For example, if t1 and t2 both want to print to stdout, since I/O is shared and they are both accessing the same variable in RAM, this would be a racing condition.

Question 24

Process vs thread.

Answer 24

A process is a unit of ownership of resources. It owns all the threads under this process. It provides an execution context for the program. The resources it has include memory, I/O, console, etc. The process pretends like it is a single entity controlling the execution environment.

A thread is a single execution unit. It is a unit of scheduling. All threads of a process share the same memory space.

Question 25

What is IPC?

Answer 25

IPC stands for Inter Process Communication. It is mechanisms like pipes, shared memory, etc, used to communicate between processes. These are super fast but difficult to set up.

Question 26

How many threads are there in a process sharing how many physical CPUs? Describe the trend from the ancient time to now.

Answer 26

Ancient time: a process has one thread running on one CPU
Old days: a process had multiple threads running on one CPU
Now: a process has multiple threads running on multiple CPUs (multicore)

Question 27

How do we implement multithreading in code? Describe the brief flow.

Answer 27

Define the functions we want to execute concurrently.
Define one thread for each function with “pthread_t t1, t2, …;”
Start the concurrent execution by running “pthread_create(&t1, defaultAttribute, functionName, input );” for each thread.
The main thread waits for all the threads to finish by running “pthread_join(t1, defaultAttribute);” for each thread.

Question 28

If we define two threads t1 and t2, start the execution with pthread_create and wait for them to finish with pthread_join, how many threads do we have in total?

Answer 28

3. There is always a main thread.

Question 29

Instead of using pthread_join() to wait for the other threads, what else can the main thread do?

Answer 29

It can sleep while waiting. Use sleep(time);

Question 30

When we run pthread_create(&t1, …) for n threads, how do we determine which thread runs first?

Answer 30

We cannot. Who runs first is dependent on the system.

Question 31

If there is a global variable in the RAM and two threads are both trying to access and change its value, but one thread changes the value and the system switches to the other thread to print the value which does not reflect the change, what is this interruption of tasks called? What is a potential solution?

Answer 31

Context switching. Do not declare a global variable, keep the variable local in the thread.

Question 32

What is CRC?

Answer 32

CRC stands for cyclic redundancy check. It is used to identify error in data.

Question 33

Describe the active part in detail.

Answer 33

The active part holds the resources and components that change over time as the process runs.

CPU context includes PC, registers. The execution state includes the current state of the process, e.g. waiting, running, ready. It also tracks what the process is doing at any moment.