Operating Systems: Processes

Chapter 3: Processes

• Explores processes, process scheduling, operations, interprocess communication (IPC), IPC examples, and client-server communication.
• Introduces processes, their features (scheduling, creation, termination, communication), and client-server system communication.

Process Concept

• Specifies that an OS runs diverse programs, including:
  • Batch systems running jobs.
  • Time-shared systems running user programs or tasks.
• "Job" and "process" are used interchangeably.
• A process embodies a program in execution, progressing sequentially, and includes; a program counter, stack, and data section.

Process Memory

• Memory for process is segmented into:
  • Stack: Instructions may overflow.
  • Heap: Dynamic data, new parameters can be stored, writing to unallocated memory may cause segmentation faults.
  • Data: Is static
  • Text: Is file text
• Processes can crash without affecting the entire system.

Process State

• Processes transition through different states during execution; including
  • New: being created.
  • Running: instructions are executed.
  • Waiting: awaiting an event.
  • Ready: awaiting processor assignment.
  • Terminated: execution is complete.

Process Control Block (PCB)

• Contains process-specific information such as; state, program counter, CPU registers, scheduling data, and memory management info.
• Also holds accounting and I/O status.
• The PCB resides in protected memory, often at the kernel stack's beginning for safety.
  • Swapping slows computers and memory reduces swapping.
  • Caching does not use swapping.
  • Increased RAM increases batter usage, and needs a good configuration.

Process Scheduling Queues

• Job queue : a set of all processes in the system
• Ready queue: a set of processes residing in main memory as well as ready and waiting to execute
• Device queues: a set of processes waiting for an I/O device
• Processes shift queues but retain their memory location, transitioning between ready and device queues.

Schedulers

• Long-term (job) scheduler: selects processes for the ready queue.
• Short-term (CPU) scheduler: selects and allocates the CPU to the next process.
• The long-term scheduler manages multiprogramming degree.
• Processes are I/O-bound, spending more time on I/O with brief CPU bursts, or CPU-bound, spending more time on computations with long CPU bursts

CPU Context Switch

• Involves saving an old process's state and loading a new one, which introduces overhead as the system does no work during the switch.
• Context is represented in the PCB, and the time for context switching depends on hardware support.

Process Creation

• Happens when parent processes create child processes, forming a process tree in shared memory space.
• Processes are identified and managed via a process identifier (pid).
• Resource Sharing Options
  • Sharing all.
  • Subsets only.
  • No sharing.
• Execution Options
  • Parent and children execute concurrently.
  • Parent waits for children to terminate.
• Fork creates a duplicate child process and exec replaces a process’ memory space after a fork in UNIX.

Process Termination

• Occurs when a process executes its last statement, requesting OS deletion using "exit".
• The child process can output data to the parent using wait and resources are deallocated by the OS.
• Parents can terminate child execution using abort for; exceeding resources, task completion, or parent exiting.
  • Some OSs terminate children upon parent exit, referred to as cascading termination.

Interprocess Communication (IPC)

• Processes include independent or cooperating processes, with cooperation enabling data sharing.
• IPC involves; sharing data, speeding up computation, modularity, and offering convenience.
• IPC models use shared memory or message passing.

Cooperating Processes

• A process that cannot affect or be affected by another is independent.
• A cooperating processing can be affected by another.
• Process cooperation brings; information sharing, computation speed-up, modularity, and convenience.

Producer-Consumer Problem

• Cooperation paradigm where a Producer creates information to be consumed by a Consumer.
• Unbounded-buffer places no restriction on buffer size, whereas bounded-buffer assumes it.

Bounded-Buffer (Shared Memory)

• Employs shared data structures like buffer and variables for in/out management
• A fixed #define BUFFER_SIZE 10 where Solution only used BUFFER_SIZE - 1

Bounded Buffer Producer/Consumer

• In producer -> wait if no free buffers available, then add item to buffer.
• In consumer -> waits until an item is available, then removes item fro the buffer

Interprocess Communication - Message Passing

• Processes use actions to communicate and synchronise without shared variables.
• Interprocess Communication (IPC) provides operations to send(message) of a fixed or variable size and receive(message).
• If processes P and Q, seek communication, they must; establish a communication link and then exchange information.
• Implementation uses physical (shared memory, hardware bus) or logical properties, implementing direct or indirect, synchronous or asynchronous, and automatic or explicit buffering.

Implementation Questions

• Are links established?
• Can links be associated with more than two processes?
• How many links are there between process pars?
• What link capacity is there?
• Can the message be fixed or variable?
• Is the link unidirectional or bi-directional?

Direct Communication

• Processes explicitly name each other when exchanging messages.
  • send (P, message) sends to process P while receive(Q, message) receives from process Q.
• Communication links are established automatically between one pair, with links that may unidirection but are usually bi-directional

Indirect Communication

• Messages move between mailboxes or ports, which are special repositories; each mailbox has a unique id, processes only communicate if they have share a mailbox.
• send(A, message) sends to mailbox A, and receive(A, message) retrieves from A.
• Mailboxes link multiple senders and receivers, or one statically associated receiver known as a 'port'.
• Mailboxes are owned by the system and managed by a service.
• Links establish only with shared mailbox; links can involve multiple processes sharing several communication links, which can be unidirectional or bidirectional.

Indirect Communication

• Actions include creating, sending/receiving, and destroying.
• send(A, message) sends to mailbox A
• receive(A, message) retrieves from mailbox A
• To solve the problem of P1 sending, with P2 and P3 receiving, solutions include no more than two processes, one process at a time gets allowed actions, or sender gets notified.

Message Passing - Synchronization

• Can be Blocking (synchronous) or Non-Blocking(asynchronous)
• Blocking send: the sender blocks until a message is received
• Blocking receive : the receiver blocks until a message is available
• Non-blocking send: the sender sends the message and continue
• Non-blocking receive: A valid message OR a null message must be received

Buffering

• Queue of messages, implemented in three ways.
  • Zero capacity: sender waits for 0 messages(rendezvous)
  • Bounded capacity: if finite length N is full, sender must wait
  • Unbounded capacity: Sender never waits

IPC Examples (POSIX)

• POSIX shared memory actions include:
  • Process creates a shared memory segment.
  • Requester must attach.
  • Process writes to shared memory using sprintf(shared memory, "Writing to shared memory");
  • Process detaches via shmdt(shared memory);

IPC Examples (Mach)

• Communication is message based, including system calls.
• Tasks get kernel and notify mailboxes on creation.
• Three system calls are vital for message transfer: msg_send(), msg_receive(), msg_rpc()
• Mailboxes, which are created with port_allocate(), are core for general commuication.

IPC Examples (Windows XP)

• Message-centric passing based on local procedure call (LPC) that works on the same systems through ports.
• Communication runs by client:
  • Opens the subsystem's handle.
  • Sends request.
• The server:
• Creates comm ports.
• Returns a handle.
• Comm ports send messages with callbacks.

Communications in Client-Server Systems

• Client-server systems use; sockets, remote procedure calls, pipes, and remote method invocation (Java).

Sockets

• Generally used for Client-Server Systems.
• They are defined as a communication endpoint, and identified by IP address and port to be combined.
• 161.25.19.8:1625 specifies port 1625 on host 161.25.19.8.

Socket Communication

• Involves a server listening on a specified port, and a client requesting a connection and the server connects from the client.
• Well-known services have ports below 1024; Telnet uses 23, FTP uses 21, and HTTP uses 80.
• New processes accessing port 80 should create new ports with values > 1024.

Remote Procedure Calls (RPC)

• Protocol to remotely request a service without network configuration.
• Requires message-based communications between hosts to operate reliably.
• Every message is sent to a port.
  • RPCDaemon listens to a port and sends a function.
  • A function is code provided by the request on the remote system.
  • After the function, any output in a separate message.

Remote Procedure Calls - Stubs

• Stubs hide details for client communications.
• Remote procedures get separate stubs.
• Stubs look for ports or server using 'marshalling' to transmit.

Remote Procedure Calls - Issues

• Data rep can use 32-bit, big-endian, and little-endian solutions using External Data Representation (XDR).
• A network error is fixed when Action (ACK) is done, or messages are endlessly resent.

Pipes

• Pipes: a conduit for communication with potential issues of unidirectionality, bidirectionality (half or full-duplex), and parental relationship.
• Can pipes be used over a network?

Ordinary Pipes

• Ordinary pipes: Communication in standard producer-consumer style.
• Producers use the write-end and consumers use the read-end, making communication unidirectional and requiring a parent-child relation.

Named Pipes

• A named pipe uses increased power from ordinary pipes that's useful for two-way communication, without child/parent, for many processes and Windows/UNIX.