通过Posix队列传递大量数据

Question

我试图在C（带有Debian的Raspberry）中的线程之间传递大量数据。 我想创建32个队列。 我需要传递每个105字节的消息。 我想每4毫秒将105个字节传递给线程20秒钟（最高30秒钟）。

我发现posix队列是无法修改mq_msgsize参数。 我可以修改mq_maxmsg，但如果尝试修改另一个，队列将无法工作。 它只能处理1024个字节。

我想我还不了解mq_maxmsg和mq_msgsize参数。 我以为mq_maxmsg是我可以存储在队列中的消息数，mq_msgsize是每个参数的大小。

在mq_send函数中，我应该传递具有105字节值的缓冲区。 在mq_receive函数中，我应该每次读取105个字节。 这是正确的吗？ 如果尝试这样做，则发送/接收无效。 只有1024。

这就是我声明队列的方式（我现在有32个队列，但是它们都是平等创建的）：

#define Q_MOTOR_SIZE            1024

struct mq_attr          mq_motor_attr;
mq_motor_attr.mq_flags      = 0;
mq_motor_attr.mq_maxmsg     = 10000;
mq_motor_attr.mq_msgsize    = Q_MOTOR_SIZE;   #I tried to change this value by 105
mq_motor_attr.mq_curmsgs    = 0;
PR_mq_motor[0] = mq_open(MOTOR_0_Q_NAME, O_CREAT| O_RDONLY| O_NONBLOCK, 0644, &mq_motor_attr);
PR_mq_motor[1] = mq_open(MOTOR_1_Q_NAME, O_CREAT| O_RDONLY| O_NONBLOCK, 0644, &mq_motor_attr);
...
PR_mq_motor[31] = mq_open(MOTOR_31_Q_NAME, O_CREAT| O_RDONLY| O_NONBLOCK, 0644, &mq_motor_attr);

每次发送一堆帧（105个字节）时，我应该发送1024个帧还是应该与105个数据包大小一起使用？

mq_send(PR_mq_motor[motor_counter], PR_queue_buffer, 1024, 0);

与

mq_send(PR_mq_motor[motor_counter], PR_queue_buffer, 105, 0);

在接收部分中也是如此。 如果我尝试读取105而不是1024，则会在操作过程中崩溃。

我该怎么办？ 如果需要在raspi配置上进行某些修改，这不是问题。

如@肖恩建议。 我实现了一个链表，以便在开始时拥有32个队列。

我创建了一些数组来跟踪所有互斥量以控制访问和每个列表的标题。

我认为推送效果很好，但是在弹出元素时出现了一些问题。

就像我说的那样，我想每个存储8个字节的缓冲区，因此我确定使用10个缓冲区来创建结构。

int16_t LL_M_Push(uint8_t LL_M_motor, uint8_t *LL_M_frame, uint16_t LL_M_size) {

pthread_mutex_lock(&PR_LL_M_lock[LL_M_motor]);

PR_LL_M_node_t *current = PR_LL_M_head[LL_M_motor];
if (current != NULL) {
    while (current->next != NULL) {
        current = current->next;
    }

    /* now we can add a new variable */
    current->next = malloc(sizeof(PR_LL_M_node_t));
    memcpy(current->next->val, LL_M_frame, LL_M_size);
    current->next->next = NULL;
} else {
    PR_LL_M_head[LL_M_motor] = malloc(sizeof(PR_LL_M_node_t));
    memcpy(PR_LL_M_head[LL_M_motor]->val, LL_M_frame, LL_M_size);
    PR_LL_M_head[LL_M_motor]->next = NULL;
}
PR_LL_M_counter[LL_M_motor]++;
pthread_mutex_unlock(&PR_LL_M_lock[LL_M_motor]);

return PR_LL_M_counter[LL_M_motor];
}

int16_t LL_M_Pop(uint8_t LL_M_motor, uint8_t *LL_M_element) {
uint8_t         *retval;
PR_LL_M_node_t  *next_node  = NULL;

pthread_mutex_lock(&PR_LL_M_lock[LL_M_motor]);
if ((PR_LL_M_head[LL_M_motor] == NULL) || (PR_LL_M_counter[LL_M_motor] == 0)) {
    pthread_mutex_unlock(&PR_LL_M_lock[LL_M_motor]);
    return -1;
}

next_node               = PR_LL_M_head[LL_M_motor]->next;
retval                  = PR_LL_M_head[LL_M_motor]->val;
memcpy(LL_M_element, retval, 10);
PR_LL_M_counter[LL_M_motor]--;
free(PR_LL_M_head[LL_M_motor]);
PR_LL_M_head[LL_M_motor] = next_node;

pthread_mutex_unlock(&PR_LL_M_lock[LL_M_motor]);

return PR_LL_M_counter[LL_M_motor];
}

您在这里看到问题吗？ 您还需要些别的吗？