diff --git a/src/steam/engine/diagnostic-buffer-provider.cpp b/src/steam/engine/diagnostic-buffer-provider.cpp index 3ef43f281..7037cd910 100644 --- a/src/steam/engine/diagnostic-buffer-provider.cpp +++ b/src/steam/engine/diagnostic-buffer-provider.cpp @@ -64,12 +64,12 @@ namespace engine { - TrackingHeapBlockProvider& + HeapMemProvider& DiagnosticBufferProvider::reset() { if (pImpl_) pImpl_->markAllEmitted(); - pImpl_.reset(new TrackingHeapBlockProvider()); + pImpl_.reset(new HeapMemProvider()); return *pImpl_; } diff --git a/src/steam/engine/diagnostic-buffer-provider.hpp b/src/steam/engine/diagnostic-buffer-provider.hpp index dc2178bd2..cbf2372ca 100644 --- a/src/steam/engine/diagnostic-buffer-provider.hpp +++ b/src/steam/engine/diagnostic-buffer-provider.hpp @@ -41,7 +41,7 @@ namespace engine { * simple BufferProvider implementation * with additional allocation tracking */ - class TrackingHeapBlockProvider; + class HeapMemProvider; /****************************************************************//** @@ -53,11 +53,11 @@ namespace engine { : util::NonCopyable { - std::unique_ptr pImpl_; + std::unique_ptr pImpl_; static lib::Depend diagnostics; - TrackingHeapBlockProvider& reset(); + HeapMemProvider& reset(); bool isCurrent (BufferProvider const&); diff --git a/src/steam/engine/heap-mem-provider.cpp b/src/steam/engine/heap-mem-provider.cpp index e719e15e2..995304819 100644 --- a/src/steam/engine/heap-mem-provider.cpp +++ b/src/steam/engine/heap-mem-provider.cpp @@ -222,13 +222,13 @@ namespace engine { /** * @internal create a memory tracking BufferProvider, */ - TrackingHeapBlockProvider::TrackingHeapBlockProvider() + HeapMemProvider::HeapMemProvider() : BufferProvider ("Diagnostic_HeapAllocated") , pool_(new diagn::PoolTable) , outSeq_() { } - TrackingHeapBlockProvider::~TrackingHeapBlockProvider() + HeapMemProvider::~HeapMemProvider() { INFO (proc_mem, "discarding %zu diagnostic buffer entries", outSeq_.size()); } @@ -237,7 +237,7 @@ namespace engine { /* ==== Implementation of the BufferProvider interface ==== */ uint - TrackingHeapBlockProvider::prepareBuffers(uint requestedAmount, HashVal typeID) + HeapMemProvider::prepareBuffers(uint requestedAmount, HashVal typeID) { diagn::BlockPool& responsiblePool = getBlockPoolFor (typeID); return responsiblePool.prepare_for (requestedAmount); @@ -245,7 +245,7 @@ namespace engine { BuffHandle - TrackingHeapBlockProvider::provideLockedBuffer(HashVal typeID) + HeapMemProvider::provideLockedBuffer(HashVal typeID) { diagn::BlockPool& blocks = getBlockPoolFor (typeID); diagn::Block& newBlock = blocks.createBlock(); @@ -254,7 +254,7 @@ namespace engine { void - TrackingHeapBlockProvider::mark_emitted (HashVal typeID, LocalTag const& specifics) + HeapMemProvider::mark_emitted (HashVal typeID, LocalTag const& specifics) { diagn::Block* block4buffer = locateBlock (typeID, specifics); if (!block4buffer) @@ -275,7 +275,7 @@ namespace engine { /** mark a buffer as officially discarded */ void - TrackingHeapBlockProvider::detachBuffer (HashVal typeID, LocalTag const& specifics, Buff& storage) + HeapMemProvider::detachBuffer (HashVal typeID, LocalTag const& specifics, Buff& storage) { diagn::Block* block4buffer = locateBlock (typeID, specifics); REQUIRE (block4buffer, "releasing a buffer not allocated through this provider"); @@ -288,20 +288,20 @@ namespace engine { /* ==== Implementation details ==== */ size_t - TrackingHeapBlockProvider::emittedCnt() const + HeapMemProvider::emittedCnt() const { return outSeq_.size(); } void - TrackingHeapBlockProvider::markAllEmitted() + HeapMemProvider::markAllEmitted() { for (auto& [_, blockPool] : *pool_) blockPool.discard(); } diagn::Block& - TrackingHeapBlockProvider::access_emitted (uint bufferID) + HeapMemProvider::access_emitted (uint bufferID) { if (!withinOutputSequence (bufferID)) return emptyPlaceholder; ////////////////////////////////TICKET #856 @@ -310,7 +310,7 @@ namespace engine { } bool - TrackingHeapBlockProvider::withinOutputSequence (uint bufferID) const + HeapMemProvider::withinOutputSequence (uint bufferID) const { if (bufferID >= MAX_BUFFERS) throw error::Fatal ("hardwired internal limit for test buffers exceeded"); @@ -319,7 +319,7 @@ namespace engine { } diagn::BlockPool& - TrackingHeapBlockProvider::getBlockPoolFor (HashVal typeID) + HeapMemProvider::getBlockPoolFor (HashVal typeID) { diagn::BlockPool& pool = (*pool_)[typeID]; if (!pool) @@ -328,7 +328,7 @@ namespace engine { } diagn::Block* - TrackingHeapBlockProvider::locateBlock (HashVal typeID, void* storage) + HeapMemProvider::locateBlock (HashVal typeID, void* storage) { diagn::BlockPool& pool = getBlockPoolFor (typeID); diagn::Block* block4buffer = pool.find (storage); ////////////////////////////////TICKET #856 @@ -337,7 +337,7 @@ namespace engine { } diagn::Block* - TrackingHeapBlockProvider::searchInOutSeqeuence (void* blockLocation) + HeapMemProvider::searchInOutSeqeuence (void* blockLocation) { return pick_Block_by_storage (outSeq_, blockLocation); ////////////////////////////////TICKET #856 } diff --git a/src/steam/engine/heap-mem-provider.hpp b/src/steam/engine/heap-mem-provider.hpp index 4286e6f1e..a5e212f5d 100644 --- a/src/steam/engine/heap-mem-provider.hpp +++ b/src/steam/engine/heap-mem-provider.hpp @@ -116,7 +116,7 @@ namespace engine { * is discarded as a whole. There is an additional testing/diagnostics API to access the * tracked usage information, even when blocks are already marked as "released". */ - class TrackingHeapBlockProvider + class HeapMemProvider : public BufferProvider { unique_ptr pool_; @@ -131,8 +131,8 @@ namespace engine { virtual void detachBuffer (HashVal, LocalTag const&, Buff&) override; public: - TrackingHeapBlockProvider(); - virtual ~TrackingHeapBlockProvider(); + HeapMemProvider(); + virtual ~HeapMemProvider(); size_t emittedCnt() const; @@ -162,7 +162,7 @@ namespace engine { */ template TY& - TrackingHeapBlockProvider::accessAs (uint bufferID) + HeapMemProvider::accessAs (uint bufferID) { if (!withinOutputSequence (bufferID)) throw error::Invalid ("Buffer with the given ID not yet emitted"); diff --git a/src/steam/engine/render-environment.cpp b/src/steam/engine/render-environment.cpp index 81d9649a4..062b4486b 100644 --- a/src/steam/engine/render-environment.cpp +++ b/src/steam/engine/render-environment.cpp @@ -38,7 +38,7 @@ namespace engine{ BufferProvider& getNaiveBufferManager() { - static TrackingHeapBlockProvider buffProvider; //////////////////////////////////////////////////TICKET #1367 : only suitable for first prototype; should implement a bare bone memory manager instead + static HeapMemProvider buffProvider; ////////////////////////////////////////////////////TICKET #1367 : only suitable for first prototype; should implement a bare bone memory manager instead return buffProvider; } } diff --git a/tests/core/steam/engine/diagnostic-buffer-provider-test.cpp b/tests/core/steam/engine/diagnostic-buffer-provider-test.cpp index 28c030ad1..0a67b84fc 100644 --- a/tests/core/steam/engine/diagnostic-buffer-provider-test.cpp +++ b/tests/core/steam/engine/diagnostic-buffer-provider-test.cpp @@ -81,7 +81,7 @@ namespace test { void simpleExample() { - TrackingHeapBlockProvider provider; + HeapMemProvider provider; /////////////////////////////////////OOO should be DiagnosticBufferProvider BuffHandle testBuff = provider.lockBufferFor(); CHECK (testBuff); @@ -101,7 +101,7 @@ namespace test { void verifyStandardCase() { - TrackingHeapBlockProvider provider; + HeapMemProvider provider; /////////////////////////////////////OOO should be DiagnosticBufferProvider BuffDescr buffType = provider.getDescriptorFor(TEST_ELM_SIZE); uint numElms = provider.announce(MAX_ELMS, buffType); @@ -126,7 +126,7 @@ namespace test { void verifyTestProtocol() { - TrackingHeapBlockProvider provider; + HeapMemProvider provider; /////////////////////////////////////OOO should be DiagnosticBufferProvider BuffDescr buffType = provider.getDescriptorFor(TEST_ELM_SIZE); diff --git a/tests/core/steam/engine/node-base-test.cpp b/tests/core/steam/engine/node-base-test.cpp index c90ac35c6..b7a343586 100644 --- a/tests/core/steam/engine/node-base-test.cpp +++ b/tests/core/steam/engine/node-base-test.cpp @@ -20,12 +20,12 @@ #include "lib/iter-zip.hpp" #include "lib/meta/function.hpp" #include "lib/several-builder.hpp" +#include "steam/engine/engine-ctx.hpp" #include "steam/engine/proc-node.hpp" #include "steam/engine/turnout.hpp" #include "steam/engine/turnout-system.hpp" #include "steam/engine/feed-manifold.hpp" #include "steam/engine/node-builder.hpp" -#include "steam/engine/diagnostic-buffer-provider.hpp" #include "steam/engine/buffhandle-attach.hpp" #include "lib/test/test-helper.hpp" #include "lib/util.hpp" @@ -187,8 +187,7 @@ namespace test { // prepare for invoking the node.... - BufferProvider& provider = DiagnosticBufferProvider::build(); - BuffHandle buff = provider.lockBufferFor (-55); + BuffHandle buff = EngineCtx::access().mem.lockBufferFor (-55); CHECK (-55 == buff.accessAs()); // allocated some data buffer for the result, with a marker-value Time nomTime{Time::ZERO}; @@ -208,7 +207,7 @@ namespace test { /** @test the FeedManifold as adapter between Engine and processing library... * - bind local λ with various admissible signatures * - construct specifically tailored FeedManifold types - * - use the DiagnosticBufferProvider for test buffers + * - use the default BufferProvider (from EngineCtx) to get test buffers * - create FeedManifold instance, passing the λ and additional parameters * - connect BuffHandle for these buffers into the FeedManifold instance * - trigger invocation of the function @@ -248,7 +247,7 @@ namespace test { // CHECK (m1.inArgs ); // does not compile because storage field is not provided // CHECK (m1.param ); - BufferProvider& provider = DiagnosticBufferProvider::build(); + BufferProvider& provider = EngineCtx::access().mem; BuffHandle buff = provider.lockBufferFor (-55); CHECK (buff.isValid()); CHECK (buff.accessAs() == -55); @@ -458,8 +457,7 @@ namespace test { { // Prepare setup to build a suitable FeedManifold... using Buffer = long; - BufferProvider& provider = DiagnosticBufferProvider::build(); - BuffHandle buff = provider.lockBufferFor (-55); + BuffHandle buff = EngineCtx::access().mem.lockBufferFor (-55); //_______________________________________ diff --git a/tests/core/steam/engine/node-builder-test.cpp b/tests/core/steam/engine/node-builder-test.cpp index 01e7d54b5..91cf89852 100644 --- a/tests/core/steam/engine/node-builder-test.cpp +++ b/tests/core/steam/engine/node-builder-test.cpp @@ -17,8 +17,8 @@ #include "lib/test/run.hpp" +#include "steam/engine/engine-ctx.hpp" #include "steam/engine/node-builder.hpp" -#include "steam/engine/diagnostic-buffer-provider.hpp" #include "steam/asset/meta/time-grid.hpp" #include "lib/test/diagnostic-output.hpp" #include "lib/time/timequant.hpp" @@ -92,7 +92,7 @@ namespace test { /** * @internal Helper for Render Node invocation - * - use a DiagnosticBufferProvider to allocate a result buffer + * - use default config of EngineCtx (≙test setup) to allocate a result buffer * - assuming that the Node internally does not allocate further buffers * - pull from Port #0 of the given node, passing the \a nomTime as argument * - expect the buffer to hold a single `uint` value after invocation @@ -100,8 +100,7 @@ namespace test { uint invokeRenderNode (ProcNode& theNode, Time nomTime =Time::ZERO) { - BufferProvider& provider = DiagnosticBufferProvider::build(); - BuffHandle buff = provider.lockBufferFor (-55); + BuffHandle buff = EngineCtx::access().mem.lockBufferFor (-55); ProcessKey key{0}; uint port{0}; diff --git a/tests/core/steam/engine/node-devel-test.cpp b/tests/core/steam/engine/node-devel-test.cpp index 3c20eeeac..3f5a81ed9 100644 --- a/tests/core/steam/engine/node-devel-test.cpp +++ b/tests/core/steam/engine/node-devel-test.cpp @@ -19,9 +19,9 @@ #include "lib/test/run.hpp" #include "lib/hash-combine.hpp" #include "lib/test/test-helper.hpp" +#include "steam/engine/engine-ctx.hpp" #include "steam/engine/node-builder.hpp" #include "steam/engine/test-rand-ontology.hpp" -#include "steam/engine/diagnostic-buffer-provider.hpp" #include "lib/iter-zip.hpp" #include "lib/random.hpp" @@ -321,7 +321,7 @@ namespace test { CHECK (watch(node).getNodeSpec() == "Test:generate-◎"_expect); CHECK (watch(node).getPortSpec(0) == "generate(TestFrame)"_expect); - BufferProvider& provider = DiagnosticBufferProvider::build(); + BufferProvider& provider = EngineCtx::access().mem; BuffHandle buffHandle = provider.lockBuffer (provider.getDescriptorFor(sizeof(TestFrame))); uint port{0}; @@ -415,7 +415,7 @@ namespace test { CHECK (watch(nFilt).getPortSpec(0) == "manipulate(TestFrame)(TestFrame)"_expect ); // prepare to invoke this Node chain... - BufferProvider& provider = DiagnosticBufferProvider::build(); + BufferProvider& provider = EngineCtx::access().mem; BuffHandle buffHandle = provider.lockBuffer (provider.getDescriptorFor(sizeof(TestFrame))); uint port{0}; @@ -473,7 +473,7 @@ namespace test { CHECK (watch(nMix).getPortSpec(0) == "combine(TestFrame/2)(TestFrame)"_expect ); // prepare to invoke this Node chain... - BufferProvider& provider = DiagnosticBufferProvider::build(); + BufferProvider& provider = EngineCtx::access().mem; BuffHandle buffHandle = provider.lockBuffer (provider.getDescriptorFor(sizeof(TestFrame))); CHECK (not buffHandle.accessAs().isValid()); uint port{0}; diff --git a/tests/core/steam/engine/node-feed-test.cpp b/tests/core/steam/engine/node-feed-test.cpp index cb9a9cb41..000c5e6f0 100644 --- a/tests/core/steam/engine/node-feed-test.cpp +++ b/tests/core/steam/engine/node-feed-test.cpp @@ -106,6 +106,7 @@ namespace test { BuffHandle result = port.weave (turnoutSys); // ◁————————— paramFun invoked here, then procFun CHECK (LIFE_AND_UNIVERSE_4EVER == result.accessAs());// and procFun wrote param-value into result buffer result.release(); + //////////////////////OOO verify no leaked buffer here } @@ -228,7 +229,7 @@ namespace test { .build()}; // Prepare result buffer for invocation - BufferProvider& provider = DiagnosticBufferProvider::build(); + BufferProvider& provider = DiagnosticBufferProvider::build(); ////////////////OOO should rather switch whole pipeline to a DiagnosticBufferProvider here BuffHandle buff = provider.lockBufferFor (-55); CHECK (-55 == buff.accessAs()); @@ -237,6 +238,7 @@ namespace test { CHECK (v0+v1 == buff.accessAs()); buff.release(); + //////////////////////OOO verify no leaked buffer here } }; diff --git a/tests/core/steam/engine/node-link-test.cpp b/tests/core/steam/engine/node-link-test.cpp index 43388afe2..643bf24cc 100644 --- a/tests/core/steam/engine/node-link-test.cpp +++ b/tests/core/steam/engine/node-link-test.cpp @@ -17,6 +17,7 @@ #include "lib/test/run.hpp" +#include "steam/engine/engine-ctx.hpp" #include "steam/engine/proc-node.hpp" #include "steam/engine/node-builder.hpp" #include "steam/engine/test-rand-ontology.hpp" @@ -301,10 +302,9 @@ namespace test { //________________________________________________________ // for sake of completeness: all these nodes can be invoked - BufferProvider& provider = DiagnosticBufferProvider::build(); auto invoke = [&](ProcNode& node, uint port) { // Sequence to invoke a Node... - BuffHandle buff = provider.lockBufferFor (-55); + BuffHandle buff = EngineCtx::access().mem.lockBufferFor (-55); CHECK (-55 == buff.accessAs()); buff = node.pull (port, buff, Time::ZERO, ProcessKey{0}); int result = buff.accessAs(); @@ -350,6 +350,7 @@ namespace test { auto testGen = testRand().setupGenerator(); auto testMan = testRand().setupManipulator(); auto testMix = testRand().setupCombinator(); + /////////////////////////////////////////////////OOO install DiagnosticBufferProvider here... // Prepare for Time-Quantisation --> Frame-# or Offset parameter @@ -482,7 +483,7 @@ namespace test { return f1.getChecksum(); }; - BufferProvider& provider = DiagnosticBufferProvider::build(); + BufferProvider& provider = EngineCtx::access().mem; const BuffDescr buffDescr = provider.getDescriptor(); auto invoke = [&](Time nomTime, uint port) @@ -508,6 +509,7 @@ namespace test { // Invoke -- and compare checksum with direct computation CHECK (invoke (nomTime,port) == verify (nomTime,port)); } + //////////////////////OOO verify no leaked buffer here } }; diff --git a/tests/core/steam/play/diagnostic-output-slot.hpp b/tests/core/steam/play/diagnostic-output-slot.hpp index 44ef6554e..790d16396 100644 --- a/tests/core/steam/play/diagnostic-output-slot.hpp +++ b/tests/core/steam/play/diagnostic-output-slot.hpp @@ -57,7 +57,7 @@ namespace play { using steam::asset::meta::TimeGrid; using steam::engine::BuffDescr; using steam::engine::test::TestFrame; - using steam::engine::TrackingHeapBlockProvider; + using steam::engine::HeapMemProvider; namespace diagn = steam::engine::diagn; //using std::vector; @@ -94,7 +94,7 @@ namespace play { typedef std::unordered_set FrameTrackingInfo; - TrackingHeapBlockProvider buffProvider_; + HeapMemProvider buffProvider_; BuffDescr bufferType_; FrameTrackingInfo frameTrackingIndex_; diff --git a/wiki/thinkPad.ichthyo.mm b/wiki/thinkPad.ichthyo.mm index d409fc9d1..6774bf639 100644 --- a/wiki/thinkPad.ichthyo.mm +++ b/wiki/thinkPad.ichthyo.mm @@ -86133,7 +86133,7 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- + @@ -92928,7 +92928,7 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 - + @@ -104545,7 +104545,7 @@ StM_bind(Builder<R1> b1, Extension<R1,R2> extension) - + @@ -110708,6 +110708,98 @@ StM_bind(Builder<R1> b1, Extension<R1,R2> extension) + + + + + + + + + + + + + + + +

+ commit a88ccd219d3d2b3e9c158771a6e7195435563286 +

+

+ Author: Ichthyostega <prg@ichthyostega.de> +

+

+ Date:   Mon Nov 7 00:07:53 2011 +0100 +

+

+ +

+

+     extract the diagnostic BufferProvider into separate header +

+ + + + + + + + +

+ Diese Betrachtung ist allerdings ungerecht: +

+
    +
  • + ich dachte, daß das Tracking eine Schlüsselrolle spielen würde +
    • +
  • + ich plante eine Buff-Table, die direkt auf dem BufferProvider aufsetzen sollte +
    • +
  • + es war damals (im 1.Anlauf, 2011) die Rolle und Problematik der Type-Registry nicht klar +
    • +
  • + das Tracking und der zugehörige Test waren eine wichtige Bestätigung für mich, da ich sonst überhaupt nichts zu Greifen bekam und die weitere Entwicklung der Engine ins Bodenlose zu entgleiten drohte +
    • +
+ + + + + + + + +

+ ...und erst damit gab es eine Standard-Methode, wie man Test-Mocks verwenden sollte; vor diesem Zeitpunkt habe ich öfters solche ad-hoc-Frameworks gebaut, mit statischen Zugriffsfunktionen (übrigens auch danach noch habe ich deses Pattern weiter verwendet, vmtl. ohne diesen Widerspruch zu bemerken) +

+ + + + + + + + + + + + + +

+ ...und zwar, weil dieser TrackingHeapBlockProvider gleichzeitig auch die einzige Implementierung ist, und daher auch als Referenz zum Verständnis beiträgt (oder eben nicht) +

+ + + + + + + + + + @@ -110934,8 +111026,7 @@ StM_bind(Builder<R1> b1, Extension<R1,R2> extension) das könnte man auch in einer Subklasse tun; mir erschien aber die Schreibweise klarer: EngineCtx::access().mem.lockBufferFor<Type>() anstatt einem getBufferProvider() — das heißt, ich möchte die Abstraktion »Buffer Provider« oder »Cache Provider« nicht eigens hervorheben; außerdem kann so die ganze Implementierung in einem File beieinander stehen, und man spart sich ein weiteres leeres, nichtsagendes  Interface, welches nur aus Gettern besteht. Ja, Getter halte ich inzwischen für ein Antipattern

- - + @@ -111051,6 +111142,17 @@ StM_bind(Builder<R1> b1, Extension<R1,R2> extension) + + + + +

+ Name: EngineFacilities +

+ + + + @@ -111096,6 +111198,261 @@ StM_bind(Builder<R1> b1, Extension<R1,R2> extension) + + + + + + + + + + + + + + + + + + +

+ theoretisch könnte die Instrumentierung weiterhin hilfreich sein für Integrationstests +

+ + + + + + + + + + + + +

+ ...denn damit kann man zeigen +

+
    +
  • + wir haben die Implementierung voll im Griff +
    • +
  • + unser informmeles Verständnis der Abläufe ist auch im Detail zutreffend und bestätigbar +
    • +
  • + Buffer-Speicher wird nicht korrumpiert (das ist tatsächlich relevant und kann anders nicht gezeigt werden) +
    • +
+ + + + + + + + + + + + + + + + + + + +

+ WER schreibt denn solchen Scheiß Code +

+ + + + + + + + +

+ schon das Interface BufferProvider hat sehr viel »code behind« +

+ + + + + + +

+ ...das aber ist erst das übernächste Thema (und ist wohl den Problemen mit der Type-Registry geschuldet) +

+ + + + + + + +

+ ...wobei es sich größtenteils um eine aufgebohrte Kapsel  handelt, so daß externder Diagnose-Code in den Inereien rumpfuschen kann +

+ + + + + + + + + + +

+ ...und zwar als Identität des konkreten Speicherblocks, der ja von der Implementierung hier nicht verworfen wird — dieses Konzept kann es aber gar nicht geben im Rahmen des Interfaces/Protokolls +

+ + + + + + + +

+ und die interne, instrumentierte class Block spielt auch noch eine wesentliche Rolle +

+ + + + + + + + + + +

+ ...also die TrackingInMemoryBlockSequence — dort sollte eine Übersetzung von einer Frame-ID in interne Mechanismen stattfinden, aber stattdessen wird der Aufruf direkt an den Block-Pool durchgereicht, und dort geschickt auf die bufferNr zurückgeführt... (ja, kann man so machen, ist erst mal gar nicht falsch, aber keine gute Architektur für eine Prototyp-Implementierung, weil sich daraus die tatsähclichen Strukturen nicht ableiten lassen...) +

+ + + + + + + + + + + + + + + + + + + + +

+ die verworrene alte Implementierung ist die einzige Spezifikation, im Besonderen bezüglich des Type-management. Es gibt dafür einen speziellen Test, der ist aber oberflächlich +

+ + + + + + + + + + +

+ Das ist angemessen so, und vermutlich habe ich es deshalb auch unterlassen, mehr zur Implementierung zu schreiben. Und hier dürfte die Wurzel des aktuellen Problems liegen: das Protokoll allein deckt noch nicht die besonderen Schwierigkeiten der Situation in der Render-Engine ab; und zudem wußte ich damals von diesen Problemen nichts, und hab daher die zu erwartende Realität interpoliert... +

+ + + + + + + + + + + + +

+ ...weil diese Implementierung selber explorativ war, das heißt, ihr Zweck war, diese Anforderungen herauszufinden +

+ + + + + + + + + + + + + + + +

+ das würde heißen: während der Arbeit an diesen Protokollen habe ich immer in den gleichen Strukturen gedacht, die letztlich Implementierungs-Primitive waren. Dadurch sind Implementierungs-Konzepte in die Standard-Implementierung der Protokolle ge»leaked« — und da es nur diese eine Referenz-Implementierung gab, ist diese Vermischung auch in den »code behind« der Protokoll-Implementierungen eingedrungen. Damit war ich schnell fertig (und stand zudem unter Druck, weil ich nicht vorwärts gekommen bin). Infolgedessen unterblieb eine Kritik, und das herausdestilieren einer abstrakteren Form des Typ-Managers; im Fall der Output-Slots ist es sogar noch schlimmer, denn dort ist eine abstrahierte Implementierung relativ sinnnlos (und würde Vorgriffe machen bezüglich der Technologie, also z.B. dann nur gut passen für Audio-Buffer) +

+ + + + + + + + + + +

+ demnach sollte ich aufräumen, nicht neubauen +

+ + + + + + + + + + +

+ Ansatz ⟹ die Test-Instrumentierung neu darüber bauen +

+ + + + + + + + + + + + + + + + + + + + + + + + + @@ -151799,7 +152156,7 @@ std::cout << tmpl.render({"what", "World"}) << s - + @@ -198286,13 +198643,13 @@ env.Command('out.bin', 'in.bin', my_action) - + - + @@ -198300,7 +198657,7 @@ env.Command('out.bin', 'in.bin', my_action) sieht aber soweit sauber aus...

- Wenngleich auch ziemlich elaboriert; all diese Tracking-Funktionalität war seinerzeit angelegt worden, aber nur oberflächlich getestet, weil der Render-Engine-Entwurf von 2012 letztlich steckengeblieben ist. Jetzt, 2024 beginne ich, den TrackingHeapBlockProvider zu für Tests zu nutzen, einfach weil er da ist — und stelle fest, daß einige Details unfertig und etwas unausgereift wirken.... + Wenngleich auch ziemlich elaboriert; all diese Tracking-Funktionalität war seinerzeit angelegt worden, aber nur oberflächlich getestet, weil der Render-Engine-Entwurf von 2012 letztlich steckengeblieben ist. Jetzt, 2024 beginne ich, den TrackingHeapBlockProvider zu für Tests zu nutzen, einfach weil er da ist — und stelle fest, daß einige Details unfertig und etwas unausgereift wirken....