Getting Started with QNX Neutrino - QNX Software Systems

© 2009, QNX Software Systems GmbH & Co. KG. Pulses
Function Send buffer Receive buffer
MsgSendv() IOV IOV
MsgSendvnc() IOV IOV
Implementation
By “linear,” I mean a single buffer of type void * is passed, along with its length.
The easy way to remember this is that the “v” stands for “vector,” and is in the same
place as the appropriate parameter — first or second, referring to “send” or “receive,”
respectively.
Hmmm. . . looks like the MsgSendsv() and MsgSendsvnc() functions are identical,
doesn’t it? Well, yes, as far as their parameters go, they indeed are. The difference lies
in whether or not they are cancellation points. The “nc” versions are not cancellation
points, whereas the non-“nc” versions are. (For more information about cancellation
points and cancelability in general, please consult the Neutrino Library Reference,
under pthread_cancel().)
You’ve probably already suspected that all the variants of the MsgRead(),
MsgReceive(), MsgSend(), and MsgWrite() functions are closely related. (The only
exception is MsgReceivePulse() — we’ll look at this one shortly.)
Which ones should you use? Well, that’s a bit of a philosophical debate. My own
personal preference is to mix and match.
If I’m sending or receiving only one-part messages, why bother with the complexity of
setting up IOVs? The tiny amount of CPU overhead in setting them up is basically the
same regardless of whether you set it up yourself or let the kernel/library do it. The
single-part message approach saves the kernel from having to do address space
manipulations and is a little bit faster.
Should you use the IOV functions? Absolutely! Use them any time you find yourself
dealing with multipart messages. Never copy the data when you can use a multipart
message transfer with only a few lines of code. This keeps the system screaming along
by minimizing the number of times data gets copied around the system; passing the
pointers is much faster than copying the data into a new buffer.
Pulses
All the messaging we’ve talked about so far blocks the client. It’s nap time for the
client as soon as it calls MsgSend(). The client sleeps until the server gets around to
replying.
However, there are instances where the sender of a message can’t afford to block.
We’ll look at some examples in the Interrupts and Clocks, Timers, and Getting a Kick
Every So Often chapters, but for now we should understand the concept.
The mechanism that implements a non-blocking send is called a pulse. A pulse is a
tiny message that:
April 30, 2009 Chapter 2 • Message Passing 113