Adds nodejs echo_server benchmark program.

benchmarks/echo_server_client.cpp

@@ -0,0 +1,64 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <iostream>
+#include <boost/asio.hpp>
+
+namespace net = boost::asio;
+
+using net::ip::tcp;
+using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
+using timer_type = net::use_awaitable_t<>::as_default_on_t<net::steady_timer>;
+
+net::awaitable<void>
+example(boost::asio::ip::tcp::endpoint ep, std::string msg, int n)
+{
+   try {
+      auto ex = co_await net::this_coro::executor;
+
+      tcp_socket socket{ex};
+      co_await socket.async_connect(ep);
+
+      std::string buffer;
+      auto dbuffer = net::dynamic_buffer(buffer);
+      for (int i = 0; i < n; ++i) {
+         co_await net::async_write(socket, net::buffer(msg));
+         auto n = co_await net::async_read_until(socket, dbuffer, "\n");
+         //std::printf("> %s", buffer.data());
+         dbuffer.consume(n);
+      }
+
+      //std::printf("Ok: %s", msg.data());
+   } catch (std::exception const& e) {
+      std::cerr << "Error: " << e.what() << std::endl;
+   }
+}
+
+int main(int argc, char* argv[])
+{
+   try {
+      int sessions = 1;
+      int msgs = 1;
+
+      if (argc == 3) {
+         sessions = std::stoi(argv[1]);
+         msgs = std::stoi(argv[2]);
+      }
+
+      net::io_context ioc;
+
+      tcp::resolver resv{ioc};
+      auto const res = resv.resolve("127.0.0.1", "55555");
+      auto ep = *std::begin(res);
+
+      for (int i = 0; i < sessions; ++i)
+         net::co_spawn(ioc, example(ep, "Some message\n", msgs), net::detached);
+
+      ioc.run();
+   } catch (std::exception const& e) {
+      std::cerr << e.what() << std::endl;
+   }
+}

benchmarks/echo_server_direct.cpp

@@ -0,0 +1,55 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/asio/co_spawn.hpp>
+#include <boost/asio/detached.hpp>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/signal_set.hpp>
+#include <boost/asio/write.hpp>
+#include <cstdio>
+
+namespace net = boost::asio;
+namespace this_coro = net::this_coro;
+using net::ip::tcp;
+using net::awaitable;
+using net::co_spawn;
+using net::detached;
+using net::use_awaitable;
+
+awaitable<void> echo(tcp::socket socket)
+{
+  try {
+     char data[1024];
+     for (;;) {
+        std::size_t n = co_await socket.async_read_some(net::buffer(data), use_awaitable);
+        co_await async_write(socket, net::buffer(data, n), use_awaitable);
+     }
+  } catch (std::exception const& e) {
+     std::printf("echo Exception: %s\n", e.what());
+  }
+}
+
+awaitable<void> listener()
+{
+  auto executor = co_await this_coro::executor;
+  tcp::acceptor acceptor(executor, {tcp::v4(), 55555});
+  for (;;) {
+     tcp::socket socket = co_await acceptor.async_accept(use_awaitable);
+     co_spawn(executor, echo(std::move(socket)), detached);
+  }
+}
+
+int main()
+{
+  try {
+     net::io_context io_context(1);
+     co_spawn(io_context, listener(), detached);
+     io_context.run();
+  } catch (std::exception& e) {
+     std::printf("Exception: %s\n", e.what());
+  }
+}

benchmarks/echo_server_direct.js

@@ -0,0 +1,7 @@
+var net = require('net');
+
+net.createServer(function(socket){
+    socket.on('data', function(data){
+        socket.write(data.toString())
+    });
+}).listen(55555);

benchmarks/echo_server_over_redis.cpp

@@ -0,0 +1,60 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <string>
+#include <iostream>
+#include <boost/asio.hpp>
+#include <aedis/aedis.hpp>
+#include <aedis/src.hpp>
+
+namespace net = boost::asio;
+using aedis::adapt;
+using aedis::command;
+using aedis::resp3::request;
+using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
+using tcp_acceptor = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::acceptor>;
+using connection = aedis::connection<tcp_socket>;
+
+net::awaitable<void> echo_loop(tcp_socket socket, std::shared_ptr<connection> db)
+{
+   try {
+      for (std::string buffer;;) {
+         auto n = co_await net::async_read_until(socket, net::dynamic_buffer(buffer, 1024), "\n");
+         request req;
+         req.push(command::ping, buffer);
+         std::tuple<std::string> resp;
+         co_await db->async_exec(req, adapt(resp));
+         co_await net::async_write(socket, net::buffer(std::get<0>(resp)));
+         buffer.erase(0, n);
+      }
+   } catch (std::exception const& e) {
+      std::cout << e.what() << std::endl;
+   }
+}
+
+net::awaitable<void> listener(bool coalesce_requests)
+{
+   auto ex = co_await net::this_coro::executor;
+   connection::config cfg;
+   cfg.coalesce_requests = coalesce_requests;
+   auto db = std::make_shared<connection>(ex, cfg);
+   db->async_run("127.0.0.1", "6379", net::detached);
+
+   tcp_acceptor acc(ex, {net::ip::tcp::v4(), 55555});
+   for (;;)
+      net::co_spawn(ex, echo_loop(co_await acc.async_accept(), db), net::detached);
+}
+
+int main(int argc, char* argv[])
+{
+   try {
+      net::io_context ioc;
+      co_spawn(ioc, listener(argc == 1), net::detached);
+      ioc.run();
+   } catch (std::exception const& e) {
+      std::cerr << e.what() << std::endl;
+   }
+}

benchmarks/echo_server_over_redis.js

@@ -0,0 +1,13 @@
+import { createClient } from 'redis';
+import * as net from 'net';
+
+const client = createClient();
+client.on('error', (err) => console.log('Redis Client Error', err));
+await client.connect();
+
+net.createServer(function(socket){
+   socket.on('data', async function(data) {
+      const value = await client.ping(data.toString());
+      socket.write(data)
+   });
+}).listen(55555);