The Qnet protocol extends interprocess communication (IPC) transparently over a network of microkernels. This is done by taking advantage of the QNX Neutrino RTOS's message-passing paradigm. Message passing is the central theme of QNX Neutrino that manages a group of cooperating processes by routing messages. This enhances the efficiency of all transactions among all processes throughout the system.
As we found out in the “How does it work?” section, many POSIX and other function calls are built on this message passing. For example, the write() function is built on the MsgSendv() function. In this section, you'll find several things, such as how Qnet works at the message-passing level, how node names are resolved to node numbers, and how such a number is used to create a connection to a remote node.
In order to understand how message passing works, consider two processes that wish to communicate with each other: a client process and a server process. First we consider a single-node case, where both client and server reside in the same machine. In this case, the client simply creates a connection (via ConnectAttach()) to the server, and then sends a message (perhaps via MsgSend()).
The Qnet protocol extends this message passing over to a network. For
example, consider the case of a simple network with two machines: one
contains the client process, the other contains the server process. The
code required for client-server communication is identical (it uses the same API)
to the code
in the single-node case. The client creates a connection to the server
and sends the server a message. The only difference in the network case
is that the client specifies a different node descriptor for the
ConnectAttach() function call in order to indicate the server's node.
See the diagram below to understand how message passing works.
