Getting Started with QNX Neutrino - QNX Software Systems

© 2009, QNX Software Systems GmbH & Co. KG. Network-distributed message passing
Network-distributed message passing
Suppose we want to change our example above to talk to a different node on the
network. You might think that we’ll have to invoke special function calls to “get
networked.” Here’s the network version’s code:
#include
#include
int
main (void)
{
int
fd;
fd = open ("/net/wintermute/home/rk/filename", O_WRONLY);
write (fd, "This is message passing\n", 24);
close (fd);
return (EXIT_SUCCESS);
What it means for you
}
You’re right if you think the code is almost the same in both versions. It is.
In a traditional OS, the C library open() calls into the kernel, which looks at the
filename and says “oops, this is on a different node.” The kernel then calls into the
network filesystem (NFS) code, which figures out where
/net/wintermute/home/rk/filename actually is. Then, NFS calls into the
network driver and sends a message to the kernel on node wintermute, which then
repeats the process that we described in our original example. Note that in this case,
there are really two filesystems involved; one is the NFS client filesystem, and one is
the remote filesystem. Unfortunately, depending on the implementation of the remote
filesystem and NFS, certain operations may not work as expected (e.g., file locking)
due to incompatibilities.
Under Neutrino, the C library open() creates the same message that it would have sent
to the local filesystem and sends it to the filesystem on node wintermute. In the local
and remote cases, the exact same filesystem is used.
This is another fundamental characteristic of Neutrino: network-distributed operations
are essentially “free,” as the work to decouple the functionality requirements of the
clients from the services provided by the servers is already done, by virtue of message
passing.
On a traditional kernel there’s a “double standard” where local services are
implemented one way, and remote (network) services are implemented in a totally
different way.
Message passing is elegant and network-distributed. So what? What does it buy you,
the programmer?
Well, it means that your programs inherit those characteristics — they too can become
network-distributed with far less work than on other systems. But the benefit that I
find most useful is that they let you test software in a nice, modular manner.
April 30, 2009 Chapter 2 • Message Passing 85