Use TSAN on futures test. Continue implementation of simulator

src/io/v3/transport.hpp

@@ -65,14 +65,12 @@ class Io {
     default_timeout_microseconds_ = timeout_microseconds;
   }
 
-  /*
-    template <Message Request, Message Response>
-    ResponseFuture<Response> RequestTimeout(Address address, Request request, uint64_t timeout_microseconds) {
-      uint64_t request_id = ++request_id_counter_;
-      return implementation_.template RequestTimeout<Request, Response>(address, request_id, request,
-                                                                        timeout_microseconds);
-    }
-    */
+  template <Message Request, Message Response>
+  ResponseFuture<Response> RequestTimeout(Address address, Request request, uint64_t timeout_microseconds) {
+    uint64_t request_id = ++request_id_counter_;
+    return implementation_.template RequestTimeout<Request, Response>(address, request_id, request,
+                                                                      timeout_microseconds);
+  }
 
   template <Message Request, Message Response>
   ResponseFuture<Response> RequestTimeout(Address address, Request request) {
@@ -82,22 +80,21 @@ class Io {
                                                                       timeout_microseconds);
   }
 
-  /*
-    template <Message... Ms>
-    RequestResult<Ms...> ReceiveTimeout(uint64_t timeout_microseconds) {
-      return implementation_.template ReceiveTimeout<Ms...>(timeout_microseconds);
-    }
+  template <Message... Ms>
+  RequestResult<Ms...> ReceiveTimeout(uint64_t timeout_microseconds) {
+    return implementation_.template ReceiveTimeout<Ms...>(timeout_microseconds);
+  }
 
-    template <Message... Ms>
-    RequestResult<Ms...> ReceiveTimeout() {
-      uint64_t timeout_microseconds = default_timeout_microseconds_;
-      return implementation_.template ReceiveTimeout<Ms...>(timeout_microseconds);
-    }
-    template <Message M>
-    void Send(Address address, uint64_t request_id, M message) {
-      return implementation_.template Send<M>(address, request_id, message);
-    }
-    */
+  template <Message... Ms>
+  RequestResult<Ms...> ReceiveTimeout() {
+    uint64_t timeout_microseconds = default_timeout_microseconds_;
+    return implementation_.template ReceiveTimeout<Ms...>(timeout_microseconds);
+  }
+
+  template <Message M>
+  void Send(Address address, uint64_t request_id, M message) {
+    return implementation_.template Send<M>(address, request_id, message);
+  }
 
   std::time_t Now() { return implementation_.Now(); }
 

tests/simulation/CMakeLists.txt

@@ -15,7 +15,7 @@ function(add_simulation_test test_cpp san)
   set_target_properties(${target_name} PROPERTIES OUTPUT_NAME ${exec_name})
   target_link_libraries(${target_name} gtest gmock gtest_main mg-utils mg-io-v3)
 
-  # sanitize?
+  # sanitize
   target_compile_options(${target_name} PRIVATE -fsanitize=${san})
   target_link_options(${target_name} PRIVATE -fsanitize=${san})
 
@@ -24,6 +24,6 @@ function(add_simulation_test test_cpp san)
   add_dependencies(memgraph__simulation ${target_name})
 endfunction(add_simulation_test)
 
-add_simulation_test(future.cpp address)
+add_simulation_test(future.cpp thread)
 
 add_simulation_test(basic_request.cpp address)

tests/simulation/basic_request.cpp

@@ -14,9 +14,10 @@
 #include <string>
 #include <vector>
 
+#include <spdlog/spdlog.h>
+
 #include "io/v3/simulator.hpp"
-//#include "io/v3/transport.hpp"
-//#include "utils/logging.hpp"
+#include "utils/terminate_handler.hpp"
 
 struct Request {
   std::string data;

tests/simulation/future.cpp

@@ -24,9 +24,9 @@ void Wait(MgFuture<std::string> future_1, MgPromise<std::string> promise_2) {
 }
 
 int main() {
-  std::atomic_bool filled = false;
+  std::atomic_bool waiting = false;
 
-  std::function<void()> notifier = [&] { filled.store(true, std::memory_order_seq_cst); };
+  std::function<void()> notifier = [&] { waiting.store(true, std::memory_order_seq_cst); };
 
   auto [future_1, promise_1] = FuturePromisePairWithNotifier<std::string>(notifier);
   auto [future_2, promise_2] = FuturePromisePair<std::string>();
@@ -35,7 +35,7 @@ int main() {
 
   // spin in a loop until the promise signals
   // that it is waiting
-  while (!filled.load(std::memory_order_acquire)) {
+  while (!waiting.load(std::memory_order_acquire)) {
     std::this_thread::yield();
   }