Merge pull request #19863 from ClickHouse/improve-server-latency

Maybe improve server latency

src/Client/tests/test_connect.cpp

@@ -7,8 +7,10 @@
 #include <atomic>
 #include <Poco/Net/StreamSocket.h>
 #include <Common/Exception.h>
-#include <Common/Stopwatch.h>
+#include <Common/ShellCommand.h>
 #include <IO/ReadHelpers.h>
+#include <IO/WriteBufferFromFileDescriptor.h>
+#include <IO/copyData.h>
 
 
 /** In a loop it connects to the server and immediately breaks the connection.
@@ -18,22 +20,26 @@
 int main(int argc, char ** argv)
 try
 {
+    using namespace DB;
+
     size_t num_iterations = 1;
     size_t num_threads = 1;
     std::string host = "localhost";
     uint16_t port = 9000;
 
     if (argc >= 2)
-        num_iterations = DB::parse<size_t>(argv[1]);
+        num_iterations = parse<size_t>(argv[1]);
 
     if (argc >= 3)
-        num_threads = DB::parse<size_t>(argv[2]);
+        num_threads = parse<size_t>(argv[2]);
 
     if (argc >= 4)
         host = argv[3];
 
     if (argc >= 5)
-        port = DB::parse<uint16_t>(argv[4]);
+        port = parse<uint16_t>(argv[4]);
+
+    WriteBufferFromFileDescriptor out(STDERR_FILENO);
 
     std::atomic_bool cancel{false};
     std::vector<std::thread> threads(num_threads);
@@ -45,44 +51,32 @@ try
             {
                 std::cerr << ".";
 
-                Poco::Net::SocketAddress address(host, port);
-
-                int fd = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
-
-                if (fd < 0)
-                    DB::throwFromErrno("Cannot create socket", 0);
-
-                linger linger_value;
-                linger_value.l_onoff = 1;
-                linger_value.l_linger = 0;
-
-                if (0 != setsockopt(fd, SOL_SOCKET, SO_LINGER, &linger_value, sizeof(linger_value)))
-                    DB::throwFromErrno("Cannot set linger", 0);
-
                 try
                 {
-                    Stopwatch watch;
+                    Poco::Net::SocketAddress address(host, port);
+                    Poco::Net::StreamSocket socket;
+                    //socket.setLinger(1, 0);
 
-                    int res = connect(fd, address.addr(), address.length());
-
-                    if (res != 0 && errno != EINPROGRESS && errno != EWOULDBLOCK)
+                    socket.connectNB(address);
+                    if (!socket.poll(Poco::Timespan(1000000),
+                        Poco::Net::Socket::SELECT_READ | Poco::Net::Socket::SELECT_WRITE | Poco::Net::Socket::SELECT_ERROR))
                     {
-                        close(fd);
-                        DB::throwFromErrno("Cannot connect", 0);
-                    }
+                        /// Allow to debug the server.
+/*                        auto command = ShellCommand::execute("kill -STOP $(pidof clickhouse-server)");
+                        copyData(command->err, out);
+                        copyData(command->out, out);
+                        command->wait();*/
 
-                    close(fd);
-
-                    if (watch.elapsedSeconds() > 0.1)
-                    {
-                        std::cerr << watch.elapsedSeconds() << "\n";
-                        cancel = true;
-                        break;
+                        std::cerr << "Timeout\n";
+/*                        cancel = true;
+                        break;*/
                     }
                 }
                 catch (const Poco::Exception & e)
                 {
                     std::cerr << e.displayText() << "\n";
+                    cancel = true;
+                    break;
                 }
             }
         });

src/Server/TCPHandler.h

@@ -109,15 +109,16 @@ public:
       *  because it allows to check the IP ranges of the trusted proxy.
       * Proxy-forwarded (original client) IP address is used for quota accounting if quota is keyed by forwarded IP.
       */
-    TCPHandler(IServer & server_, const Poco::Net::StreamSocket & socket_, bool parse_proxy_protocol_)
+    TCPHandler(IServer & server_, const Poco::Net::StreamSocket & socket_, bool parse_proxy_protocol_,
+        std::string server_display_name_)
         : Poco::Net::TCPServerConnection(socket_)
         , server(server_)
         , parse_proxy_protocol(parse_proxy_protocol_)
         , log(&Poco::Logger::get("TCPHandler"))
         , connection_context(server.context())
         , query_context(server.context())
+        , server_display_name(std::move(server_display_name_))
     {
-        server_display_name = server.config().getString("display_name", getFQDNOrHostName());
     }
 
     void run() override;

src/Server/TCPHandlerFactory.h

@@ -17,6 +17,7 @@ private:
     IServer & server;
     bool parse_proxy_protocol = false;
     Poco::Logger * log;
+    std::string server_display_name;
 
     class DummyTCPHandler : public Poco::Net::TCPServerConnection
     {
@@ -34,6 +35,7 @@ public:
         : server(server_), parse_proxy_protocol(parse_proxy_protocol_)
         , log(&Poco::Logger::get(std::string("TCP") + (secure_ ? "S" : "") + "HandlerFactory"))
     {
+        server_display_name = server.config().getString("display_name", getFQDNOrHostName());
     }
 
     Poco::Net::TCPServerConnection * createConnection(const Poco::Net::StreamSocket & socket) override
@@ -42,7 +44,7 @@ public:
         {
             LOG_TRACE(log, "TCP Request. Address: {}", socket.peerAddress().toString());
 
-            return new TCPHandler(server, socket, parse_proxy_protocol);
+            return new TCPHandler(server, socket, parse_proxy_protocol, server_display_name);
         }
         catch (const Poco::Net::NetException &)
         {