Lecture 3 - Processes

Question 1

Can we associate a FIFO to more than two processes?

Answer 1

Yes.

Question 2

Process

Answer 2

A program in execution; process execution must progress in sequential fashion
Program becomes process when executable file loaded into memory.
One program can have multiple processes.

Question 3

5 parts of process

Answer 3

1. Text section (program code)
2. Current activity (program counter), processor registers
3. Stack containing temporary data (function parameters, return addresses, local variables)
4. Data section: global variables (initialized and unitialized)
5. Heap: memory dynamically allocated during run time

Question 4

5 states of process

Answer 4

1. New: The process is being created
2. Running: Instructions are being executed
3. Waiting: The process is waiting for some event to occur
4. Ready: The process is waiting to be assigned to a processor
5. Terminated: The process has finished execution

Question 5

Process Control Block (PCB)

Answer 5

Hold information associated with each process:
■Process state –running, waiting, etc
■Program counter –location of instruction to next execute
■CPU registers –contents of all process-centric registers
■CPU scheduling information-priorities, scheduling queue pointers
■Memory-management information –memory allocated to the process
■Accounting information –CPU used, clock time elapsed since start, time limits
■I/O status information –I/O devices allocated to process, list of open files

Question 6

Threads

Answer 6

Ability to run multiple processes within one program by having multiple program counters executing multiple locations at once. Need to store thread details in PCB.

Question 7

C structure to represent Process in Linux

Answer 7

task_struct:
pid t_pid; /* process identifier /
long state; / state of the process /
unsigned int time_slice / scheduling information */
struct task_struct parent;/ this process’s parent /
struct list_head children; / this process’s children */
struct files_struct files;/ list of open files */
struct mm_struct mm; / address space of this process */

Question 8

Main benefit of Process Scheduling

Answer 8

Maximize CPU use, quickly switch processes onto CPU core

Question 9

Role of Process Scheduler

Answer 9

Process scheduler selects among available processes for next execution on CPU core

Question 10

2 Scheduling Queues of processes

Answer 10

1. Ready queue –set of all processes residing in main memory, ready and waiting to execute
2. Wait queues –set of processes waiting for an event (i.e. I/O)

Question 11

CPU Context switch

Answer 11

When CPU switches to another process, the system must save the state of the old process and load the saved state for the new process

Question 12

Context of a process

Answer 12

Current state of process, represented in PCB

Question 13

What is context-switch overhead?

Answer 13

When the cpu switches between contexts, it does no useful work. The more complex the OS and the PCB, the longer the context switch.

Question 14

Why does context switch depend on hardware?

Answer 14

We could have cpus with multiple sets of registers, which allows multiople contexts to be loaded at once. Faster.

Question 15

Main difference between multitasking in IOS vs Android?

Answer 15

IOS is more limited on the background processes it can run, and has one main foreground process.

Android has both, but background processes uses a service to perform tasks, which can run even if background is suspended. The service has no ui and small memory use, which allows it to do more.

Question 16

2 main process operations

Answer 16

1. Creation

2. Termination

Question 17

process identifier (pid)

Answer 17

id assigned to a created process

Question 18

How does a tree of processes occur?

Answer 18

Parent creates children, which in turn can create other children

Question 19

3 Resource sharing options between Parent and Child process

Answer 19

1. Parent and children share all resources
2. Children share subset of parent’s resources
3. Parent and child share no resources

Question 20

2 Execution options between Parent and Child process

Answer 20

1. Parent and child can run concurrently

2. Parent waits for child to terminate

Question 21

Relationship between child and parent address space

Answer 21

Child duplicate of parent virtual address space, and changes in one don’t affect the other.

Question 22

fork() system call

Answer 22

creates child process (pid = 0) from parent process (pid > 0)

Question 23

exec() system call

Answer 23

replace the process’memory space with a new program

Question 24

wait() system call

Answer 24

The parent process may wait for termination of a child process by using the wait()system call. The call returns status information and the pid of the terminated process
pid = wait(&status);

Question 25

What happens when a process terminate?

Answer 25

Asks the operating system to delete it using the exit() system call. ● Returns status data from child to parent (via wait()) ● Process’resources are deallocated by operating system

Question 26

abort() function | + 3 reasons to use it

Answer 26

Parent may terminate the execution of children processes using the abort() system call: 1. Child has exceeded allocated resources. 2. Task assigned to child is no longer required. 3. The parent is exiting and the operating systems does not allow a child to continue if its parent terminates.

Question 27

Cascading (process) termination

Answer 27

Some operating systems do not allow child to exists if its parent has terminated. If a process terminates, then all its children must also be terminated.

Question 28

zombie process

Answer 28

If no parent waiting (did not invoke wait()) process is a zombie

Question 29

orphan process

Answer 29

If parent terminated without invoking wait(), process is an orphan

Question 30

Android Process Importance Hierarchy

Answer 30

``` Foreground process Visible process Service process Background process Empty process ```

Question 31

Problem with running web browser as single process

Answer 31

If one web site causes trouble, entire browser can hang or crash

Question 32

Cooperating process | + 4 reasons

Answer 32

``` Can affect or be affected by other processes, including sharing data: ●Information sharing ●Computation speedup ●Modularity ●Convenience ```

Question 33

``` Interprocess communication (IPC) + 2 Models ```

Answer 33

Method by which processes cooperate: 1. Shared memory (same memory block) 2. Memory passing (through message queue)

Question 34

Independent Process

Answer 34

Cannot affect or be affected by the execution of another process

Question 35

unbounded-buffer

Answer 35

Places no practical limit on the size of the buffer between producer and consumer

Question 36

bounded-buffer

Answer 36

Assumes that there is a fixed buffer size between producer and consumer

Question 37

``` Shared Memory (Interprocess Communication) + Major issue ```

Answer 37

An area of memory shared among the processes that wish to communicate. The communication is under the control of the users processes not the operating system. Major issues is to provide mechanism that will allow the user processes to synchronize their actions when they access shared memory.

Question 38

Message Passing

Answer 38

Mechanism for processes to communicate and to synchronize their actions. Message system –processes communicate with each other without resorting to shared variables.

Question 39

2. IPC functions for Message passing

Answer 39

●send(message) | ●receive(message)

Question 40

Communication link

Answer 40

Connection between process P and Q in message passing

Question 41

Is the size of a message that the link can accommodate fixed or variable?

Answer 41

either fixed or varible

Question 42

Implementation of communication link (Message Passing): 3 Physical 3 Logical

Answer 42

Physical • Shared memory • Hardware bus • Network Logical • Direct or indirect • Synchronous or asynchronous • Automatic or explicit buffering

Question 43

Direct Communication | + 4 Properties

Answer 43

Processes must name each other explicitly: ●send(P, message) –send a message to process P ●receive(Q, message) –receive a message from process Q Properties ●Links are established automatically ●A link is associated with exactly one pair of communicating processes ●Between each pair there exists exactly one link ●The link may be unidirectional, but is usually bi-directional

Question 44

Indirect Communication | + 4 properties

Answer 44

Messages are directed and received from mailboxes (also referred to as ports) ●Each mailbox has a unique id ●Processes can communicate only if they share a mailbox Properties of communication link ●Link established only if processes share a common mailbox ●A link may be associated with many processes ●Each pair of processes may share several communication links ●Link may be unidirectional or bi-directional

Question 45

3 Indirect Communication Operations | + Send and receive function arguments

Answer 45

1. create a new mailbox (port) 2. send and receive messages through mailbox 3. destroy a mailbox Primitives are defined as: send(A, message) –send a message to mailbox A receive(A, message) –receive a message from mailbox

Question 46

Blocking (Message Passing) | + 2 functions

Answer 46

Blocking is considered synchronous ●Blocking send --the sender is blocked until the message is received ●Blocking receive --the receiver is blocked until a message is available

Question 47

Non-blocking (Message Passing) | + 2 functions

Answer 47

Non-blocking is considered asynchronous ●Non-blocking send--the sender sends the message and continue ●Non-blocking receive--the receiver receives: ●A valid message, or ●Null message

Question 48

Rendezvous (Message Passing Synchronization)

Answer 48

If both send and receive are blocking, we have a rendezvous

Question 49

Buffering | + 3 Implementation methods

Answer 49

1. Zero capacity –no messages are queued on a link. Sender must wait for receiver (rendezvous) 2. Bounded capacity –finite length of n messages. Sender must wait if link full 3. Unbounded capacity –infinite length. Sender never waits

Question 50

Function to create Shared Memory in POSIX

Answer 50

shm_fd = shm_open(name, O CREAT | O RDWR, 0666);

Question 51

Set the size of the object in POSIX Shared Memory

Answer 51

ftruncate(shm_fd, 4096);

Question 52

mmap()

Answer 52

``` Use mmap() to memory-map a file pointer to the shared memory object. Reading and writing to shared memory is done by using the pointer returned by mmap(). ```

Question 53

Pipes

Answer 53

Acts as a conduit allowing two processes to communicate

Question 54

Ordinary pipes

Answer 54

Cannot be accessed from outside the process that created it. Typically, a parent process creates a pipe and uses it to communicate with a child process that it created. ■ Producer writes to one end (the write-end of the pipe) ■Consumer reads from the other end (the read-endof the pipe) ■Ordinary pipes are therefore unidirectional Windows calls these anonymous pipes

Question 55

Named pipes

Answer 55

Named Pipes are more powerful than ordinary pipes ■Communication is bidirectional ■No parent-child relationship is necessary between the communicating processes ■Several processes can use the named pipe for communication ■Provided on both UNIX and Windows systems