zmq_msg_t的结构和相关函数

本文主要讲zeromq的消息体系zmq_msg_t及其相关的操作函数。

因为tcp是一种字节流类型的协议，木有边界，所以把该消息边界的制定留给了应用层。通常有两种方式实现:

1. 在传输的数据中添加分隔符。

2. 在每条消息中添加size字段。

而zeromq可以说选择了第二种方式。

先来看看zmq_msg_t的基本数据结构

/*  A message. Note that 'content' is not a pointer to the raw data.          */
/*  Rather it is pointer to zmq::msg_content_t structure                      */
/*  (see src/msg_content.hpp for its definition).                             */
typedef struct
{
    void *content;
    unsigned char flags;
    unsigned char vsm_size;// 小消息的大小
    unsigned char vsm_data [ZMQ_MAX_VSM_SIZE];// 小消息的内存区域
} zmq_msg_t

其中content指针指向的是zmq::msg_content_t的结构, flags表示消息的一些flags

这边vsm_size和vsm_data是针对very small message的小消息做一些优化，直接在stack上分配内存了，可以看后面的消息函数的具体操作。

//  Shared message buffer. Message data are either allocated in one
    //  continuous block along with this structure - thus avoiding one
    //  malloc/free pair or they are stored in used-supplied memory.
    //  In the latter case, ffn member stores pointer to the function to be
    //  used to deallocate the data. If the buffer is actually shared (there
    //  are at least 2 references to it) refcount member contains number of
    //  references.

    struct msg_content_t
    {
        void *data;
        size_t size;
        zmq_free_fn *ffn;
        void *hint;
        zmq::atomic_counter_t refcnt;
    };

其中data指向真正的消息数据，size表示消息数据的字节大小，zmq_free_fn *ffn指向释放函数，refcnt表示消息的引用计数，hint目前未知。

下面我们看一下基本的消息操作函数:

int zmq_msg_init_size (zmq_msg_t *msg_, size_t size_)
{
    if (size_ <= ZMQ_MAX_VSM_SIZE) {
        msg_->content = (zmq::msg_content_t*) ZMQ_VSM;
        msg_->flags = (unsigned char) ~ZMQ_MSG_MASK;
        msg_->vsm_size = (uint8_t) size_;
    }
    else {
        msg_->content =
            (zmq::msg_content_t*) malloc (sizeof (zmq::msg_content_t) + size_);
        if (!msg_->content) {
            errno = ENOMEM;
            return -1;
        }
        msg_->flags = (unsigned char) ~ZMQ_MSG_MASK;

        zmq::msg_content_t *content = (zmq::msg_content_t*) msg_->content;
        content->data = (void*) (content + 1);
        content->size = size_;
        content->ffn = NULL;
        content->hint = NULL;
        new (&content->refcnt) zmq::atomic_counter_t (); // 设置引用计数
    }
    return 0;
}

对于小消息来说, 我们设置content指向地址ZMQ_VSM，这个值为32，相当于一个魔法数字，用来表示小消息。

对于相对来说的大消息来说，我们malloc (sizeof (zmq::msg_content_t) + size_)的空间，其中size_就是可变长的消息大小，然后设置content->data = (void *) (content + 1)，指向这块可变长的内存区域。

这边有一个初始化msg的flags的操作:

msg_->flags = (unsigned char) ~ZMQ_MSG_MASK;

flags的定义:

/*  Message flags. ZMQ_MSG_SHARED is strictly speaking not a message flag     */
/*  (it has no equivalent in the wire format), however, making  it a flag     */
/*  allows us to pack the stucture tigher and thus improve performance.       */
#define ZMQ_MSG_MORE 1 // 00000001
#define ZMQ_MSG_SHARED 128 // 10000000
#define ZMQ_MSG_MASK 129 /* Merges all the flags */ // 10000001

我们简单分析下这样就可以msg的flags的初始值就是01111110，即可以| ZMQ_MSG_MORE或者| ZMQ_MSG_SHARED。

尼玛。。。感觉在说废话。。。

我们再来看看另外两个消息初始化函数:

int zmq_msg_init (zmq_msg_t *msg_)
{
    msg_->content = (zmq::msg_content_t*) ZMQ_VSM;
    msg_->flags = (unsigned char) ~ZMQ_MSG_MASK;
    msg_->vsm_size = 0;
    return 0;
}

初始化一个msg消息，设置成小消息类型，初始化flags，并且将小消息的大小初始化为0.

int zmq_msg_init_data (zmq_msg_t *msg_, void *data_, size_t size_,
    zmq_free_fn *ffn_, void *hint_)
{
    msg_->content = (zmq::msg_content_t*) malloc (sizeof (zmq::msg_content_t));
    alloc_assert (msg_->content);
    msg_->flags = (unsigned char) ~ZMQ_MSG_MASK;
    zmq::msg_content_t *content = (zmq::msg_content_t*) msg_->content;
    content->data = data_;
    content->size = size_;
    content->ffn = ffn_;
    content->hint = hint_;
    new (&content->refcnt) zmq::atomic_counter_t ();
    return 0;
}

该函数根据已有的data和相应的size，和销毁的函数，以及hint来初始化消息。

这边消息指向data指针所指的内存区域。

接下来我们来看看获取数据的地址的函数，这样你就能操作消息的数据内存区域了。

void *zmq_msg_data (zmq_msg_t *msg_)
{
    zmq_assert ((msg_->flags | ZMQ_MSG_MASK) == 0xff);

    if (msg_->content == (zmq::msg_content_t*) ZMQ_VSM)
        return msg_->vsm_data;
    if (msg_->content == (zmq::msg_content_t*) ZMQ_DELIMITER)
        return NULL;

    return ((zmq::msg_content_t*) msg_->content)->data;
}

如果是小消息那么就是stack上的vsm_data地址，大消息的就是heap上的content->data。

如果是delimiter的话，返回的是空指针。 我们后面会讲述delimiter的用处。

而zmq_msg_size(1)函数也是类似的处理方式，只不过返回的是消息大小。

size_t zmq_msg_size (zmq_msg_t *msg_)
{
    zmq_assert ((msg_->flags | ZMQ_MSG_MASK) == 0xff);

    if (msg_->content == (zmq::msg_content_t*) ZMQ_VSM)
        return msg_->vsm_size;
    if (msg_->content == (zmq::msg_content_t*) ZMQ_DELIMITER)
        return 0;

    return ((zmq::msg_content_t*) msg_->content)->size;
}

接下来我们来看zmq_msg_close(1)函数, 看看如何销毁消息的。

int zmq_msg_close (zmq_msg_t *msg_)
{
    //  Check the validity tag.
    if (unlikely (msg_->flags | ZMQ_MSG_MASK) != 0xff) {
        errno = EFAULT;
        return -1;
    }

    //  For VSMs and delimiters there are no resources to free.
    if (msg_->content != (zmq::msg_content_t*) ZMQ_DELIMITER &&
          msg_->content != (zmq::msg_content_t*) ZMQ_VSM) {

        //  If the content is not shared, or if it is shared and the reference.
        //  count has dropped to zero, deallocate it.
        zmq::msg_content_t *content = (zmq::msg_content_t*) msg_->content;
        if (!(msg_->flags & ZMQ_MSG_SHARED) || !content->refcnt.sub (1)) {

            //  We used "placement new" operator to initialize the reference.
            //  counter so we call its destructor now.
            content->refcnt.~atomic_counter_t ();

            if (content->ffn)
                content->ffn (content->data, content->hint);
            free (content);
        }
    }

    //  Remove the validity tag from the message.
    msg_->flags = 0;

    return 0;
}

消息的flag检测和前面类似，该函数末尾除还会移除初始化的flags，将其置成0，表明该消息已经废了。

对于小消息，消息数据是分配在stack上的，因此不需要手动销毁。

对于大消息，消息数据是分配在heap上的，因此我们查看消息flags是否采用ZMQ_MSG_SHARED共享模式，如果没有使用就直接销毁。假如使用了共享模式，那么我们递减消息的引用计数，一旦引用计数为0，我们就销毁消息内容。

销毁过程如下: 

1. 销毁引用计数，因为在创建引用计数的时候我们使用的是placement new所以这边我们需要调用它的析构函数。

2. 如果有注册相应的自定义的销毁函数，就调用该函数。这种情况主要是用于使用zmq_msg_init_data()，自己来管理data所指向空间。 

3. 调用free(1)释放heap的空间, 注意 如果是使用zmq_msg_init_size()来初始化消息的，就会释放掉data的空间，因为这块空间就是分配时多分配的size大小(在content下方)的那块。

至于zmq_msg_move和zmq_msg_copy主要是消息的move和copy。

int zmq_msg_move (zmq_msg_t *dest_, zmq_msg_t *src_)
{
#if 0
    //  Check the validity tags.
    if (unlikely ((dest_->flags | ZMQ_MSG_MASK) != 0xff ||
          (src_->flags | ZMQ_MSG_MASK) != 0xff)) {
        errno = EFAULT;
        return -1;
    }
#endif
    zmq_msg_close (dest_);
    *dest_ = *src_;
    zmq_msg_init (src_);
    return 0;
}

int zmq_msg_copy (zmq_msg_t *dest_, zmq_msg_t *src_)
{
    //  Check the validity tags.
    if (unlikely ((dest_->flags | ZMQ_MSG_MASK) != 0xff ||
          (src_->flags | ZMQ_MSG_MASK) != 0xff)) {
        errno = EFAULT;
        return -1;
    }

    zmq_msg_close (dest_);

    //  VSMs and delimiters require no special handling.
    if (src_->content != (zmq::msg_content_t*) ZMQ_DELIMITER &&
          src_->content != (zmq::msg_content_t*) ZMQ_VSM) {

        //  One reference is added to shared messages. Non-shared messages
        //  are turned into shared messages and reference count is set to 2.
        zmq::msg_content_t *content = (zmq::msg_content_t*) src_->content;
        if (src_->flags & ZMQ_MSG_SHARED)
            content->refcnt.add (1);
        else {
            src_->flags |= ZMQ_MSG_SHARED;
            content->refcnt.set (2);
        }
    }

    *dest_ = *src_;
    return 0;
}

zmq_msg_move(1)将source的消息重置成初始化的空消息。

而zmq_msg_copy(1)dst和src共享消息content的引用，主要注意引用计数的变更。如果已经是SHARED模式则增加引用计数，否则则设置成SHARED模式，并将引用技术设置成2。

有了这些知识，下面我们来看一下基本的消息操作的示例:

//  Receive 0MQ string from socket and convert into C string
static char *
s_recv (void *socket) {
    zmq_msg_t message; // 创建消息结构
    zmq_msg_init (&message); // 初始化空消息
    zmq_recv (socket, &message, 0); // 接收消息
    int size = zmq_msg_size (&message); // 计算消息的大小
    char *string = malloc (size + 1); // 分配string为指向size + 1大小的heap空间，那个多出来的1字节是'\0'的空间
    memcpy (string, zmq_msg_data (&message), size); // 通过zmq_msg_data(1)获得消息的data地址，拷贝到字符串中
    zmq_msg_close (&message); // 释放或销毁消息
    string [size] = 0; // 设置'\0'
    return (string);
}

//  Convert C string to 0MQ string and send to socket
static int
s_send (void *socket, char *string) {
    int rc;
    zmq_msg_t message; // 创建消息结构
    zmq_msg_init_size (&message, strlen (string)); // 以字符串长度(不包括'\0')初始化成消息
    memcpy (zmq_msg_data (&message), string, strlen (string)); // 将字符串的内容(不包括'\0')拷贝给消息
    rc = zmq_send (socket, &message, 0); // 发送消息
    assert (!rc);
    zmq_msg_close (&message); // 释放和销毁消息
    return (rc);
}

从上面的注释可以看出收发消息的流程。zeromq有相关的库(czmq)封装了这些操作，当然你也可以自己封装。

ZMQ_DELIMITER:

刚才上文曾经提到过delimiter类型的消息。这种类型的消息类似于终结者的意思，主要在收发的管道中使用。因为zeromq会将消息先发送到管道中，然后poller运行在另外一个线程，将管道中的数据读出来发往socket的缓冲区，所以可以发送一个delimiter类型的消息去终结管道，销毁它。在以后我们分析管道的过程中，你能看到做这个工作的代码。

总结:

本文简单地介绍了zeromq中定义的消息的数据结构以及相关的操作，基本上zeromq的消息的数据结构就采用了可变长的数据结构来存放data，还会对小消息进行内存分配上面的优化，直接使用stack分配，而不是使用heap动态分配，消息content拥有引用计数可以共享之。

这边我们看到消息flags的时候我们发觉漏讲了一个#define ZMQ_MSG_MORE 1的标志，这个标志是multipart message使用的。下一次我们就会分析这块内容，并且会看看消息发送到管道后，poller将其取出来发送给socket缓冲区的具体细节以及反过来接收消息的过程，敬请期待！

希望有兴趣的朋友可以和我联系，一起学习。 [e-mail]