Skip to main content

Understanding POSIX Message Queues: A Guide to Real-Time Interprocess Communication

As a software engineer, building efficient interprocess communication (IPC) mechanisms is critical when multiple processes need to exchange data or coordinate in real-time. POSIX message queues provide a robust, standardized way for processes to exchange messages asynchronously in Unix-like systems. They are often used in real-time systems, where low-latency communication is crucial.

This guide explores what POSIX message queues are, their features, and how to implement them in a practical use case.

What Are POSIX Message Queues?​

POSIX message queues are a part of the POSIX.1b real-time extensions, providing a method for processes to send and receive messages asynchronously. Unlike traditional file-based IPC mechanisms like pipes, POSIX message queues:

  1. Support asynchronous, priority-based messaging.
  2. Allow message persistence in memory until received.
  3. Provide non-blocking options for both sending and receiving messages.
  4. Support message priority, enabling more important messages to bypass lower-priority ones.

Key Features​

  • Priority Queues: Messages are ordered by priority, not just arrival time.
  • Asynchronous Notification: Processes can register to be notified (via signals) when new messages arrive.
  • Configurable Attributes: Maximum queue size, message size, and other attributes are configurable at runtime.

A Use Case: Real-Time Command Processing​

Imagine a real-time robotic system where a control process sends commands to multiple worker processes. Each command has a priority indicating its urgency:

  • High-priority commands should preempt low-priority ones.
  • Worker processes should receive commands asynchronously.

POSIX message queues are a perfect fit for this use case.

Step-by-Step Guide: Using POSIX Message Queues in C​

Step 1: Include Necessary Libraries​

To use POSIX message queues in C, include the following headers:

#include <fcntl.h>    // For O_* constants
#include <sys/stat.h> // For mode constants
#include <mqueue.h>   // For POSIX message queue functions
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

Step 2: Create and Open a Message Queue​

Use mq_open to create or open a message queue.

Example Code:

#define QUEUE_NAME "/command_queue"
#define MAX_SIZE 1024
#define PERMISSIONS 0666

int main() {
    // Define message queue attributes
    struct mq_attr attr;
    attr.mq_flags = 0;           // Blocking mode
    attr.mq_maxmsg = 10;         // Maximum number of messages in the queue
    attr.mq_msgsize = MAX_SIZE;  // Maximum message size
    attr.mq_curmsgs = 0;         // Number of messages currently in the queue

    // Create a new message queue
    mqd_t mq = mq_open(QUEUE_NAME, O_CREAT | O_RDWR, PERMISSIONS, &attr);
    if (mq == (mqd_t) -1) {
        perror("mq_open");
        exit(EXIT_FAILURE);
    }

    printf("Message queue created successfully.\n");
    mq_close(mq);
    return 0;
}

Step 3: Send Messages to the Queue​

Use mq_send to send messages to the queue. You can specify a priority for each message (higher values indicate higher priority).

Example Code:

int main() {
    mqd_t mq = mq_open(QUEUE_NAME, O_WRONLY);
    if (mq == (mqd_t) -1) {
        perror("mq_open");
        exit(EXIT_FAILURE);
    }

    // Message to send
    char message[] = "High-priority command";
    unsigned int priority = 10; // Higher value = higher priority

    // Send the message
    if (mq_send(mq, message, strlen(message) + 1, priority) == -1) {
        perror("mq_send");
        exit(EXIT_FAILURE);
    }

    printf("Message sent: %s\n", message);
    mq_close(mq);
    return 0;
}

Step 4: Receive Messages from the Queue​

Use mq_receive to read messages from the queue. Messages with the highest priority are retrieved first.

Example Code:

int main() {
    mqd_t mq = mq_open(QUEUE_NAME, O_RDONLY);
    if (mq == (mqd_t) -1) {
        perror("mq_open");
        exit(EXIT_FAILURE);
    }

    // Buffer to store the message
    char buffer[MAX_SIZE];
    unsigned int priority;

    // Receive the message
    if (mq_receive(mq, buffer, MAX_SIZE, &priority) == -1) {
        perror("mq_receive");
        exit(EXIT_FAILURE);
    }

    printf("Received message: %s (priority: %u)\n", buffer, priority);
    mq_close(mq);
    return 0;
}

Step 5: Clean Up Resources​

Always close and unlink the message queue after use to release system resources.

Example Code:

int main() {
    // Unlink the message queue
    if (mq_unlink(QUEUE_NAME) == -1) {
        perror("mq_unlink");
        exit(EXIT_FAILURE);
    }

    printf("Message queue deleted.\n");
    return 0;
}

Handling Non-Blocking and Asynchronous Operations​

Non-Blocking Mode​

Set the O_NONBLOCK flag when opening the queue to enable non-blocking operations:

mqd_t mq = mq_open(QUEUE_NAME, O_RDONLY | O_NONBLOCK);

Asynchronous Notification​

Register a signal-based notification mechanism to be alerted when new messages arrive:

#include <signal.h>

void notification_handler(union sigval sv) {
    printf("New message arrived!\n");
    // Additional processing here
}

int main() {
    mqd_t mq = mq_open(QUEUE_NAME, O_RDONLY);

    // Register notification
    struct sigevent sev;
    sev.sigev_notify = SIGEV_THREAD;
    sev.sigev_notify_function = notification_handler;
    sev.sigev_notify_attributes = NULL;
    sev.sigev_value.sival_ptr = &mq;

    if (mq_notify(mq, &sev) == -1) {
        perror("mq_notify");
        exit(EXIT_FAILURE);
    }

    printf("Notification handler registered.\n");
    pause(); // Wait for notifications
    return 0;
}

Advantages of POSIX Message Queues​

  1. Low Latency: Messages are stored in memory for fast communication.
  2. Priority-Based Messaging: Higher-priority messages are delivered first.
  3. Simplicity: Standardized API across POSIX-compliant systems.
  4. Asynchronous Support: Notifications reduce polling overhead.

Limitations of POSIX Message Queues​

  1. System Limits: Configurable limits on the number of queues, message size, and total memory usage (/proc/sys/fs/mqueue).
  2. Lack of Distribution: POSIX message queues are limited to processes on the same system.
  3. Requires Management: Applications must handle cleanup (e.g., unlinking queues).

Conclusion​

POSIX message queues provide a robust mechanism for interprocess communication in real-time systems, with features like message prioritization and asynchronous notifications. While they are limited to local systems, their performance and simplicity make them ideal for scenarios requiring fast and predictable IPC.

By following the steps in this guide, you can set up and use POSIX message queues to build efficient, real-time communication between processes. Let me know if you'd like to explore other IPC mechanisms like shared memory or sockets!