Question

I want to understand these IPC mechanism concepts in OS – Shared Memory, Message System, Sockets, RPC, RMI

How do different operating systems implement these. Specifically Android operating system?

Answer 1

IPC is inter-process communication mechanisms in OS is large discussion concept so, I think here we can’t cover all this,

Some Low Level stuff:

The IPC mechanism discussed here is at the lowest level—all other inter-CPU IPC mechanisms use it as the base. For example, a TCP/IP connection through the ARM11 processor to another processor ends up going through this IPC mechanism. Diagnostic messages are another example of messages that rely on this low-level IPC.

The IPC mechanism is implemented with two sides—a “client side,” which faces the kernel and provides a callback-based style of interface, and a “CPU side,” which provides the interface to the other CPUs.

• The CPU side is implemented as a shared-memory interface, with
  interrupts and a “doorbell” mechanism. At the highest level, to send
  messages from the ARM11 to another CPU, the message content is placed
  in a buffer in shared memory and a hardware port is tickled to
  indicate to the other CPU that data is available.

• In the reverse direction, the data is placed into shared memory by
  the other CPU and a hardware interrupt is triggered on the ARM11.
  This hardware interrupt causes the ARM11 to examine the shared
  memory’s buffer, retrieve the message and route it to the client.

But to more specific to Android:

IPC in android, It describes the mechanism how different types of android components are communicated.

Android implements a few key tools used to communicate with or coordinate between programs securely. These mechanisms give Android applications the ability to run processes in the background, offer services consumed by other applications, safely share relational data, start other programs, and reuse components from other applications safely.

• Much of the interprocess communication (IPC) that occurs on Android
  is done through the passing around of a data structures called
  Intents. These are collections of information that have a few
  expected properties the system can use to help figure out where to
  send an Intent if the developer wasn’t explicit. The Action property
  expresses what the Intent is for (the Intent.ACTION_VIEW action
  indicates that the data is to be displayed to the user, for example).
  The data property is an optional URI and could point to a file,
  contact, web page, phone number, and so on. Intents also potentially
  have a collection of key/value pairs called extras, as well as flags,
  components, and other more advanced features.

• Each of these IPC mechanisms uses Intents in some capacity and is
  probably somewhat familiar to most Android developers. However,
  because using these safely is key to Android security,

1) Intents are messages which components can send and receive. It is a universal mechanism of passing data between processes. With help of the intents one can start services or activities, invoke broadcast receivers and so on.

2) Bundles are entities the data is passed through. It is similar to the serialization of an object, but much faster on android. Bundle can be got from intent via the getExtras() method.

3) Binders are the entity which allows activities and services obtain a reference to another services. It allows not simply send messages to services but directly invoke methods on them.

For more info look at:

1. Grasping Android’s IPC mechanism

2. Android’s Securable IPC Mechanisms