Ichthyostega
4f8a8e8042
As with all those C++ base types, unfortunately they are giving you only rough size guarantees. For Lumiera, I defined short hand names some time ago, notably because the explicit long X and short X qualifiers do not work with ''constructor syntax'' for direct conversions. But I choose the name `f128` at that time -- which might raise ill-guided expectations, since the `long double` is not that long on relevant linux 64bit platforms; it can just hold 64bit of mantissa at least however. As replacement, I'll use `lflo` now, because it has also 4 letters, looks somewhat weird (and thus catches attention) and points into the right direction. I considered `lfloat` as alternative, but that looks too much like `float`, visually...
256 lines
9.7 KiB
C++
256 lines
9.7 KiB
C++
/*
|
||
EngineBufferManager(Test) - cover the interface to a central buffer manager
|
||
|
||
Copyright (C)
|
||
2026, Hermann Vosseler <Ichthyostega@web.de>
|
||
|
||
**Lumiera** 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. See the file COPYING for further details.
|
||
|
||
* *****************************************************************/
|
||
|
||
/** @file engine-buffer-manager-test.cpp
|
||
** unit test \ref EngineBufferManager_test
|
||
*/
|
||
|
||
|
||
#include "test/run.hpp"
|
||
#include "test/test-helper.hpp"
|
||
#include "vault/mem/engine-buffer-manager.hpp"
|
||
#include "vault/mem/engine-buffer-allocator.hpp"
|
||
#include "lib/scoped-collection.hpp"
|
||
#include "lib/iter-explorer.hpp"
|
||
#include "lib/sync-barrier.hpp"
|
||
#include "lib/thread.hpp"
|
||
#include "lib/symbol.hpp"
|
||
|
||
#include <algorithm>
|
||
#include <string>
|
||
#include <array>
|
||
|
||
using lib::explore;
|
||
using lib::Literal;
|
||
using lib::Thread;
|
||
using lib::SyncBarrier;
|
||
using std::this_thread::yield;
|
||
using std::this_thread::sleep_for;
|
||
using std::chrono::microseconds;
|
||
using std::chrono_literals::operator ""ms;
|
||
|
||
namespace vault {
|
||
namespace mem {
|
||
namespace test {
|
||
|
||
namespace { // Test parameters......
|
||
const size_t ALLOC_REQ = 1024*1024; ///< use test-allocation request of 1 MiB size
|
||
const size_t NUM_THREADS = 100; ///< press concurrently
|
||
}
|
||
|
||
|
||
|
||
|
||
/*****************************************************************************//**
|
||
* @test Show how the central buffer manager of the Render Engine can be accessed.
|
||
*/
|
||
class EngineBufferManager_test : public Test
|
||
{
|
||
|
||
virtual void
|
||
run (Arg)
|
||
{
|
||
demonstrate_AllocatorInterface();
|
||
verify_syncRequest();
|
||
verify_asyncRequest();
|
||
}
|
||
|
||
|
||
|
||
/** @test show how to allocate buffer memory
|
||
* with the underlying base allocator.
|
||
* @remark 4/2026 for the first integration of the Render Engine,
|
||
* a simplified implementation is used that just delegates
|
||
* to the regular heap allocator (which actually performs
|
||
* quite well on modern C++ STDLib). The plan is to
|
||
* use some kind of tiling pool allocator eventually,
|
||
* contingent on the actual performance observations.
|
||
*/
|
||
void
|
||
demonstrate_AllocatorInterface()
|
||
{
|
||
using Allo = HeapBufferAllocator;
|
||
CHECK (lib::allo::is_Stateless_v<Allo>);
|
||
|
||
Allo allo;
|
||
auto a1 = allo.allocate (55);
|
||
auto a2 = allo.allocate (555);
|
||
CHECK (a1.mem);
|
||
CHECK (a2.mem);
|
||
CHECK (a1.siz == Allo::TILE_SIZ);
|
||
CHECK (a2.siz % Allo::TILE_SIZ == 0);
|
||
CHECK (a2.siz > 555);
|
||
|
||
// can use that memory without blowing up....
|
||
auto doooh = new(a1.mem) lflo{std::numeric_limits<lflo>::max()};
|
||
*doooh /= 2;
|
||
CHECK (2 == std::numeric_limits<lflo>::max() / *doooh);
|
||
|
||
allo.deallocate (a1);
|
||
allo.deallocate (a2);
|
||
}
|
||
|
||
|
||
|
||
/** @test show that a direct request for allocation is honored
|
||
* - request some memory
|
||
* - read and write to that memory
|
||
* - return all leased allocations
|
||
* - verify the diagnostic meshes up with the allocation
|
||
* @remark in principle it is not possible to prove that some
|
||
* memory allocation actually works, other than checking
|
||
* that access to the given memory is possible, because
|
||
* the fact that no memory corruption took place is
|
||
* only semi-decidable (you can show a corruption event,
|
||
* but not the absence of any such an event).
|
||
*/
|
||
void
|
||
verify_syncRequest()
|
||
{
|
||
EngineBufferManager manager;
|
||
CHECK (watch(manager).isEmpty());
|
||
|
||
Alloc alloc = manager.requestAllocation (555);
|
||
CHECK (not alloc.empty());
|
||
CHECK (alloc.siz >= 555);
|
||
|
||
CHECK (alloc.siz == watch(manager).bytesAllocd());
|
||
CHECK (alloc.siz == watch(manager).bytesLeased());
|
||
CHECK (alloc.siz % HeapBufferAllocator::TILE_SIZ == 0);
|
||
|
||
// can use that memory
|
||
char* buf = reinterpret_cast<char*> (alloc.mem);
|
||
std::string ranS{lib::randStr(555-1)};
|
||
auto* p = std::copy (ranS.begin(), ranS.end(), buf);
|
||
CHECK (ranS.length() == size_t(p - buf));
|
||
*p = '\0';
|
||
CHECK (ranS == buf);
|
||
|
||
CHECK (1 == watch(manager).numAllocs());
|
||
Alloc a2 = manager.requestAllocation (1'000'000);
|
||
CHECK (not a2.empty());
|
||
CHECK (a2.siz >= 1e6);
|
||
CHECK (2 == watch(manager).numAllocs());
|
||
CHECK (1e6+555 < watch(manager).bytesLeased());
|
||
|
||
manager.supply (a2);
|
||
manager.processPendingRequests();
|
||
CHECK (1 == watch(manager).numAllocs());
|
||
CHECK (1e6 > watch(manager).bytesLeased());
|
||
manager.supply (alloc);
|
||
manager.processPendingRequests();
|
||
CHECK (0 == watch(manager).numAllocs());
|
||
CHECK (0 == watch(manager).bytesLeased());
|
||
}
|
||
|
||
|
||
|
||
/** @test show a working allocation request passed over thread boundaries...
|
||
* - use a simplified »local pool« that actually just provides an in-queue
|
||
* - start a lot of threads that perform the typical allocation sequence
|
||
* + first send an asynchronous allocation request
|
||
* + some delay while doing other stuff (here: sleep)
|
||
* + check if allocation has been serviced
|
||
* + if not, then perform global allocation servicing in this worker
|
||
* + allocation must be available now, can use it
|
||
* + when done, send allocation back to the global pool
|
||
*/
|
||
void
|
||
verify_asyncRequest()
|
||
{
|
||
struct LocalTestPool
|
||
: AllocReceiver
|
||
{
|
||
Alloc
|
||
retrieveAlloc()
|
||
{
|
||
Alloc received{nullptr, 0};
|
||
inQueue_.pop (received); // Note: no-op if queue is empty
|
||
return received;
|
||
}
|
||
|
||
bool
|
||
empty() const
|
||
{
|
||
return inQueue_.empty();
|
||
}
|
||
};
|
||
|
||
EngineBufferManager manager;
|
||
|
||
using WorkBuff = std::array<uint64_t, ALLOC_REQ / sizeof(uint64_t)>;
|
||
|
||
SyncBarrier afterThread{NUM_THREADS+1};
|
||
auto workSeq = [&]{ // sequence-of-actions-within-worker-thread-------------------
|
||
LocalTestPool myPool;
|
||
CHECK (myPool.empty());
|
||
|
||
manager.async_requestAllocation (myPool, ALLOC_REQ);
|
||
|
||
// meanwhile the worker does some other "work"...
|
||
auto gen = makeRandGen(); // local random generator per thread
|
||
uint delay = 100 + gen.i(900);
|
||
sleep_for (microseconds(delay));
|
||
|
||
Alloc alloc = myPool.retrieveAlloc();
|
||
if (alloc.empty())
|
||
{ // they let us down ...
|
||
// insist harder to be serviced thusly
|
||
manager.processPendingRequests();
|
||
alloc = myPool.retrieveAlloc();
|
||
// Explanation: since the async_requestAllocation() »happens-before« the processPendingRequests()
|
||
} // our request *must* have been processed and dispatched now, unless there was a failure
|
||
|
||
CHECK (not alloc.empty());
|
||
CHECK (ALLOC_REQ <= alloc.siz);
|
||
// can use that allocation for some "serious work"...
|
||
auto content = new(alloc.mem) WorkBuff;
|
||
std::ranges::generate (*content, [&]{ return gen.u64(); });
|
||
|
||
// coordinate end of all threads
|
||
afterThread.sync();
|
||
|
||
// pass allocation back to the central hub
|
||
manager.supply (alloc);
|
||
CHECK (myPool.empty()); // no further pending / duplicate Alloc in-queue
|
||
};
|
||
|
||
// Start a collection of workers....
|
||
using Threads = lib::ScopedCollection<Thread>;
|
||
Threads threads{NUM_THREADS, Threads::fill(workSeq)};
|
||
|
||
// after that barrier, all threads send back their allocation
|
||
afterThread.sync();
|
||
|
||
// wait for all threads to finish...
|
||
while (explore(threads).has_any())
|
||
yield();
|
||
|
||
// all the allocations sent back by the workers
|
||
// should sit now in the EngineBufferManager's input queue
|
||
CHECK (NUM_THREADS == watch(manager).numAllocs());
|
||
CHECK (NUM_THREADS*ALLOC_REQ <= watch(manager).bytesLeased());
|
||
|
||
// process in-queue and retrieve all allocations..
|
||
manager.processPendingRequests();
|
||
CHECK (0 == watch(manager).bytesLeased());
|
||
}
|
||
};
|
||
|
||
|
||
/** Register this test class... */
|
||
LAUNCHER (EngineBufferManager_test, "unit engine");
|
||
|
||
|
||
|
||
}}} // namespace vault::mem::test
|