multithread wip

Author: drewdzzz

CMakeLists.txt

@@ -209,6 +209,11 @@ TNTCXX_TEST(NAME Client.test TYPE ctest
             LIBRARIES ${COMMON_LIB}
 )
 
+TNTCXX_TEST(NAME ClientMultithread.test TYPE ctest
+            SOURCES src/Client/Connector.hpp test/ClientMultithreadTest.cpp
+            LIBRARIES ${COMMON_LIB}
+)
+
 IF (TNTCXX_ENABLE_SSL)
     TNTCXX_TEST(NAME ClientSSL.test TYPE ctest
                SOURCES src/Client/Connector.hpp test/ClientTest.cpp

src/Client/Connection.hpp

@@ -612,7 +612,7 @@ Connection<BUFFER, NetProvider>::execute(const std::string& statement, const T&
 {
     impl->enc.encodeExecute(statement, parameters);
     impl->connector.readyToSend(*this);
-    return RequestEncoder<BUFFER>::getSync();
+    return impl->enc.getSync();
 }
 
 template<class BUFFER, class NetProvider>
@@ -622,7 +622,7 @@ Connection<BUFFER, NetProvider>::execute(unsigned int stmt_id, const T& paramete
 {
     impl->enc.encodeExecute(stmt_id, parameters);
     impl->connector.readyToSend(*this);
-    return RequestEncoder<BUFFER>::getSync();
+    return impl->enc.getSync();
 }
 
 template<class BUFFER, class NetProvider>
@@ -631,7 +631,7 @@ Connection<BUFFER, NetProvider>::prepare(const std::string& statement)
 {
     impl->enc.encodePrepare(statement);
     impl->connector.readyToSend(*this);
-    return RequestEncoder<BUFFER>::getSync();
+    return impl->enc.getSync();
 }
 
 template<class BUFFER, class NetProvider>
@@ -641,7 +641,7 @@ Connection<BUFFER, NetProvider>::call(const std::string &func, const T &args)
 {
 	impl->enc.encodeCall(func, args);
 	impl->connector.readyToSend(*this);
-	return RequestEncoder<BUFFER>::getSync();
+	return impl->enc.getSync();
 }
 
 template<class BUFFER, class NetProvider>
@@ -650,7 +650,7 @@ Connection<BUFFER, NetProvider>::ping()
 {
 	impl->enc.encodePing();
 	impl->connector.readyToSend(*this);
-	return RequestEncoder<BUFFER>::getSync();
+	return impl->enc.getSync();
 }
 
 template<class BUFFER, class NetProvider>
@@ -660,7 +660,7 @@ Connection<BUFFER, NetProvider>::insert(const T &tuple, uint32_t space_id)
 {
 	impl->enc.encodeInsert(tuple, space_id);
 	impl->connector.readyToSend(*this);
-	return RequestEncoder<BUFFER>::getSync();
+	return impl->enc.getSync();
 }
 
 template<class BUFFER, class NetProvider>
@@ -670,7 +670,7 @@ Connection<BUFFER, NetProvider>::replace(const T &tuple, uint32_t space_id)
 {
 	impl->enc.encodeReplace(tuple, space_id);
 	impl->connector.readyToSend(*this);
-	return RequestEncoder<BUFFER>::getSync();
+	return impl->enc.getSync();
 }
 
 template<class BUFFER, class NetProvider>
@@ -681,7 +681,7 @@ Connection<BUFFER, NetProvider>::delete_(const T &key, uint32_t space_id,
 {
 	impl->enc.encodeDelete(key, space_id, index_id);
 	impl->connector.readyToSend(*this);
-	return RequestEncoder<BUFFER>::getSync();
+	return impl->enc.getSync();
 }
 
 template<class BUFFER, class NetProvider>
@@ -692,7 +692,7 @@ Connection<BUFFER, NetProvider>::update(const K &key, const T &tuple,
 {
 	impl->enc.encodeUpdate(key, tuple, space_id, index_id);
 	impl->connector.readyToSend(*this);
-	return RequestEncoder<BUFFER>::getSync();
+	return impl->enc.getSync();
 }
 
 template<class BUFFER, class NetProvider>
@@ -703,7 +703,7 @@ Connection<BUFFER, NetProvider>::upsert(const T &tuple, const O &ops,
 {
 	impl->enc.encodeUpsert(tuple, ops, space_id, index_base);
 	impl->connector.readyToSend(*this);
-	return RequestEncoder<BUFFER>::getSync();
+	return impl->enc.getSync();
 }
 
 template<class BUFFER, class NetProvider>
@@ -716,7 +716,7 @@ Connection<BUFFER, NetProvider>::select(const T &key, uint32_t space_id,
 	impl->enc.encodeSelect(key, space_id, index_id, limit,
 					       offset, iterator);
 	impl->connector.readyToSend(*this);
-	return RequestEncoder<BUFFER>::getSync();
+	return impl->enc.getSync();
 }
 
 template<class BUFFER, class NetProvider>

src/Client/RequestEncoder.hpp

@@ -97,12 +97,12 @@ class RequestEncoder {
 			  const Greeting &greet);
 
 	/** Sync value is used as request id. */
-	static size_t getSync() { return sync; }
+	size_t getSync() { return sync; }
 	static constexpr size_t PREHEADER_SIZE = 5;
 private:
 	void encodeHeader(int request);
 	BUFFER &m_Buf;
-	inline static ssize_t sync = 0;
+	ssize_t sync = 0;
 };
 
 template<class BUFFER>

test/ClientMultithreadTest.cpp

@@ -0,0 +1,133 @@
+/*
+ * Copyright 2010-2020, Tarantool AUTHORS, please see AUTHORS file.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above
+ *    copyright notice, this list of conditions and the
+ *    following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#include "Utils/Helpers.hpp"
+#include "Utils/System.hpp"
+#include "Utils/UserTuple.hpp"
+
+#include "../src/Client/LibevNetProvider.hpp"
+#include "../src/Client/Connector.hpp"
+
+#include <thread>
+
+const char *localhost = "127.0.0.1";
+int port = 3301;
+int dummy_server_port = 3302;
+const char *unixsocket = "./tnt.sock";
+int WAIT_TIMEOUT = 1000; //milliseconds
+
+using Buf_t = tnt::Buffer<16 * 1024, tnt::MempoolInstance<16 * 1024>>;
+
+#ifdef TNTCXX_ENABLE_SSL
+constexpr bool enable_ssl = true;
+constexpr StreamTransport transport = STREAM_SSL;
+#else
+constexpr bool enable_ssl = false;
+constexpr StreamTransport transport = STREAM_PLAIN;
+#endif
+
+#ifdef __linux__
+using NetProvider = EpollNetProvider<Buf_t, DefaultStream>;
+#else
+using NetProvider = LibevNetProvider<Buf_t, DefaultStream>;
+#endif
+
+template <class Connector, class Connection>
+static int
+test_connect(Connector &client, Connection &conn, const std::string &addr,
+	     unsigned port,
+	     const std::string user = {}, const std::string passwd = {})
+{
+	std::string service = port == 0 ? std::string{} : std::to_string(port);
+	return client.connect(conn, {
+		.address = addr,
+		.service = service,
+		.transport = transport,
+		.user = user,
+		.passwd = passwd,
+	});
+}
+
+void
+single_conn_ping(void)
+{
+	TEST_INIT(0);
+	static constexpr int ITER_NUM = 10000;
+	static constexpr int THREAD_NUM = 100;
+	std::vector<std::thread> threads;
+	threads.reserve(THREAD_NUM);
+	for (int t = 0; t < THREAD_NUM; t++) {
+		threads.emplace_back([]() {
+			Connector<Buf_t, NetProvider> client;
+			Connection<Buf_t, NetProvider> conn(client);
+			int rc = test_connect(client, conn, localhost, port);
+			fail_unless(rc == 0);
+
+			for (int i = 0; i < ITER_NUM; i++) {
+				rid_t f = conn.ping();
+				fail_unless(!conn.futureIsReady(f));
+				client.wait(conn, f, WAIT_TIMEOUT);
+				fail_unless(conn.futureIsReady(f));
+				std::optional<Response<Buf_t>> response = conn.getResponse(f);
+				fail_unless(response != std::nullopt);
+				fail_unless(response->header.code == 0);
+			}
+		});
+	}
+	for (auto &thread : threads)
+		thread.join();
+}
+
+int main()
+{
+#ifdef TNTCXX_ENABLE_SSL
+#ifndef __FreeBSD__
+	// There's no way to disable SIGPIPE for SSL on non-FreeBSD platforms,
+	// so it is needed to disable signal handling.
+	signal(SIGPIPE, SIG_IGN);
+#endif
+#endif
+
+	if (cleanDir() != 0)
+		return -1;
+
+#ifdef TNTCXX_ENABLE_SSL
+	if (genSSLCert() != 0)
+		return -1;
+#endif
+
+	if (launchTarantool(enable_ssl) != 0)
+		return -1;
+
+	sleep(1);
+
+	single_conn_ping();
+	return 0;
+}