[PROBLEM] No custom memory allocator for msg can be provided

CMakeLists.txt

@@ -615,6 +615,8 @@ if(MSVC)
 
     zmq_check_cxx_flag_prepend("/analyze")
 
+    zmq_check_cxx_flag_prepend("/Zc:__cplusplus") # enables right reporting of __cplusplus, ref. https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
+
     # C++11/14/17-specific, but maybe possible via conditional defines
     zmq_check_cxx_flag_prepend("/wd26440") # Function '...' can be declared 'noexcept'
     zmq_check_cxx_flag_prepend("/wd26432") # If you define or delete any default operation in the type '...', define or
@@ -893,6 +895,7 @@ endif()
 set(cxx-sources
     precompiled.cpp
     address.cpp
+    allocator_default.cpp
     channel.cpp
     client.cpp
     clock.cpp
@@ -993,6 +996,7 @@ set(cxx-sources
     zmtp_engine.cpp
     # at least for VS, the header files must also be listed
     address.hpp
+    allocator_default.hpp
     array.hpp
     atomic_counter.hpp
     atomic_ptr.hpp

Makefile.am

@@ -22,6 +22,8 @@ include_HEADERS = \
 src_libzmq_la_SOURCES = \
 	src/address.cpp \
 	src/address.hpp \
+	src/allocator_default.cpp \
+	src/allocator_default.hpp \
 	src/array.hpp \
 	src/atomic_counter.hpp \
 	src/atomic_ptr.hpp \

include/zmq.h

@@ -643,6 +643,22 @@ ZMQ_EXPORT void *zmq_threadstart (zmq_thread_fn *func_, void *arg_);
 ZMQ_EXPORT void zmq_threadclose (void *thread_);
 
 
+struct zmq_allocator_t
+{
+    // Allocate a chunk of memory of size len and return the pointer
+    void *(*allocate_fn) (void *allocator, size_t len);
+
+    // Deallocate the memory chunk pointed to by data_
+    void (*deallocate_fn) (void *allocator, void *data_);
+
+    // Return true if this is an allocator and alive, otherwise false
+    bool (*check_tag_fn) (void *allocator);
+
+    void (*destroy_fn) (void *allocator);
+
+    void *allocator;
+};
+
 /******************************************************************************/
 /*  These functions are DRAFT and disabled in stable releases, and subject to */
 /*  change at ANY time until declared stable.                                 */
@@ -699,6 +715,15 @@ ZMQ_EXPORT int zmq_ctx_get_ext (void *context_,
                                 void *optval_,
                                 size_t *optvallen_);
 
+// ZMQ-provided message-pool implementations.                                 */
+// default allocator using malloc/free
+#define ZMQ_MSG_ALLOCATOR_DEFAULT 0
+
+ZMQ_EXPORT void *zmq_msg_allocator_new (int type_);
+ZMQ_EXPORT int zmq_msg_allocator_destroy (void **allocator_);
+ZMQ_EXPORT int
+zmq_msg_init_allocator (zmq_msg_t *msg_, size_t size_, void *allocator_);
+
 /*  DRAFT Socket methods.                                                     */
 ZMQ_EXPORT int zmq_join (void *s, const char *group);
 ZMQ_EXPORT int zmq_leave (void *s, const char *group);

perf/remote_thr.cpp

@@ -27,6 +27,7 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include "platform.hpp"
 #include "../include/zmq.h"
 #include <stdio.h>
 #include <stdlib.h>
@@ -67,6 +68,11 @@ int main (int argc, char *argv[])
         return -1;
     }
 
+#if (defined ZMQ_BUILD_DRAFT_API)
+    // EXPERIMENTAL ALLOCATOR FOR MSG_T
+    void *allocator = zmq_msg_allocator_new (ZMQ_MSG_ALLOCATOR_DEFAULT);
+#endif
+
     s = zmq_socket (ctx, ZMQ_PUSH);
     if (!s) {
         printf ("error in zmq_socket: %s\n", zmq_strerror (errno));
@@ -105,7 +111,11 @@ int main (int argc, char *argv[])
     }
 
     for (i = 0; i != message_count; i++) {
+#if (defined ZMQ_BUILD_DRAFT_API)
+        rc = zmq_msg_init_allocator (&msg, message_size, allocator);
+#else
         rc = zmq_msg_init_size (&msg, message_size);
+#endif
         if (rc != 0) {
             printf ("error in zmq_msg_init_size: %s\n", zmq_strerror (errno));
             return -1;
@@ -134,5 +144,11 @@ int main (int argc, char *argv[])
         return -1;
     }
 
+#if (defined ZMQ_BUILD_DRAFT_API)
+    // IMPORTANT: destroy the allocator only after zmq_ctx_term() since otherwise
+    // some zmq_msg_t may still be "in fly"
+    zmq_msg_allocator_destroy (&allocator);
+#endif
+
     return 0;
 }

src/allocator_default.cpp

@@ -0,0 +1,60 @@
+/*
+    Copyright (c) 2019-2020 Contributors as noted in the AUTHORS file
+
+    This file is part of libzmq, the ZeroMQ core engine in C++.
+
+    libzmq is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    As a special exception, the Contributors give you permission to link
+    this library with independent modules to produce an executable,
+    regardless of the license terms of these independent modules, and to
+    copy and distribute the resulting executable under terms of your choice,
+    provided that you also meet, for each linked independent module, the
+    terms and conditions of the license of that module. An independent
+    module is a module which is not derived from or based on this library.
+    If you modify this library, you must extend this exception to your
+    version of the library.
+
+    libzmq is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+    License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "precompiled.hpp"
+#include "allocator_default.hpp"
+
+#include <new>
+
+zmq::allocator_default_t::allocator_default_t ()
+{
+    _tag = 0xCAFEEBEB;
+}
+
+
+zmq::allocator_default_t::~allocator_default_t ()
+{
+    //  Mark this instance as dead
+    _tag = 0xdeadbeef;
+}
+
+void *zmq::allocator_default_t::allocate (size_t len_)
+{
+    return operator new (len_, std::nothrow);
+}
+
+void zmq::allocator_default_t::deallocate (void *data_)
+{
+    operator delete (data_);
+}
+
+bool zmq::allocator_default_t::check_tag () const
+{
+    return _tag == 0xCAFEEBEB;
+}

src/allocator_default.hpp

@@ -0,0 +1,76 @@
+/*
+    Copyright (c) 2019-2020 Contributors as noted in the AUTHORS file
+
+    This file is part of libzmq, the ZeroMQ core engine in C++.
+
+    libzmq is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    As a special exception, the Contributors give you permission to link
+    this library with independent modules to produce an executable,
+    regardless of the license terms of these independent modules, and to
+    copy and distribute the resulting executable under terms of your choice,
+    provided that you also meet, for each linked independent module, the
+    terms and conditions of the license of that module. An independent
+    module is a module which is not derived from or based on this library.
+    If you modify this library, you must extend this exception to your
+    version of the library.
+
+    libzmq is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+    License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __ZMQ_I_ALLOCATOR_HPP_INCLUDED__
+#define __ZMQ_I_ALLOCATOR_HPP_INCLUDED__
+
+namespace zmq
+{
+class allocator_default_t
+{
+  public:
+    allocator_default_t ();
+
+    ~allocator_default_t ();
+
+    static void *allocate_fn (void *allocator_, size_t len_)
+    {
+        return static_cast<allocator_default_t *> (allocator_)->allocate (len_);
+    }
+
+    static void deallocate_fn (void *allocator_, void *data_)
+    {
+        return static_cast<allocator_default_t *> (allocator_)
+          ->deallocate (data_);
+    }
+
+    static bool check_tag_fn (void *allocator_)
+    {
+        return static_cast<allocator_default_t *> (allocator_)->check_tag ();
+    }
+
+    static void destroy_fn (void *allocator_)
+    {
+        operator delete (static_cast<allocator_default_t *> (allocator_));
+    }
+
+    // allocate() typically gets called by the consumer thread: the user app thread(s)
+    void *allocate (size_t len_);
+
+    void deallocate (void *data_);
+
+    bool check_tag () const;
+
+  private:
+    //  Used to check whether the object is a socket.
+    uint32_t _tag;
+};
+}
+
+#endif

src/ctx.cpp

@@ -47,6 +47,7 @@
 #include "err.hpp"
 #include "msg.hpp"
 #include "random.hpp"
+#include "allocator_default.hpp"
 
 #ifdef ZMQ_HAVE_VMCI
 #include <vmci_sockets.h>
@@ -311,6 +312,18 @@ int zmq::ctx_t::set (int option_, const void *optval_, size_t optvallen_)
             }
             break;
 
+            /*case ZMQ_MSG_ALLOCATOR: {
+            if (optvallen_ == sizeof (zmq::allocator_t)) {
+                const zmq::allocator_t *all =
+                  static_cast<const zmq::allocator_t *> (optval_);
+                if (all->check_tag ()) {
+                    _allocator = const_cast<zmq::allocator_t *> (all);
+                    return 0;
+                }
+            }
+            break;
+    }*/
+
         default: {
             return thread_ctx_t::set (option_, optval_, optvallen_);
         }
@@ -381,6 +394,9 @@ int zmq::ctx_t::get (int option_, void *optval_, const size_t *optvallen_)
                 return 0;
             }
             break;
+            /*
+        case ZMQ_MSG_ALLOCATOR: {
+        } break;*/
 
         default: {
             return thread_ctx_t::get (option_, optval_, optvallen_);

src/ctx.hpp

@@ -35,6 +35,7 @@
 #include <string>
 #include <stdarg.h>
 
+//#include "allocator_default.hpp"
 #include "mailbox.hpp"
 #include "array.hpp"
 #include "config.hpp"
@@ -221,6 +222,9 @@ class ctx_t ZMQ_FINAL : public thread_ctx_t
     //  Synchronisation of access to the list of inproc endpoints.
     mutex_t _endpoints_sync;
 
+    // Allocator for messages
+    //allocator_t *_allocator;
+
     //  Maximum socket ID.
     static atomic_counter_t max_socket_id;