Merge pull request #31 from basiliscos/experimental-boost-1.70

basiliscos · web-flow · commit c97b36824180 · 2019-04-27T14:50:40.000+03:00
Experimental boost 1.70
diff --git a/.travis.yml b/.travis.yml
@@ -8,12 +8,12 @@ os:
     - linux
 
 before_script:
-    - wget -q -O - https://sourceforge.net/projects/boost/files/boost/1.69.0/boost_1_69_0.tar.gz | tar -xz
-    - cd boost_1_69_0 && ./bootstrap.sh --with-libraries=coroutine,context,chrono,system,thread,regex,filesystem,program_options
+    - wget -q -O - https://sourceforge.net/projects/boost/files/boost/1.70.0/boost_1_70_0.tar.gz | tar -xz
+    - cd boost_1_70_0 && ./bootstrap.sh --with-libraries=coroutine,context,chrono,system,thread,regex,filesystem,program_options
     - ./b2  --ignore-site-config && cd ..
     - mkdir build
     - cd build
-    - cmake -DBOOST_ROOT=`pwd`/../boost_1_69_0 ..
+    - cmake -DBOOST_ROOT=`pwd`/../boost_1_70_0 ..
 
 addons:
   apt:
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -72,11 +72,14 @@ if(WIN32)
     set(LINK_DEPENDENCIES ${Boost_LIBRARIES} catch_lib)
     add_definitions(-DBOOST_ALL_DYN_LINK -DBOOST_THREAD_USE_LIB -D_WIN32_WINNT=0x0501)
 else()
-    add_definitions(-Wall -Wextra -pedantic -Werror)
+    #add_definitions(-Wall -Wextra -pedantic -Werror)
+    add_definitions(-Wall -Wextra -pedantic)
     #add_definitions(-fsanitize=undefined -fsanitize=address -fno-omit-frame-pointer)
     set(LINK_DEPENDENCIES pthread ${Boost_LIBRARIES} catch_lib) #  asan ubsan
 endif()
 
+set(BOOST_VERSION_OK, (Boost_MAJOR_VERSION GREATER_EQUAL 1) AND (Boost_MINOR_VERSION GREATER_EQUAL 70))
+
 add_subdirectory(examples)
 
 add_executable(t-05-protocol t/05-protocol.cpp)
@@ -137,9 +140,11 @@ add_executable(t-19-transaction t/19-transaction.cpp)
 target_link_libraries(t-19-transaction ${LINK_DEPENDENCIES})
 add_test("t-19-transaction" t-19-transaction)
 
-add_executable(t-20-promise t/20-promise.cpp)
-target_link_libraries(t-20-promise ${LINK_DEPENDENCIES})
-add_test("t-20-promise" t-20-promise)
+if(BOOST_VERSION_OK)
+    add_executable(t-20-promise t/20-promise.cpp)
+    target_link_libraries(t-20-promise ${LINK_DEPENDENCIES})
+    add_test("t-20-promise" t-20-promise)
+endif()
 
 add_executable(t-21-coroutine t/21-coroutine.cpp)
 target_link_libraries(t-21-coroutine ${LINK_DEPENDENCIES})
@@ -153,3 +158,8 @@ add_executable(t-23-stream t/23-stream.cpp)
 target_link_libraries(t-23-stream ${LINK_DEPENDENCIES})
 add_test("t-23-stream" t-23-stream)
 
+if(BOOST_VERSION_OK)
+    add_executable(t-24-dynbuff t/24-dynbuff.cpp)
+    target_link_libraries(t-24-dynbuff ${LINK_DEPENDENCIES})
+    add_test("t-24-dynbuff" t-24-dynbuff)
+endif()
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
@@ -8,8 +8,10 @@ target_link_libraries(stream-parse ${LINK_DEPENDENCIES})
 add_executable(synch-subscription synch-subscription.cpp)
 target_link_libraries(synch-subscription ${LINK_DEPENDENCIES})
 
-add_executable(speed_test_async_multi speed_test_async_multi.cpp)
-target_link_libraries(speed_test_async_multi ${LINK_DEPENDENCIES})
+if(BOOST_VERSION_OK)
+    add_executable(speed_test_async_multi speed_test_async_multi.cpp)
+    target_link_libraries(speed_test_async_multi ${LINK_DEPENDENCIES})
+endif()
 
 add_executable(multi-threads-1 multi-threads-1.cpp)
 target_link_libraries(multi-threads-1 ${LINK_DEPENDENCIES})
diff --git a/examples/speed_test_async_multi.cpp b/examples/speed_test_async_multi.cpp
@@ -53,10 +53,15 @@ int main(int argc, char **argv) {
     // common setup
     using socket_t = asio::ip::tcp::socket;
     using next_layer_t = socket_t;
-    using Buffer = boost::asio::streambuf;
+    //using Buffer = boost::asio::streambuf;
+    using Buffer = boost::asio::dynamic_string_buffer<
+        std::string::value_type,
+        std::string::traits_type,
+        std::string::allocator_type
+    >;
     using Iterator = typename r::to_iterator<Buffer>::iterator_t;
-    //using policy_t = r::parsing_policy::drop_result;
-    using policy_t = r::parsing_policy::keep_result;
+    using policy_t = r::parsing_policy::drop_result;
+    //using policy_t = r::parsing_policy::keep_result;
 
     if (argc < 2) {
         std::cout << "Usage : " << argv[0] << " ip:port \n";
@@ -96,7 +101,11 @@ int main(int argc, char **argv) {
     // wrap it into bredis connection
     r::Connection<next_layer_t> c(std::move(socket));
 
-    Buffer tx_buff, rx_buff;
+    std::string tx_backend, rx_backend;
+    //tx_backend.reserve(cmds_count * 4);
+    //rx_backend.reserve(cmds_count * 4);
+    Buffer tx_buff(tx_backend), rx_buff(rx_backend);
+    //Buffer tx_buff, rx_buff;
     std::promise<void> completion_promise;
     auto completion_future = completion_promise.get_future();
 
@@ -109,7 +118,7 @@ int main(int argc, char **argv) {
             // cannot be done with drop_result
             //auto &replies = get<r::markers::array_holder_t<Iterator>>(r.result);
             //count += replies.elements.size() - 1;
-            count = cmds_count;
+            count = static_cast<int>(cmds_count);
             completion_promise.set_value();
             std::cout << "done reading...\n";
         },
diff --git a/include/bredis/Connection.hpp b/include/bredis/Connection.hpp
@@ -19,7 +19,6 @@
 
 #include <boost/asio.hpp>
 #include <boost/asio/async_result.hpp>
-#include <boost/asio/handler_type.hpp>
 #include <boost/utility/string_ref.hpp>
 
 #include "Command.hpp"
diff --git a/include/bredis/Protocol.hpp b/include/bredis/Protocol.hpp
@@ -21,8 +21,9 @@ class Protocol {
     static inline parse_result_t<Iterator, Policy> parse(const Iterator &from,
                                                          const Iterator &to);
 
-    static inline std::ostream &serialize(std::ostream &buff,
-                                          const single_command_t &cmd);
+    template <typename DynamicBuffer>
+    static inline void serialize(DynamicBuffer &buff,
+                                 const single_command_t &cmd);
 };
 
 } // namespace bredis
diff --git a/include/bredis/impl/common.ipp b/include/bredis/impl/common.ipp
@@ -74,21 +74,20 @@ template <typename Iterator> class MatchResult {
     }
 };
 
+template <typename DynamicBuffer>
 class command_serializer_visitor : public boost::static_visitor<void> {
   private:
-    std::ostream &out_;
+    DynamicBuffer &buff_;
 
   public:
-    command_serializer_visitor(std::ostream &out) : out_{out} {}
+    command_serializer_visitor(DynamicBuffer &buff) : buff_{buff} {}
     void operator()(const single_command_t &value) const {
-        out_.imbue(std::locale::classic());
-        Protocol::serialize(out_, value);
+        Protocol::serialize(buff_, value);
     }
 
     void operator()(const command_container_t &value) const {
-        out_.imbue(std::locale::classic());
         for (const auto &cmd : value) {
-            Protocol::serialize(out_, cmd);
+            Protocol::serialize(buff_, cmd);
         }
     }
 };
diff --git a/include/bredis/impl/connection.ipp b/include/bredis/impl/connection.ipp
@@ -26,16 +26,20 @@ Connection<NextLayer>::async_write(DynamicBuffer &tx_buff,
                                    WriteCallback &&write_callback) {
     namespace asio = boost::asio;
     namespace sys = boost::system;
+
     using boost::asio::async_write;
     using Signature = void(boost::system::error_code, std::size_t);
-    using real_handler_t =
-        typename asio::handler_type<WriteCallback, Signature>::type;
+    using Callback = std::decay_t<WriteCallback>;
+    using AsyncResult = asio::async_result<Callback, Signature>;
+    using CompletionHandler = typename AsyncResult::completion_handler_type;
+    using serializer_t = command_serializer_visitor<DynamicBuffer>;
 
-    std::ostream os(&tx_buff);
-    boost::apply_visitor(command_serializer_visitor(os), command);
+    boost::apply_visitor(serializer_t(tx_buff), command);
 
-    real_handler_t handler(std::forward<WriteCallback>(write_callback));
-    return async_write(stream_, tx_buff, handler);
+    CompletionHandler handler(std::forward<WriteCallback>(write_callback));
+    AsyncResult result(handler);
+    async_write(stream_, tx_buff, std::move(handler));
+    return result.get();
 }
 
 template <typename NextLayer>
@@ -49,31 +53,35 @@ Connection<NextLayer>::async_read(DynamicBuffer &rx_buff,
 
     namespace asio = boost::asio;
     namespace sys = boost::system;
+
     using boost::asio::async_read_until;
     using Iterator = typename to_iterator<DynamicBuffer>::iterator_t;
     using ParseResult = BREDIS_PARSE_RESULT(DynamicBuffer, Policy);
     using Signature = void(boost::system::error_code, ParseResult);
-    using real_handler_t =
-        typename asio::handler_type<ReadCallback, Signature>::type;
+    using Callback = std::decay_t<ReadCallback>;
+    using AsyncResult = asio::async_result<Callback, Signature>;
+    using CompletionHandler = typename AsyncResult::completion_handler_type;
+    using ReadOp =
+        async_read_op<NextLayer, DynamicBuffer, CompletionHandler, Policy>;
 
-    real_handler_t real_handler(std::forward<ReadCallback>(read_callback));
-    asio::async_result<real_handler_t> async_result(real_handler);
+    CompletionHandler handler(std::forward<ReadCallback>(read_callback));
+    AsyncResult result(handler);
 
-    async_read_op<NextLayer, DynamicBuffer, real_handler_t, Policy> async_op(
-        std::move(real_handler), stream_, rx_buff, replies_count);
+    ReadOp async_op(std::move(handler), stream_, rx_buff, replies_count);
 
     async_read_until(stream_, rx_buff, MatchResult<Iterator>(replies_count),
                      std::move(async_op));
-    return async_result.get();
+    return result.get();
 }
 
 template <typename NextLayer>
 void Connection<NextLayer>::write(const command_wrapper_t &command,
                                   boost::system::error_code &ec) {
     namespace asio = boost::asio;
     asio::streambuf tx_buff;
-    std::ostream os(&tx_buff);
-    boost::apply_visitor(command_serializer_visitor(os), command);
+    using serializer_t = command_serializer_visitor<asio::streambuf>;
+
+    boost::apply_visitor(serializer_t(tx_buff), command);
     asio::write(stream_, tx_buff, ec);
 }
 
@@ -93,6 +101,7 @@ Connection<NextLayer>::read(DynamicBuffer &rx_buff,
                             boost::system::error_code &ec) {
     namespace asio = boost::asio;
     using boost::asio::read_until;
+
     using Iterator = typename to_iterator<DynamicBuffer>::iterator_t;
     using Policy = bredis::parsing_policy::keep_result;
     using result_t = BREDIS_PARSE_RESULT(DynamicBuffer, Policy);
diff --git a/include/bredis/impl/protocol.ipp b/include/bredis/impl/protocol.ipp
@@ -7,9 +7,11 @@
 #pragma once
 
 #include <algorithm>
+#include <boost/asio/buffer.hpp>
 #include <boost/asio/buffers_iterator.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/variant.hpp>
+#include <cstdio>
 #include <errno.h>
 #include <stdlib.h>
 #include <string>
@@ -434,14 +436,56 @@ parse_result_t<Iterator, Policy> Protocol::parse(const Iterator &from,
     return details::raw_parse<Iterator, Policy>(from, to);
 }
 
-std::ostream &Protocol::serialize(std::ostream &buff,
-                                  const single_command_t &cmd) {
-    buff << '*' << (cmd.arguments.size()) << terminator;
+inline std::size_t size_for_int(std::size_t arg) {
+    std::size_t r = 0;
+    while (arg) {
+        ++r;
+        arg /= 10;
+    }
+    return r;
+}
+
+inline std::size_t command_size(const single_command_t &cmd) {
+    std::size_t sz = 1                                    /* * */
+                     + size_for_int(cmd.arguments.size()) /* args size */
+                     + terminator.size;
+
+    for (const auto &arg : cmd.arguments) {
+        sz += 1                          /* $ */
+              + size_for_int(arg.size()) /* argument size */
+              + terminator.size + arg.size() + terminator.size;
+    }
+    return sz;
+}
+
+template <typename DynamicBuffer>
+inline void Protocol::serialize(DynamicBuffer &buff,
+                                const single_command_t &cmd) {
+
+    auto it = buff.prepare(command_size(cmd));
+    constexpr std::size_t buff_sz = 64;
+    using namespace boost::asio;
+    char data[buff_sz];
+    std::size_t total =
+        snprintf(data, buff_sz, "*%zu\r\n", cmd.arguments.size());
+    buffer_copy(it, buffer(data, total));
+    it += total;
 
     for (const auto &arg : cmd.arguments) {
-        buff << '$' << arg.size() << terminator << arg << terminator;
+        auto bytes = snprintf(data, buff_sz, "$%zu\r\n", arg.size());
+        buffer_copy(it, buffer(data, bytes));
+        it += bytes;
+        total += bytes;
+
+        buffer_copy(it, buffer(arg.data(), arg.size()));
+        it += arg.size();
+        total += arg.size();
+
+        buffer_copy(it, buffer("\r\n", terminator.size));
+        total += terminator.size;
+        it += terminator.size;
     }
-    return buff;
+    buff.commit(total);
 }
 
 } // namespace bredis
diff --git a/t/05-protocol.cpp b/t/05-protocol.cpp
@@ -1,6 +1,7 @@
 #include <boost/asio/buffer.hpp>
 #include <vector>
 
+#include <boost/asio.hpp>
 #include "bredis/MarkerHelpers.hpp"
 #include "bredis/Protocol.hpp"
 #include "catch.hpp"
@@ -442,10 +443,24 @@ TEST_CASE("overfilled buffer", "[protocol]") {
             nullptr);
 }
 
-TEST_CASE("serialize", "[protocol]") {
-    std::stringstream buff;
+TEST_CASE("serialize + streambuf", "[protocol]") {
+    boost::asio::streambuf buff;
     r::single_command_t cmd("LLEN", "fmm.cheap-travles2");
     r::Protocol::serialize(buff, cmd);
     std::string expected("*2\r\n$4\r\nLLEN\r\n$18\r\nfmm.cheap-travles2\r\n");
-    REQUIRE(buff.str() == expected);
+
+    char data[128] = {0};
+    asio::buffer_copy(asio::buffer(data), asio::buffer(buff.data(), buff.size()));
+    REQUIRE(data == expected);
+}
+
+TEST_CASE("serialize + dynamic_string_buffer", "[protocol]") {
+    r::single_command_t cmd("LLEN", "fmm.cheap-travles2");
+    std::string buff_backend;
+    using Buff = asio::dynamic_string_buffer<char, std::char_traits<char>, std::allocator<char>>;
+    auto buff =  Buff(buff_backend);
+    r::Protocol::serialize(buff, cmd);
+    std::string expected("*2\r\n$4\r\nLLEN\r\n$18\r\nfmm.cheap-travles2\r\n");
+    std::string copy(std::begin(buff_backend), std::begin(buff_backend) + buff.size());
+    REQUIRE(copy == expected);
 }
diff --git a/t/11-multi-ping.cpp b/t/11-multi-ping.cpp
@@ -1,6 +1,7 @@
 #include <boost/asio.hpp>
 #include <future>
 #include <vector>
+#include <string>
 
 #include "EmptyPort.hpp"
 #include "SocketWithLogging.hpp"
@@ -39,11 +40,7 @@ TEST_CASE("ping", "[connection]") {
 
     size_t count = 1000;
     r::single_command_t ping_cmd("ping");
-    r::command_container_t ping_cmds_container;
-    ping_cmds_container.reserve(count);
-    for (size_t i = 0; i < count; ++i) {
-        ping_cmds_container.push_back(ping_cmd);
-    }
+    r::command_container_t ping_cmds_container(count, ping_cmd);
     r::command_wrapper_t cmd(ping_cmds_container);
 
     uint16_t port = ep::get_random<ep::Kind::TCP>();
@@ -79,6 +76,7 @@ TEST_CASE("ping", "[connection]") {
 
     write_callback_t write_callback = [&](
         const boost::system::error_code &error_code, auto bytes_transferred) {
+        (void)bytes_transferred;
         BREDIS_LOG_DEBUG("write_callback");
         if (error_code) {
             BREDIS_LOG_DEBUG("error: " << error_code.message());
diff --git a/t/24-dynbuff.cpp b/t/24-dynbuff.cpp

Original file line number	Diff line number	Diff line change
`@@ -74,21 +74,20 @@ template <typename Iterator> class MatchResult {`
`74`	`74`	`}`
`75`	`75`	`};`
`76`	`76`
	`77`	`+template <typename DynamicBuffer>`
`77`	`78`	`class command_serializer_visitor : public boost::static_visitor<void> {`
`78`	`79`	`private:`
`79`		`- std::ostream &out_;`
	`80`	`+ DynamicBuffer &buff_;`
`80`	`81`
`81`	`82`	`public:`
`82`		`- command_serializer_visitor(std::ostream &out) : out_{out} {}`
	`83`	`+ command_serializer_visitor(DynamicBuffer &buff) : buff_{buff} {}`
`83`	`84`	`void operator()(const single_command_t &value) const {`
`84`		`- out_.imbue(std::locale::classic());`
`85`		`- Protocol::serialize(out_, value);`
	`85`	`+ Protocol::serialize(buff_, value);`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`void operator()(const command_container_t &value) const {`
`89`		`- out_.imbue(std::locale::classic());`
`90`	`89`	`for (const auto &cmd : value) {`
`91`		`- Protocol::serialize(out_, cmd);`
	`90`	`+ Protocol::serialize(buff_, cmd);`
`92`	`91`	`}`
`93`	`92`	`}`
`94`	`93`	`};`