zero-copy message receive

Construct messages from a reference-counted buffer allocated once
per receive instead of copying the data.

src/v2_decoder.hpp

@@ -34,11 +34,66 @@
 
 namespace zmq
 {
-    //  Decoder for ZMTP/2.x framing protocol. Converts data stream into messages.
-    class v2_decoder_t : public decoder_base_t <v2_decoder_t>
+    // This allocater allocates a reference counted buffer which is used by v2_decoder_t
+    // to use zero-copy msg::init_data to create messages with memory from this buffer as
+    // data storage.
+    //
+    // The buffer is allocated with a reference count of 1 to make sure that is is alive while
+    // decoding messages. Otherwise, it is possible that e.g. the first message increases the count
+    // from zero to one, gets passed to the user application, processed in the user thread and deleted
+    // which would then deallocate the buffer. The drawback is that the buffer may be allocated longer
+    // than necessary because it is only deleted when allocate is called the next time.
+    class shared_message_memory_allocator
     {
     public:
+        shared_message_memory_allocator(size_t bufsize_);
 
+        ~shared_message_memory_allocator();
+
+        // Allocate a new buffer
+        //
+        // This releases the current buffer to be bound to the lifetime of the messages
+        // created on this bufer.
+        unsigned char* allocate();
+
+        // force deallocation of buffer.
+        void deallocate();
+
+        // Give up ownership of the buffer. The buffer's lifetime is now coupled to
+        // the messages constructed on top of it.
+        unsigned char* release();
+
+        void reset(unsigned char* b);
+
+        void inc_ref();
+
+        static void call_dec_ref(void*, void* buffer);
+
+        size_t size() const;
+
+        // Return pointer to the first message data byte.
+        unsigned char* data();
+
+        // Return pointer to the first byte of the buffer.
+        unsigned char* buffer()
+        {
+            return buf;
+        }
+
+    private:
+        unsigned char* buf;
+        size_t bufsize;
+    };
+
+    //  Decoder for ZMTP/2.x framing protocol. Converts data stream into messages.
+    //  The class has to inherit from shared_message_memory_allocator because
+    //  the base class calls allocate in its constructor.
+    class v2_decoder_t :
+            // inherit first from allocator to ensure that it is constructed before decoder_base_t
+            public shared_message_memory_allocator,
+            public decoder_base_t <v2_decoder_t, shared_message_memory_allocator>
+    {
+    public:
         v2_decoder_t (size_t bufsize_, int64_t maxmsgsize_);
         virtual ~v2_decoder_t ();
 
@@ -47,10 +102,12 @@ namespace zmq
 
     private:
 
-        int flags_ready ();
-        int one_byte_size_ready ();
-        int eight_byte_size_ready ();
-        int message_ready ();
+        int flags_ready (unsigned char const*);
+        int one_byte_size_ready (unsigned char const*);
+        int eight_byte_size_ready (unsigned char const*);
+        int message_ready (unsigned char const*);
+
+        int size_ready(uint64_t size_, unsigned char const*);
 
         unsigned char tmpbuf [8];
         unsigned char msg_flags;