Core inter process communication mechanisms historically important
Download
1 / 23

Core Inter-Process Communication Mechanisms (Historically Important) - PowerPoint PPT Presentation


  • 136 Views
  • Uploaded on

Core Inter-Process Communication Mechanisms (Historically Important). Fred Kuhns (fredk@arl.wustl.edu, http://www.arl.wustl.edu/~fredk) Department of Computer Science and Engineering Washington University in St. Louis. Cooperating Processes.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Core Inter-Process Communication Mechanisms (Historically Important)' - yamal


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Core inter process communication mechanisms historically important l.jpg

Core Inter-Process Communication Mechanisms(Historically Important)

Fred Kuhns

(fredk@arl.wustl.edu, http://www.arl.wustl.edu/~fredk)

Department of Computer Science and Engineering

Washington University in St. Louis


Cooperating processes l.jpg
Cooperating Processes

  • 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

  • Dangers of process cooperation

    • Data corruption, deadlocks, increased complexity

    • Requires processes to synchronize their processing

CS422 – Operating Systems Concepts


Purposes for ipc l.jpg
Purposes for IPC

  • Data Transfer

  • Sharing Data

  • Event notification

  • Resource Sharing and Synchronization

  • Process Control

CS422 – Operating Systems Concepts


Ipc mechanisms l.jpg
IPC Mechanisms

  • Mechanisms used for communication and synchronization

    • Message Passing

      • message passing interfaces, mailboxes and message queues

      • sockets, STREAMS, pipes

    • Shared Memory: Non-message passing systems

  • Common examples of IPC

    • Synchronization using primitives such as semaphores to higher level mechanisms such as monitors. Implemented using either shared memoru or message passing.

    • Debugging

    • Event Notification - UNIX signals

  • We will defer a detailed discussion of synchronization mechanisms and concurrency until a later class

  • Here we want to focus on some common (and fundamental) IPC and event notification mechanisms

CS422 – Operating Systems Concepts


Message passing l.jpg
Message Passing

  • In a Message passing system there are no shared variables. IPC facility provides two operations for fixed or variable sized message:

    • send(message)

    • receive(message)

  • If processes P and Q wish to communicate, they need to:

    • establish a communicationlink

    • exchange messages via send and receive

  • Implementation of communication link

    • physical (e.g., shared memory, hardware bus)

    • logical (e.g., syntax and semantics, abstractions)

CS422 – Operating Systems Concepts


Implementation questions l.jpg
Implementation Questions

  • How are links established?

  • Can a link be associated with more than two processes?

  • How are links made known to processes?

  • How many links can there be between every pair/group 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?

CS422 – Operating Systems Concepts


Message passing systems l.jpg
Message Passing Systems

  • Exchange messages over a communication link

  • Methods for implementing the communication link and primitives (send/receive):

    • Direct or Indirect communications (Naming)

    • Symmetric or Asymmetric communications

    • Automatic or Explicit buffering

    • Send-by-copy or send-by-reference

    • fixed or variable sized messages

CS422 – Operating Systems Concepts


Direct communication internet and sockets l.jpg
Direct Communication – Internet and Sockets

  • Processes must name each other explicitly:

    • Symmetric Addressing

      • send (P, message) – send to process P

      • receive(Q, message) – receive from Q

    • Asymmetric Addressing

      • send (P, message) – send to process P

      • receive(id, message) – rx from any; system sets id = sender

  • Primitives:

    • send(A, message) – send a message to mailbox A

    • receive(A, message) – receive a message from mailbox A

  • Properties of communication link

    • Links established automatically between pairs

    • processes must know each others ID

    • Exactly one link per pair of communicating processes

  • Disadvantage: a process must know the name or ID of the process(es) it wishes to communicate with

CS422 – Operating Systems Concepts


Indirect communication pipes l.jpg
Indirect Communication - Pipes

  • Messages are sent to or 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 more than 2 processes.

    • Each pair of processes may share several communication links.

  • Ownership:

    • process owns (i.e. mailbox is implemented in user space): only the owner may receive messages through this mailbox. Other processes may only send. When process terminates any “owned” mailboxes are destroyed.

    • system owns – then mechanisms provided to create, delete, send and receive through mailboxes. Process that creates mailbox owns it (and so may receive through it) but may transfer ownership to another process.

CS422 – Operating Systems Concepts


Indirect communication l.jpg
Indirect Communication

  • Mailbox sharing:

    • P1, P2, andP3 share mailbox A.

    • P1, sends; P2andP3 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

CS422 – Operating Systems Concepts


Synchronizing message flow l.jpg
Synchronizing Message Flow

  • Message passing may be either blocking or non-blocking.

    • blocking send: sender blocked until message received by mailbox or process

    • nonblocking send: sender resumes operation immediately after sending

    • blocking receive: receiver blocks until a message is available

    • nonblocking receive: receiver returns immediately with either a valid or null message.

CS422 – Operating Systems Concepts


Buffering l.jpg
Buffering

  • All messaging system require framework to temporarily buffer messages. These queues are implemented in one of three ways:

    • Zero capacity – No messages may be queued within the link, requires sender to block until receives retrieves message.

    • Bounded capacity – Link has finite number of message buffers. If no buffers are available then sender must block until one is freed up.

    • Unbounded capacity – Link has unlimited buffer space, consequently send never needs to block.

CS422 – Operating Systems Concepts


Lets get practical l.jpg
Lets Get Practical

Notes to help you with the first project

CS422 – Operating Systems Concepts


Conventional view l.jpg
Conventional View

Protection domains - (virtual address space)

user

process 2

process n

process 1

kernel

How can processes communicate with each

other and the kernel?

CS422 – Operating Systems Concepts


Universal ipc facilities l.jpg

process 1

pipe

Universal IPC Facilities

handler

user

process 2

dbx

kernel

stop

handle event

  • Universal Facilities in UNIX

    • Signals - asynchronous or synchronous event notification.

    • Pipes - unidirectional, FIFO, unstructured data stream.

    • Process tracing - used by debuggers to control control target process

CS422 – Operating Systems Concepts


Signals overview l.jpg
Signals Overview

  • Divided into asynchronous (CTL-C) and synchronous (illegal address)

  • Three phases to processing signals:

    • generation: event occurs requiring process notification

    • delivery: process recognizes and takes appropriate action

    • pending: between generation and delivery

  • SVR4 and 4.4BSD define 31 signals, original had 15. Some commercial system support > 32.

  • Signal to integer mappings differ between BSD and System V implementations

CS422 – Operating Systems Concepts


Signals virtual machine model l.jpg

System call interface

{read(), write(), sigaltstack() … }

Signals - Virtual Machine Model

signal handler

stack

Process X

(Signal handles)

instruction set

register handlers

dispatch to handler

kernel

(restartable system calls)

deliver signal

I/O facilities

filesystem

scheduler

CS422 – Operating Systems Concepts


Actions l.jpg
Actions

  • Handling, default actions

    • Abort: terminate process, generate core dump

    • Exit: terminate without generating core dump

    • Ignore: ignore signal

    • Stop: suspend process

    • Continue: resume process

  • User specified actions

    • Default action,

    • Ignore signal,

    • Catch signal - invoke user specified signal handler

  • User may

    • not ignore, catch or block SIGKILL and SIGSTOP

    • change action at any time

    • block signal: signal remains pending until unblocked

CS422 – Operating Systems Concepts


Signal generation l.jpg
Signal Generation

  • Exceptions - kernel notifies process with signal

  • Other Process - using kill or sigsend.

  • Terminal interrupts - stty allows binding of signals to specific keys, sent to foreground process

  • Job control - background processes attempt to read/write to terminal. Process terminate or suspends, kernels sends signal to parent

  • Quotas - exceeding limits

  • Notifications - event notification (device ready)

  • Alarms - process notified of alarm via signal reception

CS422 – Operating Systems Concepts


Reliable signals bsd l.jpg
Reliable Signals - BSD

  • Persistent handlers

  • Masking signals

    • signals masked (blocked) temporarily

    • user can specify mask set for each signal

    • current signal is masked when handler invoked

  • Interruptible sleeps

  • Restartable system calls

  • Allocate separate stack for handling signals

    • why is this important?

CS422 – Operating Systems Concepts


Signals a few details l.jpg
Signals - A Few Details

  • Any process or interrupt can post a signal

    • set bit in pending signal bit mask

    • perform default action or setup for delivery

  • Signal typically delivered in context of receiving process.

    • exception is sending SIGSTOP, kernel may perform action directly

    • Pending signals are checked before returning to user mode and just before/after certain sleep calls.

    • Produce core dump or invoke signal handler

CS422 – Operating Systems Concepts


Unix pipes l.jpg
UNIX Pipes

  • Unidirectional, FIFO, unstructured data stream

  • Fixed maximum size

  • Simple flow control

  • pipe() system call creates two file descriptors. Why?

  • Implemented using filesystem, sockets or STREAMS (bidirectional pipe).

  • Named Pipes:

    • Lives in the filesystem - that is, a file is created of type S_IFIFO (use mknod() or mkfifo())

    • may be accessed by unrelated processes

    • persistent

    • less secure than regular Pipes. Why?

CS422 – Operating Systems Concepts


Process tracing l.jpg
Process Tracing

  • ptrace()

  • used by debuggers such as dbx and gdb.

  • Parent process controls execution of child

    • child must notify kernel that it will be traced by parent

  • Modern systems use the /proc file system.

    • Allows process to trace unrelated processes

CS422 – Operating Systems Concepts