Ichthyostega
88b91d204c
...while reworking the application code, it became clear that actually there are two further quite distinct variants of usage. And while these could be implemented with some trickery based on the Thread-wrapper defined thus far, it seems prudent better to establish a safely confined explicit setup for these cases: - a fire-and-forget-thread, which manages its own memory autonomously - a thread with explicit lifecycle, with detectable not-running state
145 lines
5 KiB
C++
145 lines
5 KiB
C++
/*
|
|
ThreadWrapperAutonomous(Test) - launching a self-contained and completely detached thread
|
|
|
|
Copyright (C) Lumiera.org
|
|
2023, Hermann Vosseler <Ichthyostega@web.de>
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of
|
|
the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
* *****************************************************/
|
|
|
|
/** @file thread-wrapper-autonomous-test.cpp
|
|
** unit test \ref ThreadWrapperAutonomous_test
|
|
*/
|
|
|
|
|
|
#include "lib/test/run.hpp"
|
|
#include "lib/thread.hpp"
|
|
#include "lib/iter-explorer.hpp"
|
|
#include "lib/scoped-collection.hpp"
|
|
#include "lib/test/microbenchmark.hpp"
|
|
|
|
#include <atomic>
|
|
#include <chrono>
|
|
|
|
using test::Test;
|
|
using lib::explore;
|
|
using std::atomic_uint;
|
|
using std::this_thread::yield;
|
|
using std::this_thread::sleep_for;
|
|
using std::chrono::microseconds;
|
|
|
|
|
|
namespace lib {
|
|
namespace test{
|
|
|
|
namespace { // test parameters
|
|
|
|
const uint NUM_THREADS = 200;
|
|
const uint REPETITIONS = 10;
|
|
}
|
|
|
|
|
|
/*******************************************************************//**
|
|
* @test a variation of the Thread wrapper to launch a detached thread,
|
|
* with automatic memory management for the _thread-object._.
|
|
* @see thread.hpp
|
|
* @see ThreadWrapper_test
|
|
*/
|
|
class ThreadWrapperAutonomous_test : public Test
|
|
{
|
|
|
|
virtual void
|
|
run (Arg)
|
|
{
|
|
demonstrateSimpleUsage();
|
|
verifyMemoryManagement();
|
|
}
|
|
|
|
|
|
/** @test demonstrate simply launching a λ-function into background */
|
|
void
|
|
demonstrateSimpleUsage()
|
|
{
|
|
atomic_uint i{0};
|
|
Thread thread("counter", [&]{ ++i; }); // bind a λ and launch thread
|
|
while (thread) yield(); // ensure thread has finished and detached
|
|
|
|
CHECK (i == 1); // verify the effect has taken place
|
|
UNIMPLEMENTED ("actually launch detached");
|
|
}
|
|
|
|
|
|
/**
|
|
* @test verify the detached thread autonomously manages its memory.
|
|
*/
|
|
void
|
|
verifyMemoryManagement()
|
|
{
|
|
struct TestThread
|
|
: Thread
|
|
{
|
|
using Thread::Thread;
|
|
|
|
uint local{0};
|
|
|
|
void
|
|
doIt (uint a, uint b) ///< the actual operation running in a separate thread
|
|
{
|
|
uint sum = a + b;
|
|
sleep_for (microseconds{sum}); // Note: explicit random delay before local store
|
|
local = sum;
|
|
}
|
|
};
|
|
|
|
// prepare Storage for these objects (not created yet)
|
|
lib::ScopedCollection<TestThread> threads{NUM_THREADS};
|
|
|
|
size_t checkSum = 0;
|
|
size_t globalSum = 0;
|
|
auto launchThreads = [&]
|
|
{
|
|
for (uint i=1; i<=NUM_THREADS; ++i)
|
|
{
|
|
uint x = rand() % 1000;
|
|
globalSum += (i + x);
|
|
threads.emplace (&TestThread::doIt, i, x);
|
|
} // Note: bind to member function, copying arguments
|
|
|
|
while (explore(threads).has_any())
|
|
yield(); // wait for all threads to have detached
|
|
|
|
for (auto& t : threads)
|
|
{
|
|
CHECK (0 < t.local);
|
|
checkSum += t.local;
|
|
}
|
|
};
|
|
|
|
double runTime = benchmarkTime (launchThreads, REPETITIONS);
|
|
|
|
CHECK (checkSum == globalSum); // sum of precomputed random numbers matches sum from threads
|
|
CHECK (runTime < NUM_THREADS * 1000/2); // random sleep time should be > 500ms on average
|
|
}
|
|
};
|
|
|
|
|
|
|
|
/** Register this test class... */
|
|
LAUNCHER (ThreadWrapperAutonomous_test, "function common");
|
|
|
|
|
|
|
|
}} // namespace lib::test
|