Problem: potentially large memory footprint of trie as number of

subscriptions increases

Solution: use a radix tree instead of a trie to store subscriptions

CMakeLists.txt

@@ -661,6 +661,7 @@ set(cxx-sources
   tcp_listener.cpp
   thread.cpp
   trie.cpp
+  radix_tree.cpp
   v1_decoder.cpp
   v1_encoder.cpp
   v2_decoder.cpp

Makefile.am

@@ -159,6 +159,8 @@ src_libzmq_la_SOURCES = \
 	src/push.hpp \
 	src/radio.cpp \
 	src/radio.hpp \
+	src/radix_tree.cpp \
+	src/radix_tree.hpp \
 	src/random.cpp \
 	src/random.hpp \
 	src/raw_decoder.cpp \
@@ -948,7 +950,8 @@ test_apps += \
 	unittests/unittest_ypipe \
 	unittests/unittest_mtrie \
 	unittests/unittest_ip_resolver \
-	unittests/unittest_udp_address
+	unittests/unittest_udp_address \
+	unittests/unittest_radix_tree
 
 unittests_unittest_poller_SOURCES = unittests/unittest_poller.cpp
 unittests_unittest_poller_CPPFLAGS = -I$(top_srcdir)/src ${UNITY_CPPFLAGS} $(CODE_COVERAGE_CPPFLAGS)
@@ -989,6 +992,14 @@ unittests_unittest_udp_address_LDADD = $(top_builddir)/src/.libs/libzmq.a \
 	${src_libzmq_la_LIBADD} \
 	${UNITY_LIBS} \
 	$(CODE_COVERAGE_LDFLAGS)
+
+unittests_unittest_radix_tree_SOURCES = unittests/unittest_radix_tree.cpp
+unittests_unittest_radix_tree_CPPFLAGS = -I$(top_srcdir)/src ${UNITY_CPPFLAGS} $(CODE_COVERAGE_CPPFLAGS)
+unittests_unittest_radix_tree_CXXFLAGS = $(CODE_COVERAGE_CXXFLAGS)
+unittests_unittest_radix_tree_LDADD = $(top_builddir)/src/.libs/libzmq.a \
+	${src_libzmq_la_LIBADD} \
+	${UNITY_LIBS} \
+	$(CODE_COVERAGE_LDFLAGS)
 endif
 
 check_PROGRAMS = ${test_apps}

src/radix_tree.hpp

+/*
+    Copyright (c) 2018 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 RADIX_TREE_HPP
+#define RADIX_TREE_HPP
+
+#include <stddef.h>
+
+#include "stdint.hpp"
+
+// Wrapper type for a node's data layout.
+//
+// There are 3 32-bit unsigned integers that act as a header. These
+// integers represent the following values in this order:
+//
+// (1) The reference count of the key held by the node. This is 0 if
+// the node doesn't hold a key.
+//
+// (2) The number of characters in the node's prefix. The prefix is a
+// part of one or more keys in the tree, e.g. the prefix of each node
+// in a trie consists of a single character.
+//
+// (3) The number of outgoing edges from this node.
+//
+// The rest of the layout consists of 3 chunks in this order:
+//
+// (1) The node's prefix as a sequence of one or more bytes. The root
+// node always has an empty prefix, unlike other nodes in the tree.
+//
+// (2) The first byte of the prefix of each of this node's children.
+//
+// (3) The pointer to each child node.
+//
+// The link to each child is looked up using its index, e.g. the child
+// with index 0 will have its first byte and node pointer at the start
+// of the chunk of first bytes and node pointers respectively.
+struct node
+{
+    unsigned char *data_;
+
+    explicit node (unsigned char *data);
+
+    bool operator== (node other) const;
+    bool operator!= (node other) const;
+
+    inline uint32_t refcount ();
+    inline uint32_t prefix_length ();
+    inline uint32_t edgecount ();
+    inline unsigned char *prefix ();
+    inline unsigned char *first_bytes ();
+    inline unsigned char first_byte_at (size_t i);
+    inline unsigned char *node_ptrs ();
+    inline node node_at (size_t i);
+    inline void set_refcount (uint32_t value);
+    inline void set_prefix_length (uint32_t value);
+    inline void set_edgecount (uint32_t value);
+    inline void set_prefix (const unsigned char *prefix);
+    inline void set_first_bytes (const unsigned char *bytes);
+    inline void set_first_byte_at (size_t i, unsigned char byte);
+    inline void set_node_ptrs (unsigned char const *ptrs);
+    inline void set_node_at (size_t i, node n);
+    inline void set_edge_at (size_t i, unsigned char byte, node n);
+    void resize (size_t prefix_length, size_t edgecount);
+};
+
+node make_node (size_t refcount, size_t prefix_length, size_t nedges);
+
+struct match_result
+{
+    size_t nkey;
+    size_t nprefix;
+    size_t edge_index;
+    size_t gp_edge_index;
+    node current_node;
+    node parent_node;
+    node grandparent_node;
+
+    match_result (size_t i,
+                  size_t j,
+                  size_t edge_index,
+                  size_t gp_edge_index,
+                  node current,
+                  node parent,
+                  node grandparent);
+};
+
+namespace zmq
+{
+class radix_tree
+{
+  public:
+    radix_tree ();
+    ~radix_tree ();
+
+    //  Add key to the tree. Returns true if this was a new key rather
+    //  than a duplicate.
+    bool add (const unsigned char *prefix_, size_t size_);
+
+    //  Remove key from the tree. Returns true if he item is acually
+    //  removed from the tree.
+    bool rm (const unsigned char *prefix_, size_t size_);
+
+    //  Check whether particular key is in the tree.
+    bool check (const unsigned char *prefix, size_t size_);
+
+    //  Apply the function supplied to each key in the tree.
+    void apply (void (*func) (unsigned char *data_, size_t size_, void *arg_),
+                void *arg);
+
+    void print ();
+    size_t size () const;
+
+  private:
+    match_result
+    match (const unsigned char *key, size_t size, bool check) const;
+
+    node root_;
+    size_t size_;
+};
+}
+
+#endif

src/xsub.hpp

@@ -34,7 +34,7 @@
 #include "session_base.hpp"
 #include "dist.hpp"
 #include "fq.hpp"
-#include "trie.hpp"
+#include "radix_tree.hpp"
 
 namespace zmq
 {
@@ -78,7 +78,7 @@ class xsub_t : public socket_base_t
     dist_t _dist;
 
     //  The repository of subscriptions.
-    trie_t _subscriptions;
+    radix_tree _subscriptions;
 
     //  If true, 'message' contains a matching message to return on the
     //  next recv call.

unittests/CMakeLists.txt

@@ -7,6 +7,7 @@ set(unittests
   unittest_mtrie
   unittest_ip_resolver
   unittest_udp_address
+  unittest_radix_tree
 )
 
 #if(ENABLE_DRAFTS)

unittests/unittest_radix_tree.cpp

+/*
+Copyright (c) 2018 Contributors as noted in the AUTHORS file
+
+This file is part of 0MQ.
+
+0MQ is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+(at your option) any later version.
+
+0MQ 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 "../tests/testutil.hpp"
+
+#include <radix_tree.hpp>
+#include <stdint.hpp>
+
+#include <set>
+#include <string>
+#include <string.h>
+#include <unity.h>
+#include <vector>
+
+void setUp ()
+{
+}
+void tearDown ()
+{
+}
+
+bool tree_add (zmq::radix_tree &tree, const std::string &key)
+{
+    return tree.add (reinterpret_cast<const unsigned char *> (key.data ()),
+                     key.size ());
+}
+
+bool tree_rm (zmq::radix_tree &tree, const std::string &key)
+{
+    return tree.rm (reinterpret_cast<const unsigned char *> (key.data ()),
+                    key.size ());
+}
+
+bool tree_check (zmq::radix_tree &tree, const std::string &key)
+{
+    return tree.check (reinterpret_cast<const unsigned char *> (key.data ()),
+                       key.size ());
+}
+
+void test_empty ()
+{
+    zmq::radix_tree tree;
+
+    TEST_ASSERT_TRUE (tree.size () == 0);
+}
+
+void test_add_single_entry ()
+{
+    zmq::radix_tree tree;
+
+    TEST_ASSERT_TRUE (tree_add (tree, "foo"));
+}
+
+void test_add_same_entry_twice ()
+{
+    zmq::radix_tree tree;
+
+    TEST_ASSERT_TRUE (tree_add (tree, "test"));
+    TEST_ASSERT_FALSE (tree_add (tree, "test"));
+}
+
+void test_rm_when_empty ()
+{
+    zmq::radix_tree tree;
+
+    TEST_ASSERT_FALSE (tree_rm (tree, "test"));
+}
+
+void test_rm_single_entry ()
+{
+    zmq::radix_tree tree;
+
+    tree_add (tree, "temporary");
+    TEST_ASSERT_TRUE (tree_rm (tree, "temporary"));
+}
+
+void test_rm_unique_entry_twice ()
+{
+    zmq::radix_tree tree;
+
+    tree_add (tree, "test");
+    TEST_ASSERT_TRUE (tree_rm (tree, "test"));
+    TEST_ASSERT_FALSE (tree_rm (tree, "test"));
+}
+
+void test_rm_duplicate_entry ()
+{
+    zmq::radix_tree tree;
+
+    tree_add (tree, "test");
+    tree_add (tree, "test");
+    TEST_ASSERT_FALSE (tree_rm (tree, "test"));
+    TEST_ASSERT_TRUE (tree_rm (tree, "test"));
+}
+
+void test_rm_common_prefix ()
+{
+    zmq::radix_tree tree;
+
+    tree_add (tree, "checkpoint");
+    tree_add (tree, "checklist");
+    TEST_ASSERT_FALSE (tree_rm (tree, "check"));
+}
+
+void test_rm_common_prefix_entry ()
+{
+    zmq::radix_tree tree;
+
+    tree_add (tree, "checkpoint");
+    tree_add (tree, "checklist");
+    tree_add (tree, "check");
+    TEST_ASSERT_TRUE (tree_rm (tree, "check"));
+}
+
+void test_rm_null_entry ()
+{
+    zmq::radix_tree tree;
+
+    tree_add (tree, "");
+    TEST_ASSERT_TRUE (tree_rm (tree, ""));
+}
+
+void test_check_empty ()
+{
+    zmq::radix_tree tree;
+
+    TEST_ASSERT_FALSE (tree_check (tree, "foo"));
+}
+
+void test_check_added_entry ()
+{
+    zmq::radix_tree tree;
+
+    tree_add (tree, "entry");
+    TEST_ASSERT_TRUE (tree_check (tree, "entry"));
+}
+
+void test_check_common_prefix ()
+{
+    zmq::radix_tree tree;
+
+    tree_add (tree, "introduce");
+    tree_add (tree, "introspect");
+    TEST_ASSERT_FALSE (tree_check (tree, "intro"));
+}
+
+void test_check_prefix ()
+{
+    zmq::radix_tree tree;
+
+    tree_add (tree, "toasted");
+    TEST_ASSERT_FALSE (tree_check (tree, "toast"));
+    TEST_ASSERT_FALSE (tree_check (tree, "toaste"));
+    TEST_ASSERT_FALSE (tree_check (tree, "toaster"));
+}
+
+void test_check_nonexistent_entry ()
+{
+    zmq::radix_tree tree;
+
+    tree_add (tree, "red");
+    TEST_ASSERT_FALSE (tree_check (tree, "blue"));
+}
+
+void test_check_query_longer_than_entry ()
+{
+    zmq::radix_tree tree;
+
+    tree_add (tree, "foo");
+    TEST_ASSERT_TRUE (tree_check (tree, "foobar"));
+}
+
+void test_check_null_entry_added ()
+{
+    zmq::radix_tree tree;
+
+    tree_add (tree, "");
+    TEST_ASSERT_TRUE (tree_check (tree, "all queries return true"));
+}
+
+void test_size ()
+{
+    zmq::radix_tree tree;
+
+    // Adapted from the example on wikipedia.
+    std::vector<std::string> keys;
+    keys.push_back ("tester");
+    keys.push_back ("water");
+    keys.push_back ("slow");
+    keys.push_back ("slower");
+    keys.push_back ("test");
+    keys.push_back ("team");
+    keys.push_back ("toast");
+
+    for (size_t i = 0; i < keys.size (); ++i)
+        TEST_ASSERT_TRUE (tree_add (tree, keys[i]));
+    TEST_ASSERT_TRUE (tree.size () == keys.size ());
+    for (size_t i = 0; i < keys.size (); ++i)
+        TEST_ASSERT_FALSE (tree_add (tree, keys[i]));
+    TEST_ASSERT_TRUE (tree.size () == 2 * keys.size ());
+    for (size_t i = 0; i < keys.size (); ++i)
+        TEST_ASSERT_FALSE (tree_rm (tree, keys[i]));
+    TEST_ASSERT_TRUE (tree.size () == keys.size ());
+    for (size_t i = 0; i < keys.size (); ++i)
+        TEST_ASSERT_TRUE (tree_rm (tree, keys[i]));
+    TEST_ASSERT_TRUE (tree.size () == 0);
+}
+
+void return_key (unsigned char *data, size_t size, void *arg)
+{
+    std::vector<std::string> *vec =
+      reinterpret_cast<std::vector<std::string> *> (arg);
+    std::string key;
+    for (size_t i = 0; i < size; ++i)
+        key.push_back (static_cast<char> (data[i]));
+    vec->push_back (key);
+}
+
+void test_apply ()
+{
+    zmq::radix_tree tree;
+
+    std::set<std::string> keys;
+    keys.insert ("tester");
+    keys.insert ("water");
+    keys.insert ("slow");
+    keys.insert ("slower");
+    keys.insert ("test");
+    keys.insert ("team");
+    keys.insert ("toast");
+
+    const std::set<std::string>::iterator end = keys.end ();
+    for (std::set<std::string>::iterator it = keys.begin (); it != end; ++it)
+        tree_add (tree, *it);
+
+    std::vector<std::string> *vec = new std::vector<std::string> ();
+    tree.apply (return_key, static_cast<void *> (vec));
+    for (size_t i = 0; i < vec->size (); ++i)
+        TEST_ASSERT_TRUE (keys.count ((*vec)[i]) > 0);
+    delete vec;
+}
+
+void test_print ()
+{
+    zmq::radix_tree tree;
+
+    // Adapted from the example on wikipedia.
+    std::vector<std::string> keys;
+    keys.push_back ("tester");
+    keys.push_back ("water");
+    keys.push_back ("slow");
+    keys.push_back ("slower");
+    keys.push_back ("test");
+    keys.push_back ("team");
+    keys.push_back ("toast");
+
+    for (size_t i = 0; i < keys.size (); ++i)
+        tree_add (tree, keys[i]);
+
+    tree.print ();
+}
+
+int main (void)
+{
+    setup_test_environment ();
+
+    UNITY_BEGIN ();
+
+    RUN_TEST (test_empty);
+    RUN_TEST (test_add_single_entry);
+    RUN_TEST (test_add_same_entry_twice);
+
+    RUN_TEST (test_rm_when_empty);
+    RUN_TEST (test_rm_single_entry);
+    RUN_TEST (test_rm_unique_entry_twice);
+    RUN_TEST (test_rm_duplicate_entry);
+    RUN_TEST (test_rm_common_prefix);
+    RUN_TEST (test_rm_common_prefix_entry);
+    RUN_TEST (test_rm_null_entry);
+
+    RUN_TEST (test_check_empty);
+    RUN_TEST (test_check_added_entry);
+    RUN_TEST (test_check_common_prefix);
+    RUN_TEST (test_check_prefix);
+    RUN_TEST (test_check_nonexistent_entry);
+    RUN_TEST (test_check_query_longer_than_entry);
+    RUN_TEST (test_check_null_entry_added);
+
+    RUN_TEST (test_size);
+
+    RUN_TEST (test_apply);
+
+    RUN_TEST (test_print);
+
+    return UNITY_END ();
+}