From fc9ff9252a1ed64661357c40c9a7b8bc24ad80e7 Mon Sep 17 00:00:00 2001 From: Ichthyostega Date: Mon, 15 Jul 2024 18:52:59 +0200 Subject: [PATCH] Invocation: clarify role of Buffer-Descriptor and Dependency-Injection MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit It became clear that a secondary system of connections must be added, running top-down from a global model context, and thus contrary to the regular orientation of the node network, which connects upwards from predecessor to successor, in accordance with the pull principle. If we accept this wiring as part of the primary structure, it can be established immediately while building the nodes, thus adding a preconfigured ''pattern of Buffer Descriptors'' to each node, since there is no further ''moving part'' — beyond the wiring to the `BufferProvider`, which thus becomes part of a global `ModelContext` As an immediate consequence, the storage for this configuraion should also be switched to `lib::Several` and handled similar to the primary node wiring in the Builder... --- src/steam/engine/buffer-metadata.hpp | 10 +- src/steam/engine/buffer-provider.cpp | 36 +-- src/steam/engine/buffer-provider.hpp | 22 +- src/steam/engine/buffhandle-attach.hpp | 2 +- src/steam/engine/buffhandle.hpp | 35 +-- src/steam/engine/bufftable.hpp | 4 +- src/steam/engine/channel-descriptor.hpp | 2 +- src/steam/engine/feed-manifold-obsolete.hpp | 4 +- src/steam/engine/state-closure-obsolete.hpp | 2 +- src/steam/engine/state-closure.hpp | 2 +- src/steam/engine/turnout.hpp | 18 +- src/steam/engine/type-handler.hpp | 2 +- .../steam/engine/buffer-metadata-test.cpp | 2 +- .../engine/buffer-provider-protocol-test.cpp | 12 +- .../tracking-heap-block-provider-test.cpp | 4 +- .../steam/play/diagnostic-output-slot.hpp | 4 +- wiki/thinkPad.ichthyo.mm | 280 ++++++++++++++---- 17 files changed, 308 insertions(+), 133 deletions(-) diff --git a/src/steam/engine/buffer-metadata.hpp b/src/steam/engine/buffer-metadata.hpp index 67819a6cd..b42097e63 100644 --- a/src/steam/engine/buffer-metadata.hpp +++ b/src/steam/engine/buffer-metadata.hpp @@ -40,10 +40,10 @@ ** just accesses yet another buffer to place the results of calculations. ** ** These additional distinctions and properties are associated with the help of the - ** BufferDescriptor, embedded into each BuffHandle. While the engine just uses these - ** handles in the way of a pointer, the buffer descriptor acts as an additional tag - ** attached to the buffer access, allowing to re-access a context within the - ** buffer provider implementation. + ** [Buffer Descriptor](\ref BuffDescr), embedded into each BuffHandle. While the engine + ** mostly uses these handles in the way of a pointer, the buffer descriptor acts as a + ** configuration tag attached to the buffer access, allowing to re-access a context + ** within the buffer provider implementation. ** ** @see buffer-provider.hpp ** @see BufferMetadata_test @@ -140,7 +140,7 @@ namespace engine { /** * Description of a Buffer-"type". * Key elements will be used to generate hash IDs, - * to be embedded into a BufferDescriptor. + * to be embedded into a [Buffer Descriptor](\ref BuffDescr). * Keys are chained hierarchically. */ class Key diff --git a/src/steam/engine/buffer-provider.cpp b/src/steam/engine/buffer-provider.cpp index bc09c9151..b714f903d 100644 --- a/src/steam/engine/buffer-provider.cpp +++ b/src/steam/engine/buffer-provider.cpp @@ -63,23 +63,23 @@ namespace engine { * currently locked and usable by client code */ bool - BufferProvider::verifyValidity (BufferDescriptor const& bufferID) const + BufferProvider::verifyValidity (BuffDescr const& bufferID) const { return meta_->isLocked (bufferID); } - BufferDescriptor + BuffDescr BufferProvider::getDescriptorFor (size_t storageSize) { - return BufferDescriptor (*this, meta_->key (storageSize)); + return BuffDescr (*this, meta_->key (storageSize)); } - BufferDescriptor + BuffDescr BufferProvider::getDescriptorFor(size_t storageSize, TypeHandler specialTreatment) { - return BufferDescriptor (*this, meta_->key (storageSize, specialTreatment)); + return BuffDescr (*this, meta_->key (storageSize, specialTreatment)); } @@ -103,7 +103,7 @@ namespace engine { metadata::Key& typeKey = meta_->get (typeID); metadata::Entry& entry = meta_->markLocked(typeKey, storage, implID); - return BuffHandle (BufferDescriptor(*this, entry), storage); + return BuffHandle (BuffDescr(*this, entry), storage); } @@ -113,14 +113,14 @@ namespace engine { * client may reasonably assume to get the actual number of buffers, as * indicated by the return value. A provider may be able to handle * various kinds of buffers (e.g. of differing size), which are - * distinguished by the \em type embodied into the BufferDescriptor. + * distinguished by _the type embodied into_ the BuffDescr. * @return maximum number of simultaneously usable buffers of this type, * to be retrieved later through calls to #lockBuffer. * @throw error::State when no buffer of this kind can be provided * @note the returned count may differ from the requested count. */ uint - BufferProvider::announce (uint count, BufferDescriptor const& type) + BufferProvider::announce (uint count, BuffDescr const& type) { uint actually_possible = prepareBuffers (count, type); if (!actually_possible) @@ -143,7 +143,7 @@ namespace engine { * to establish a reliably available baseline. */ BuffHandle - BufferProvider::lockBuffer (BufferDescriptor const& type) + BufferProvider::lockBuffer (BuffDescr const& type) { REQUIRE (was_created_by_this_provider (type)); @@ -203,7 +203,7 @@ namespace engine { * @note EX_STRONG */ void - BufferProvider::attachTypeHandler (BuffHandle const& target, BufferDescriptor const& reference) + BufferProvider::attachTypeHandler (BuffHandle const& target, BuffDescr const& reference) { metadata::Entry& metaEntry = meta_->get (target.entryID()); metadata::Entry& refEntry = meta_->get (reference); @@ -237,7 +237,7 @@ namespace engine { bool - BufferProvider::was_created_by_this_provider (BufferDescriptor const& descr) const + BufferProvider::was_created_by_this_provider (BuffDescr const& descr) const { return isSameObject (*this, *descr.provider_); } @@ -246,10 +246,10 @@ namespace engine { - /* === BufferDescriptor and BuffHandle === */ + /* === BuffDescr and BuffHandle === */ bool - BufferDescriptor::verifyValidity() const + BuffDescr::verifyValidity() const { ENSURE (provider_); return provider_->verifyValidity(*this); @@ -257,7 +257,7 @@ namespace engine { size_t - BufferDescriptor::determineBufferSize() const + BuffDescr::determineBufferSize() const { ENSURE (provider_); return provider_->getBufferSize (*this); @@ -265,7 +265,7 @@ namespace engine { uint - BufferDescriptor::announce (uint count) + BuffDescr::announce (uint count) { ENSURE (provider_); return provider_->announce(count, *this); @@ -273,7 +273,7 @@ namespace engine { BuffHandle - BufferDescriptor::lockBuffer() + BuffDescr::lockBuffer() { ENSURE (provider_); return provider_->lockBuffer(*this); @@ -313,7 +313,7 @@ namespace engine { * This causes the dtor function to be invoked when releasing this buffer. * The assumption is that client code will placement-construct an object * into this buffer right away, and thus we're taking ownership on that object. - * @param type a reference BufferDescriptor defining an embedded TypeHandler to use + * @param type a reference BuffDescr defining an embedded TypeHandler to use * A copy of this TypeHandler will be stored into the local metadata for * this buffer only, not altering the basic buffer type in any way * @throw lifecycle error when attempting to treat an buffer not in locked state @@ -322,7 +322,7 @@ namespace engine { * @note EX_STRONG */ void - BuffHandle::takeOwnershipFor(BufferDescriptor const& type) + BuffHandle::takeOwnershipFor(BuffDescr const& type) { if (!this->isValid()) throw error::Logic ("attaching an object requires an buffer in locked state", LERR_(LIFECYCLE)); diff --git a/src/steam/engine/buffer-provider.hpp b/src/steam/engine/buffer-provider.hpp index 44fc4bbdb..d365b9819 100644 --- a/src/steam/engine/buffer-provider.hpp +++ b/src/steam/engine/buffer-provider.hpp @@ -101,9 +101,9 @@ namespace engine { virtual ~BufferProvider(); ///< this is an ABC - uint announce (uint count, BufferDescriptor const&); + uint announce (uint count, BuffDescr const&); - BuffHandle lockBuffer (BufferDescriptor const&); + BuffHandle lockBuffer (BuffDescr const&); void emitBuffer (BuffHandle const&); void releaseBuffer (BuffHandle const&); @@ -111,29 +111,29 @@ namespace engine { BuffHandle lockBufferFor (ARGS ...args); /** allow for attaching and owing an object within an already created buffer */ - void attachTypeHandler (BuffHandle const& target, BufferDescriptor const& reference); + void attachTypeHandler (BuffHandle const& target, BuffDescr const& reference); void emergencyCleanup (BuffHandle const& target, bool invokeDtor =false); /** describe the kind of buffer managed by this provider */ - BufferDescriptor getDescriptorFor(size_t storageSize=0); - BufferDescriptor getDescriptorFor(size_t storageSize, TypeHandler specialTreatment); + BuffDescr getDescriptorFor(size_t storageSize=0); + BuffDescr getDescriptorFor(size_t storageSize, TypeHandler specialTreatment); template - BufferDescriptor getDescriptor (ARGS ...args); + BuffDescr getDescriptor (ARGS ...args); /* === API for BuffHandle internal access === */ - bool verifyValidity (BufferDescriptor const&) const; - size_t getBufferSize (HashVal typeID) const; + bool verifyValidity (BuffDescr const&) const; + size_t getBufferSize (HashVal typeID) const; protected: BuffHandle buildHandle (HashVal typeID, void* storage, LocalKey const&); - bool was_created_by_this_provider (BufferDescriptor const&) const; + bool was_created_by_this_provider (BuffDescr const&) const; }; @@ -152,7 +152,7 @@ namespace engine { BuffHandle BufferProvider::lockBufferFor (ARGS ...args) { - BufferDescriptor attach_object_automatically = getDescriptor (forward (args)...); + BuffDescr attach_object_automatically = getDescriptor (forward (args)...); return lockBuffer (attach_object_automatically); } @@ -162,7 +162,7 @@ namespace engine { * and destroying that embedded object when releasing the buffer. */ template - BufferDescriptor + BuffDescr BufferProvider::getDescriptor (ARGS ...args) { return getDescriptorFor (sizeof(BU), TypeHandler::create (forward (args)...)); diff --git a/src/steam/engine/buffhandle-attach.hpp b/src/steam/engine/buffhandle-attach.hpp index adb757ad9..805eda284 100644 --- a/src/steam/engine/buffhandle-attach.hpp +++ b/src/steam/engine/buffhandle-attach.hpp @@ -103,7 +103,7 @@ namespace engine { inline void BuffHandle::takeOwnershipFor() { - BufferDescriptor howto_attach_object_automatically + BuffDescr howto_attach_object_automatically = descriptor_.provider_->getDescriptor(); takeOwnershipFor (howto_attach_object_automatically); // EX_STRONG } diff --git a/src/steam/engine/buffhandle.hpp b/src/steam/engine/buffhandle.hpp index 06a374615..cae55fb9a 100644 --- a/src/steam/engine/buffhandle.hpp +++ b/src/steam/engine/buffhandle.hpp @@ -32,18 +32,19 @@ ** buffers, and for accessing those buffers, the node needs to keep a table of buffer ** pointers, and for releasing the buffers later on, we utilise the buffer handles. ** - ** These buffer handles are based on a buffer descriptor record, which is opaque as far - ** as the client is concerned. BufferDescriptor acts as a representation of the type or - ** kind of buffer. The only way to obtain such a BufferDescriptor is from a concrete - ** BufferProvider implementation. A back-link to this owning and managing provider is - ** embedded into the BufferDescriptor, allowing to retrieve an buffer handle, corresponding - ** to an actual buffer provided and managed behind the scenes. There is no automatic - ** resource management; clients are responsible to invoke BuffHandle#release when done. + ** These buffer handles are based on a [Buffer Descriptor record](\ref BuffDescr), + ** which is opaque as far as the client is concerned. BuffDescr acts as a representation + ** of the type or kind of buffer. The only way to obtain such a BuffDescr is from a concrete + ** BufferProvider implementation. A back-link to this owning and managing provider is embedded + ** into the BuffDescr, which thus may be used as a _configuration tag,_ allowing to retrieve a + ** concrete buffer handle when needed, corresponding to an actual buffer provided and managed + ** behind the scenes. There is no automatic resource management; clients are responsible to + ** invoke BuffHandle#release when done. ** - ** @warning buffer management via BuffHandle and BufferDescriptor does _not automatically - ** maintain proper alignment._ Rather, it relies on the storage allocator to provide - ** a buffer suitably aligned for the target type to hold. In most cases, this target - ** location will actually be storage maintained on heap through some STL collection; + ** @warning buffer management via BuffHandle and BuffDescr does _not automatically maintain + ** proper alignment._ Rather, it relies on the storage allocator to provide a buffer + ** suitably aligned for the target type to hold. In most cases, this target location + ** will actually be storage maintained on heap through some STL collection; ** this topic is a possible subtle pitfall non the less. ** ** @see BufferProvider @@ -82,13 +83,13 @@ namespace engine { * by the BufferProvider, which may use (and even change) the opaque contents * to organise the internal buffer management. */ - class BufferDescriptor + class BuffDescr { protected: BufferProvider* provider_; HashVal subClassification_; - BufferDescriptor(BufferProvider& manager, HashVal detail) + BuffDescr(BufferProvider& manager, HashVal detail) : provider_(&manager) , subClassification_(detail) { } @@ -120,8 +121,8 @@ namespace engine { { typedef StreamType::ImplFacade::DataBuffer Buff; - BufferDescriptor descriptor_; - Buff* pBuffer_; + BuffDescr descriptor_; + Buff* pBuffer_; public: @@ -129,7 +130,7 @@ namespace engine { /** @internal a buffer handle may be obtained by "locking" * a buffer from the corresponding BufferProvider */ - BuffHandle(BufferDescriptor const& typeInfo, void* storage = 0) + BuffHandle(BuffDescr const& typeInfo, void* storage = 0) : descriptor_(typeInfo) , pBuffer_(static_cast(storage)) { } @@ -181,7 +182,7 @@ namespace engine { private: template void takeOwnershipFor(); - void takeOwnershipFor(BufferDescriptor const& type); + void takeOwnershipFor(BuffDescr const& type); void emergencyCleanup(); }; diff --git a/src/steam/engine/bufftable.hpp b/src/steam/engine/bufftable.hpp index 2ec5400ac..8de8504a4 100644 --- a/src/steam/engine/bufftable.hpp +++ b/src/steam/engine/bufftable.hpp @@ -80,7 +80,7 @@ namespace engine { class Builder { public: - Builder& announce (uint count, BufferDescriptor const& type); + Builder& announce (uint count, BuffDescr const& type); BuffTable& build(); }; @@ -110,7 +110,7 @@ namespace engine { inline BuffTable::Builder& - BuffTable::Builder::announce (uint count, BufferDescriptor const& type) + BuffTable::Builder::announce (uint count, BuffDescr const& type) { UNIMPLEMENTED ("accept announcement of additional buffer table entries required"); } diff --git a/src/steam/engine/channel-descriptor.hpp b/src/steam/engine/channel-descriptor.hpp index 11e50b14e..343421d43 100644 --- a/src/steam/engine/channel-descriptor.hpp +++ b/src/steam/engine/channel-descriptor.hpp @@ -49,9 +49,9 @@ namespace engine { using lib::HashVal; + class BuffDescr; class BuffHandle; class BufferProvider; - class BufferDescriptor; diff --git a/src/steam/engine/feed-manifold-obsolete.hpp b/src/steam/engine/feed-manifold-obsolete.hpp index 569816856..1a4e9f12f 100644 --- a/src/steam/engine/feed-manifold-obsolete.hpp +++ b/src/steam/engine/feed-manifold-obsolete.hpp @@ -78,7 +78,7 @@ namespace engine { PBu inBuff; }; - class BufferDescriptor; + class BuffDescr; /** Obsolete, to be rewritten /////TICKET #826 */ class BuffTableStorage @@ -92,7 +92,7 @@ namespace engine { : BuffHandle { BuffHaXXXX() : BuffHandle(just_satisfy_the_compiler()) { /* wont work ever */ } - static BufferDescriptor const& + static BuffDescr const& just_satisfy_the_compiler() { } }; diff --git a/src/steam/engine/state-closure-obsolete.hpp b/src/steam/engine/state-closure-obsolete.hpp index 59263e4cc..40e0b8f21 100644 --- a/src/steam/engine/state-closure-obsolete.hpp +++ b/src/steam/engine/state-closure-obsolete.hpp @@ -64,7 +64,7 @@ namespace engine { ////////////////////////////////////////////////TICKET #826 expected to be reworked to quite some extent (9/2011) public: /** allocate a new writable buffer with type and size according to - * the BufferDescriptor. The actual provider of this buffer depends + * the BuffDescr. The actual provider of this buffer depends * on the StateClosure implementation; it could be a temporary, located in * the cache, used for feeding calculated frames over a network, etc. * @return a BuffHandle encapsulating the information necessary to get diff --git a/src/steam/engine/state-closure.hpp b/src/steam/engine/state-closure.hpp index cdcdf8a6a..f303dd177 100644 --- a/src/steam/engine/state-closure.hpp +++ b/src/steam/engine/state-closure.hpp @@ -64,7 +64,7 @@ namespace engine { /////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : to be Reworked for »Playback Vertical Slice« public: /** allocate a new writable buffer with type and size according to - * the BufferDescriptor. The actual provider of this buffer depends + * the BuffDescr. The actual provider of this buffer depends * on the StateClosure implementation; it could be a temporary, located in * the cache, used for feeding calculated frames over a network, etc. * @return a BuffHandle encapsulating the information necessary to get diff --git a/src/steam/engine/turnout.hpp b/src/steam/engine/turnout.hpp index 3bf6a9b91..a0e2f31d5 100644 --- a/src/steam/engine/turnout.hpp +++ b/src/steam/engine/turnout.hpp @@ -70,6 +70,8 @@ //#include "steam/engine/exit-node.hpp" //#include "lib/time/timevalue.hpp" //#include "lib/linked-elements.hpp" +#include "lib/several.hpp" +#include "lib/several-builder.hpp"/////////////////TODO extract with a WeavingPattern builder //#include "lib/util-foreach.hpp" //#include "lib/iter-adapter.hpp" #include "lib/meta/function.hpp" @@ -85,6 +87,7 @@ namespace steam { namespace engine { using std::forward; + using lib::Several; /////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation /** @@ -394,7 +397,7 @@ namespace engine { */ template struct Conf_DirectFunctionInvocation - //////////////////////////////OOO non-copyable? move-only?? + : util::MoveOnly { using Manifold = FeedManifold; using Feed = SimpleFunctionInvocationAdapter; @@ -413,12 +416,8 @@ namespace engine { uint fanIn{0}; uint fanOut{0}; - template - using Storage = lib::UninitialisedStorage; - - - Storage leadPort; - Storage outDescr; + Several leadPort; + Several outDescr; //////////////////////////////////////////OOO builder must set-up those descriptors @@ -433,7 +432,7 @@ namespace engine { { for (uint i=0; i struct SimpleWeavingBuilder - : Turnout> + : Turnout> /////////////////////////////////OOO can no longer directly inherit from the product(Turnout), due to SeveralBuilder!!! { SimpleWeavingBuilder attachToLeadPort(ProcNode& lead, uint portNr) @@ -526,6 +525,7 @@ namespace engine { Turnout> build() { + ///////////////////////////////OOO need a way to prepare SeveralBuilder-instances for leadPort and outDescr --> see NodeBuilder return move(*this); } }; diff --git a/src/steam/engine/type-handler.hpp b/src/steam/engine/type-handler.hpp index 1802a32c3..455e288d5 100644 --- a/src/steam/engine/type-handler.hpp +++ b/src/steam/engine/type-handler.hpp @@ -30,7 +30,7 @@ ** Within the Lumiera Engine, the BufferProvider default implementation utilises instances ** of TypeHandler to _describe specific buffer types_ capable of managing an attached object, ** or requiring some other kind of special treatment of the memory area used for the buffer. - ** This BufferDescriptor is embodied into the BufferMetadata::Key and used later on to invoke + ** This BuffDescr is embodied into the BufferMetadata::Key and used later on to invoke ** the contained ctor / dtor functors, passing a concrete buffer (memory area). ** ** @see buffer-metadata.hpp diff --git a/tests/core/steam/engine/buffer-metadata-test.cpp b/tests/core/steam/engine/buffer-metadata-test.cpp index ec69ae067..5ff7ffff7 100644 --- a/tests/core/steam/engine/buffer-metadata-test.cpp +++ b/tests/core/steam/engine/buffer-metadata-test.cpp @@ -211,7 +211,7 @@ namespace test { bufferType1 = meta_->key(bufferType1, transaction1); rawBuffType = meta_->key(rawBuffType, transaction2); // these type keys are now handed over to the client, - // embedded into a BufferDescriptor... + // embedded into a Buffer Descriptor... // later, when it comes to actually *locking* those buffers... typedef char RawBuffer[SIZE_B]; diff --git a/tests/core/steam/engine/buffer-provider-protocol-test.cpp b/tests/core/steam/engine/buffer-provider-protocol-test.cpp index ac6dee9b9..5d9b825f2 100644 --- a/tests/core/steam/engine/buffer-provider-protocol-test.cpp +++ b/tests/core/steam/engine/buffer-provider-protocol-test.cpp @@ -126,8 +126,8 @@ namespace test { // will be preconfigured, depending on the usage context BufferProvider& provider = DiagnosticBufferProvider::build(); - BufferDescriptor desc1 = provider.getDescriptor(); // note: implies also sizeof(TestFrame) - BufferDescriptor desc2 = provider.getDescriptorFor(TEST_SIZE); + BuffDescr desc1 = provider.getDescriptor(); // note: implies also sizeof(TestFrame) + BuffDescr desc2 = provider.getDescriptorFor(TEST_SIZE); CHECK (desc1.verifyValidity()); CHECK (desc2.verifyValidity()); @@ -158,9 +158,9 @@ namespace test { verifyObjectAttachment() { BufferProvider& provider = DiagnosticBufferProvider::build(); - BufferDescriptor type_A = provider.getDescriptorFor(sizeof(TestFrame)); - BufferDescriptor type_B = provider.getDescriptorFor(sizeof(int)); - BufferDescriptor type_C = provider.getDescriptor(); + BuffDescr type_A = provider.getDescriptorFor(sizeof(TestFrame)); + BuffDescr type_B = provider.getDescriptorFor(sizeof(int)); + BuffDescr type_C = provider.getDescriptor(); BuffHandle handle_A = provider.lockBuffer(type_A); BuffHandle handle_B = provider.lockBuffer(type_B); @@ -195,7 +195,7 @@ namespace test { verifyObjectAttachmentFailure() { BufferProvider& provider = DiagnosticBufferProvider::build(); - BufferDescriptor type_D = provider.getDescriptorFor(sizeof(Dummy)); + BuffDescr type_D = provider.getDescriptorFor(sizeof(Dummy)); Dummy::checksum() = 0; BuffHandle handle_D = provider.lockBuffer(type_D); diff --git a/tests/core/steam/engine/tracking-heap-block-provider-test.cpp b/tests/core/steam/engine/tracking-heap-block-provider-test.cpp index 9879f4bb5..511fa4d18 100644 --- a/tests/core/steam/engine/tracking-heap-block-provider-test.cpp +++ b/tests/core/steam/engine/tracking-heap-block-provider-test.cpp @@ -113,7 +113,7 @@ namespace test { { TrackingHeapBlockProvider provider; - BufferDescriptor buffType = provider.getDescriptorFor(TEST_ELM_SIZE); + BuffDescr buffType = provider.getDescriptorFor(TEST_ELM_SIZE); uint numElms = provider.announce(MAX_ELMS, buffType); CHECK (0 < numElms); CHECK (numElms <= MAX_ELMS); @@ -138,7 +138,7 @@ namespace test { { TrackingHeapBlockProvider provider; - BufferDescriptor buffType = provider.getDescriptorFor(TEST_ELM_SIZE); + BuffDescr buffType = provider.getDescriptorFor(TEST_ELM_SIZE); BuffHandle bu1 = provider.lockBuffer (buffType); BuffHandle bu2 = provider.lockBuffer (buffType); diff --git a/tests/core/steam/play/diagnostic-output-slot.hpp b/tests/core/steam/play/diagnostic-output-slot.hpp index 1e24ce5e5..bfe6a40b4 100644 --- a/tests/core/steam/play/diagnostic-output-slot.hpp +++ b/tests/core/steam/play/diagnostic-output-slot.hpp @@ -64,7 +64,7 @@ namespace play { using lib::time::FrameRate; using steam::asset::meta::PGrid; using steam::asset::meta::TimeGrid; - using steam::engine::BufferDescriptor; + using steam::engine::BuffDescr; using steam::engine::test::TestFrame; using steam::engine::TrackingHeapBlockProvider; namespace diagn = steam::engine::diagn; @@ -104,7 +104,7 @@ namespace play { TrackingHeapBlockProvider buffProvider_; - BufferDescriptor bufferType_; + BuffDescr bufferType_; FrameTrackingInfo frameTrackingIndex_; PGrid frameGrid_; diff --git a/wiki/thinkPad.ichthyo.mm b/wiki/thinkPad.ichthyo.mm index ffa432f12..104772f74 100644 --- a/wiki/thinkPad.ichthyo.mm +++ b/wiki/thinkPad.ichthyo.mm @@ -2049,9 +2049,7 @@ - - - +

...um den Umstand zu dokumentieren, @@ -2085,9 +2083,7 @@ - - - +

erscheint definitiv nicht als CSS-Node @@ -2168,9 +2164,7 @@ - - - +

...dann Einfügestelle davor platzieren @@ -2309,9 +2303,7 @@ - - - +

...welches ich zusammen mit meinem @@ -2364,9 +2356,7 @@ - - - +

denn dieses Design gibt die beste Balance zwischen den Belangen @@ -2896,9 +2886,7 @@ - - - +

Lösung: delegiere über zwei Stufen... @@ -3580,9 +3568,7 @@ - - - +

..damit ~GtkLumiera() garantiert vorher aufgerufen wird @@ -4642,9 +4628,7 @@ - - - +

1/2017 Review durchgeführt und Logik überarbeitet. @@ -6330,9 +6314,7 @@ - - - +

Aufgabe: docking panels global @@ -8496,9 +8478,7 @@ - - - +

monadische Lösung @@ -11741,9 +11721,7 @@ - - - +

es werden jetzt keine weiteren Features für TreeExplorer gebaut.... @@ -52971,9 +52949,7 @@ - - - +

...und kaum erkennbarer Nutzen. @@ -52989,9 +52965,7 @@ - - - +

hier müßte der InvocationTrail die aufgesammelten Argumente transportieren. @@ -53273,9 +53247,7 @@ - - - +

...wir versuchen gar nicht erst, »etwas Bestehendes zu nutzen« ― sondern wir machen unser eigenes Ding. @@ -53522,9 +53494,7 @@ - - - +

...implementiert "für die Zukunft", @@ -67976,6 +67946,14 @@ + + + + + + + + @@ -71265,7 +71243,10 @@ - + + + + @@ -82189,16 +82170,49 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + + + + + + + + + + - + + + + + + + + + + + +

+ Aufbau erfolgt aus dem Scope der DomainOntology +

+ + + + + + + + + + @@ -86670,6 +86684,57 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + + + + +

+ ein Zwischending: BufferDescriptor +

+ + + + + + + + + + + + + + +
    +
  • + das bedeutet: dies ist die Quintessenz der Buffer-Konfiguration und damit die Minimal-Information, die wir für jeden Slot fest vorbelegen müssen. +
    • +
  • + allerdings könnte man noch über eine kompaktere Repräsentation im Speicher nachdenken... +
    • +
+ + + + + + + + + + + +

+ ...im Gegensatz zum Baumuster des Node-Graphen, der stets abwärts gerichtet ist: eine Node kennt nur ihre Vorläufer, aber der BufferDescriptor verweist aufwärts auf einen globalen Service +

+ + + + + + + + @@ -86764,12 +86829,21 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- + + + + + + + + + + @@ -88100,7 +88174,7 @@ Date:   Thu Apr 20 18:53:17 2023 +0200

- + @@ -88131,7 +88205,25 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + + + + + + + + + +

+ und all dies muß in einen verständliche Builder-DSL  verpackt werden +

+ + + + + + @@ -88141,6 +88233,29 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + + + + + + + + + + + + + + + + + + + + + + + @@ -88150,11 +88265,39 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -88180,8 +88323,7 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
aber festgelegt wird sie beim Bauen des Turnout

- - + @@ -88205,6 +88347,24 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + + + + + + + +

+ ...denn wir verweisen darauf per Referenz oder Pointer +

+ + + + + + + + @@ -89306,6 +89466,20 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + + + + + + + + + + + + + + @@ -127593,7 +127767,7 @@ std::cout << tmpl.render({"what", "World"}) << s - +