Add loops in stress tests to test adaptor/proxy initialization/deinitialization

test/perftests/server.cpp

@@ -54,7 +54,6 @@ protected:
     virtual void sendDataSignals(const uint32_t& numberOfSignals, const uint32_t& signalMsgSize) override
     {
         auto data = createRandomString(signalMsgSize);
-        char digits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
 
         auto start_time = std::chrono::steady_clock::now();
         for (uint32_t i = 0; i < numberOfSignals; ++i)

test/stresstests/sdbus-c++-stress-tests.cpp

@@ -37,6 +37,7 @@
 #include <thread>
 #include <chrono>
 #include <cassert>
+#include <cstdlib>
 #include <atomic>
 #include <sstream>
 #include <mutex>
@@ -319,7 +320,7 @@ private:
 
         uint32_t aNumber;
         str >> aNumber;
-        assert(aNumber >= 0);
+        assert(aNumber > 0);
 
         ++repliesReceived_;
     }
@@ -333,7 +334,7 @@ private:
 
         uint32_t aNumber;
         str >> aNumber;
-        assert(aNumber >= 0);
+        assert(aNumber > 0);
 
         ++signalsReceived_;
     }
@@ -344,8 +345,47 @@ public:
 };
 
 //-----------------------------------------
-int main(int /*argc*/, char */*argv*/[])
+int main(int argc, char *argv[])
 {
+    long loops;
+    long loopDuration;
+
+    if (argc == 1)
+    {
+        loops = 1;
+        loopDuration = 30000;
+    }
+    else if (argc == 3)
+    {
+        loops = std::atol(argv[1]);
+        loopDuration = std::atol(argv[2]);
+    }
+    else
+        throw std::runtime_error("Wrong program options");
+
+    std::cout << "Going on with " << loops << " loops and " << loopDuration << "ms loop duration" << std::endl;
+
+    std::atomic<uint32_t> concatenationCallsMade{0};
+    std::atomic<uint32_t> concatenationRepliesReceived{0};
+    std::atomic<uint32_t> concatenationSignalsReceived{0};
+    std::atomic<uint32_t> thermometerCallsMade{0};
+
+    std::atomic<bool> exitLogger{};
+    std::thread loggerThread([&]()
+    {
+        while (!exitLogger)
+        {
+            std::this_thread::sleep_for(1s);
+
+            std::cout << "Made " << concatenationCallsMade << " concatenation calls, received " << concatenationRepliesReceived << " replies and " << concatenationSignalsReceived << " signals so far." << std::endl;
+            std::cout << "Made " << thermometerCallsMade << " thermometer calls so far." << std::endl << std::endl;
+        }
+    });
+
+    for (long loop = 0; loop < loops; ++loop)
+    {
+        std::cout << "Entering loop " << loop+1 << std::endl;
+
         auto service2Connection = sdbus::createSystemBusConnection(SERVICE_2_BUS_NAME);
         std::atomic<bool> service2ThreadReady{};
         std::thread service2Thread([&con = *service2Connection, &service2ThreadReady]()
@@ -369,12 +409,10 @@ int main(int /*argc*/, char */*argv*/[])
         while (!service2ThreadReady || !service1ThreadReady)
             std::this_thread::sleep_for(1ms);
 
-    std::atomic<uint32_t> concatenationCallsMade{0};
-    std::atomic<uint32_t> concatenationRepliesReceived{0};
-    std::atomic<uint32_t> concatenationSignalsReceived{0};
-    std::atomic<uint32_t> thermometerCallsMade{0};
-
         auto clientConnection = sdbus::createSystemBusConnection();
+        std::mutex clientThreadExitMutex;
+        std::condition_variable clientThreadExitCond;
+        bool clientThreadExit{};
         std::thread clientThread([&, &con = *clientConnection]()
         {
             std::atomic<bool> stopClients{false};
@@ -390,7 +428,7 @@ int main(int /*argc*/, char */*argv*/[])
                 {
                     std::map<std::string, sdbus::Variant> param;
                     param["key1"] = "sdbus-c++-stress-tests";
-                param["key2"] = localCounter++;
+                    param["key2"] = ++localCounter;
 
                     concatenator.concatenate(param);
 
@@ -440,35 +478,37 @@ int main(int /*argc*/, char */*argv*/[])
                 }
             });
 
-        con.enterProcessingLoop();
+            // We could run the loop in a sync way, but we want it to run also when proxies are destroyed for better
+            // coverage of multi-threaded scenarios, so we run it async and use condition variable for exit notification
+            //con.enterProcessingLoop();
+            con.enterProcessingLoopAsync();
+
+            std::unique_lock<std::mutex> lock(clientThreadExitMutex);
+            clientThreadExitCond.wait(lock, [&]{return clientThreadExit;});
 
             stopClients = true;
-        concatenatorThread.join();
             thermometerThread.join();
+            concatenatorThread.join();
         });
 
-    std::atomic<bool> exitLogger{};
+        std::this_thread::sleep_for(std::chrono::milliseconds(loopDuration));
-    std::thread loggerThread([&]()
-    {
-        while (!exitLogger)
-        {
-            std::this_thread::sleep_for(1s);
 
-            std::cout << "Made " << concatenationCallsMade << " concatenation calls, received " << concatenationRepliesReceived << " replies and " << concatenationSignalsReceived << " signals so far." << std::endl;
+        //clientConnection->leaveProcessingLoop();
-            std::cout << "Made " << thermometerCallsMade << " thermometer calls so far." << std::endl << std::endl;
+        std::unique_lock<std::mutex> lock(clientThreadExitMutex);
+        clientThreadExit = true;
+        lock.unlock();
+        clientThreadExitCond.notify_one();
+        clientThread.join();
+
+        service1Connection->leaveProcessingLoop();
+        service1Thread.join();
+
+        service2Connection->leaveProcessingLoop();
+        service2Thread.join();
     }
-    });
-
-    getchar();
 
     exitLogger = true;
     loggerThread.join();
-    clientConnection->leaveProcessingLoop();
-    clientThread.join();
-    service1Connection->leaveProcessingLoop();
-    service1Thread.join();
-    service2Connection->leaveProcessingLoop();
-    service2Thread.join();
     
     return 0;
 }