chapter 3:Process concept Flashcards

Question

(22)Process Creation (Cont.)

Answer 1

Address space * Child duplicate of parent * Child has a program loaded into it UNIX examples * fork() system call creates new process * exec() system call used after a fork() to replace the process’ memory space with a new program

Answer 2

Process executes last statement and asks the operating system to delete it **(exit())** * Output data from child to parent (via **wait())** * Process’ resources are deallocated by operating system Parent may terminate execution of children processes (abort()) * Child has exceeded allocated resources * Task assigned to child is no longer required * If parent is exiting Some operating systems do not allow child to continue if its parent terminates All children terminated - **cascading termination** Wait for termination, returning the pid: **pid t pid; int status; pid = wait(&status); ** If no parent waiting, then terminated process is a **zombie** If parent terminated, processes are **orphans**

Answer 3

Many web browsers ran as single process (some still do) * If one web site causes trouble, entire browser can hang or crash Google Chrome Browser is multiprocess with 3 categories **Browser** process manages user interface, disk and network I/O **Renderer** process renders web pages, deals with HTML, Javascript, new one for each website opened * Runs in **sandbox** restricting disk and network I/O, minimizing effect of security exploits **Plug-in** process for each type of plug-in

Answer 4

Processes within a system may be ***independent*** or ***cooperating*** Cooperating process can affect or be affected by other processes, including sharing data Reasons for cooperating processes: Information sharing Computation speedup Modularity Convenience Cooperating processes need **interprocess communication (IPC)** Two models of IPC * **Shared memory** * **Message passing**

Answer 5

***Independent*** process cannot affect or be affected by the execution of another process ***Cooperating*** process can affect or be affected by the execution of another process Advantages of process cooperation * Information sharing * Computation speed-up * Modularity * Convenience

Answer 6

Paradigm for cooperating processes, producer process produces information that is consumed by a consumer process * **unbounded-buffer** places no practical limit on the size of the buffer * **bounded-buffer** assumes that there is a fixed buffer size

Answer 7

Shared data #define BUFFER\_SIZE 10 typedef struct { . . . } item; item buffer[BUFFER\_SIZE]; int in = 0; int out = 0; Solution is correct, but can only use BUFFER\_SIZE-1 elements

Answer 8

item next produced; while (true) { /\* produce an item in next produced \*/ while (((in + 1) % BUFFER SIZE) == out) ; /\* do nothing \*/ buffer[in] = next produced; in = (in + 1) % BUFFER SIZE; }

Answer 9

item next consumed; while (true) { while (in == out) ; /\* do nothing \*/ next consumed = buffer[out]; out = (out + 1) % BUFFER SIZE; /\* consume the item in next consumed \*/ }

Answer 10

Mechanism for processes to communicate and to synchronize their actions Message system – processes communicate with each other without resorting to shared variables IPC facility provides two operations: * **send**(message) – message size fixed or variable * **receive**(message) If P and Q wish to communicate, they need to: * establish a **communication link** between them * exchange messages via send/receive Implementation of communication link * physical (e.g., shared memory, hardware bus) * logical (e.g., direct or indirect, synchronous or asynchronous, automatic or explicit buffering)

Answer 11

How are links established? Can a link be associated with more than two processes? How many links can there be between every pair of communicating processes? What is the capacity of a link? Is the size of a message that the link can accommodate fixed or variable? Is a link unidirectional or bi-directional?

Answer 12

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 of communication link * 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

Answer 13

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

Answer 14

Operations create a new mailbox send and receive messages through mailbox destroy a mailbox Primitives are defined as: * *send**(A, message) – send a message to mailbox A * *receive**(A, message) – receive a message from mailbox A

Answer 15

Mailbox sharing * P1, P2, and P3 share mailbox A * P1, sends; P2 and P3 receive * Who gets the message? Solutions * Allow a link to be associated with at most two processes * Allow only one process at a time to execute a receive operation * Allow the system to select arbitrarily the receiver. Sender is notified who the receiver was.

Answer 16

Message passing may be either blocking or non-blocking **Blocking** is considered **synchronous** * **Blocking send** has the sender block until the message is received * **Blocking receive** has the receiver block until a message is available **Non-blocking** is considered **asynchronous** **Non-blocking** send has the sender send the message and continue **Non-blocking** receive has the receiver receive a valid message or null }

Answer 17

Different combinations possible * If both send and receive are blocking, we have a rendezvous Producer-consumer becomes trivial message next produced; while (true) { /\* produce an item in next produced \*/ send(next produced); } message next consumed; while (true) { receive(next consumed); /\* consume the item in next consumed \*/ }

Answer 18

Queue of messages attached to the link; implemented in one of three ways 1. Zero capacity – 0 messages 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

Answer 19

POSIX Shared Memory Process first creates shared memory segment **shm\_fd = shm\_open(name, O CREAT | O RDRW, 0666);** Also used to open an existing segment to share it Set the size of the object **ftruncate(shm fd, 4096); ** Now the process could write to the shared memory ** sprintf(shared memory, "Writing to shared memory");**

Answer 20

Mach communication is message based Even system calls are messages Each task gets two mailboxes at creation- Kernel and Notify Only three system calls needed for message transfer ** msg\_send(), msg\_receive(), msg\_rpc()** Mailboxes needed for commuication, created via ** port\_allocate()** Send and receive are flexible, for example four options if mailbox full: 1. Wait indefinitely 2. Wait at most n milliseconds 3. Return immediately 4. Temporarily cache a message

Answer 21

Message-passing centric via **advanced local procedure call (LPC)** facility Only works between processes on the same system Uses ports (like mailboxes) to establish and maintain communication channels Communication works as follows: * The client opens a handle to the subsystem’s **connection port** object. * The client sends a connection request. * The server creates two private **communication ports** and returns the handle to one of them to the client. * The client and server use the corresponding port handle to send messages or callbacks and to listen for replies.

Answer 22

Sockets Remote Procedure Calls Pipes Remote Method Invocation (Java)

Answer 23

A **socket** is defined as an endpoint for communication Concatenation of IP address and **port** – a number included at start of message packet to differentiate network services on a host The socket **161.25.19.8:1625** refers to port **1625** on host **161.25.19.8** Communication consists between a pair of sockets All ports below 1024 are ***well known***, used for standard services Special IP address 127.0.0.1 (**loopback**) to refer to system on which process is running

Answer 24

Three types of sockets * **Connection-oriented (TCP)** * **Connectionless (UDP)** * **MulticastSocket** class– data can be sent to multiple recipients Consider this “Date” server:

Answer 25

Remote procedure call (RPC) abstracts procedure calls between processes on networked systems * Again uses ports for service differentiation **Stubs** – client-side proxy for the actual procedure on the server The client-side stub locates the server and **marshalls** the parameters The server-side stub receives this message, unpacks the marshalled parameters, and performs the procedure on the server On Windows, stub code compile from specification written in **Microsoft Interface Definition Language (MIDL)** Data representation handled via **External Data Representation (XDL)** format to account for different architectures * **Big-endian** and **little-endian** Remote communication has more failure scenarios than local Messages can be delivered **exactly once** rather than **at most once** OS typically provides a rendezvous (or **matchmaker**) service to connect client and server

Answer 26

Acts as a conduit allowing two processes to communicate **Issues** * Is communication unidirectional or bidirectional? * In the case of two-way communication, is it half or full-duplex? * Must there exist a relationship (i.e. parent-child) between the communicating processes? * Can the pipes be used over a network?

Answer 27

Ordinary Pipes allow communication in standard producer-consumer style Producer writes to one end (the **write-end** of the pipe) Consumer reads from the other end (the **read-end** of the pipe) Ordinary pipes are therefore unidirectional Require parent-child relationship between communicating processes Windows calls these **anonymous pipes** See Unix and Windows code samples in textbook Windows calls these anonymous pipes See Unix and Windows code samples in textbook

Answer 28

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