benn/lumiera_
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Invocation: establish a concept for the rework

Browse source 
As outlined in #1367, the integration effort requires some rework
of existing code, which will be driven ahead by the `NodeLinkage_test`
 * redefine Node Connectivity
 * build simple `ProcNode` directly in scope
 * create an `TurnoutSystem` instance
 * perform a ''dummy Node-Invocation''
This commit is contained in:
Fischlurch 2024-06-21 16:14:24 +02:00
parent f632701f48
commit 17dcb7495f
19 changed files with 831 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
src/steam/engine/nodefactory.cpp → src/steam/engine/node-factory.cpp
View file

@ -21,16 +21,17 @@
* *****************************************************/
/** @file nodefactory.cpp
/** @file node-factory.cpp
** Implementation of render node setup and wiring
** @todo draft from the early days of the Lumiera project, reworked in 2009
** Development activity in that area as stalled ever since. In the end,
** it is highly likely we'll _indeed need_ a node factory though...
** @todo WIP-WIP 2024 to be reworked from ground up for the »Playback Vertical Slice«
*/
#include "steam/engine/exit-node.hpp"
#include "steam/engine/nodefactory.hpp"
#include "steam/engine/node-factory.hpp"
#include "steam/mobject/session/effect.hpp"
#include "lib/allocation-cluster.hpp"

11
src/steam/engine/nodefactory.hpp → src/steam/engine/node-factory.hpp
View file

@ -1,5 +1,5 @@
/*
NODEFACTORY.hpp - Service for creating processing nodes of various kinds
NODE-FACTORY.hpp - Service for creating processing nodes of various kinds
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>
@ -21,16 +21,17 @@
*/
/** @file nodefactory.hpp
/** @file node-factory.hpp
** A factory to build processing nodes
** @todo draft from the early days of the Lumiera project, reworked in 2009
** Development activity in that area as stalled ever since. In the end,
** it is highly likely we'll _indeed need_ a node factory though...
** @todo about to be reworked for the »Playback Vertical Slice« in 2024
*/
#ifndef ENGINE_NODEFACTORY_H
#define ENGINE_NODEFACTORY_H
#ifndef STEAM_ENGINE_NODE_FACTORY_H
#define STEAM_ENGINE_NODE_FACTORY_H
#include "steam/engine/proc-node.hpp"
#include "steam/mobject/placement.hpp"
@ -85,4 +86,4 @@ namespace engine {
};
}} // namespace steam::engine
#endif
#endif /*STEAM_ENGINE_NODE_FACTORY_H*/

8
src/steam/engine/node-wiring-builder.hpp
View file

@ -20,7 +20,7 @@
*/
/** @file nodewiring-def.hpp
/** @file node-wiring-builder.hpp
** Helper for defining the desired wiring and operation mode for a render node.
** During the Builder run, the render nodes network is wired up starting from the
** source (generating) nodes up to the exit nodes. As the wiring is implemented through
@ -29,6 +29,8 @@
** the desired operation mode of this node need to be available. Thus we use this temporary
** information record to assemble all these pieces of information.
**
** @deprecated WIP-WIP-WIP 2024 Node-Invocation is reworked from ground up -- not clear yet what happens with the builder
**
** @see steam::engine::NodeFactory
** @see nodewiring.hpp
** @see node-basic-test.cpp
@ -66,7 +68,9 @@ namespace engine {
* Thus, we start with one or several existing nodes, specifying which
* output should go to which input pin of the yet-to-be created new node.
* When intending to create a source node, a default WiringSituation
* should be used, without adding any connection information.
* should be used, without adding any connection information.
*
* @deprecated WIP-WIP-WIP 2024 Node-Invocation is reworked from ground up for the »Playback Vertical Slice«
*/
class WiringSituation
: util::NonCopyable

20
src/steam/engine/nodeinvocation.hpp
View file

@ -56,7 +56,7 @@
#include "steam/engine/proc-node.hpp"
#include "steam/engine/state-closure.hpp"
#include "steam/engine/state-closure-obsolete.hpp"
#include "steam/engine/channel-descriptor.hpp"
#include "steam/engine/feed-manifold.hpp"
@ -76,18 +76,18 @@ namespace engine {
* push / fetch and recursive downcall to render the source frames.
*/
class StateAdapter
: public StateClosure
: public StateClosure_OBSOLETE
{
protected:
StateClosure& parent_;
StateClosure& current_;
StateClosure_OBSOLETE& parent_;
StateClosure_OBSOLETE& current_;
StateAdapter (StateClosure& callingProcess)
StateAdapter (StateClosure_OBSOLETE& callingProcess)
: parent_ (callingProcess),
current_(callingProcess.getCurrentImplementation())
{ }
virtual StateClosure& getCurrentImplementation () { return current_; }
virtual StateClosure_OBSOLETE& getCurrentImplementation () { return current_; }
@ -131,7 +131,7 @@ namespace engine {
protected:
/** creates a new invocation context state, without FeedManifold */
Invocation (StateClosure& callingProcess, Connectivity const& w, uint o)
Invocation (StateClosure_OBSOLETE& callingProcess, Connectivity const& w, uint o)
: StateAdapter(callingProcess),
wiring(w), outNr(o),
feedManifold(0)
@ -179,7 +179,7 @@ namespace engine {
struct AllocBufferFromParent ///< using the parent StateAdapter for buffer allocations
: Invocation
{
AllocBufferFromParent (StateClosure& sta, Connectivity const& w, const uint outCh)
AllocBufferFromParent (StateClosure_OBSOLETE& sta, Connectivity const& w, const uint outCh)
: Invocation(sta, w, outCh) {}
virtual BuffHandle
@ -189,7 +189,7 @@ namespace engine {
struct AllocBufferFromCache ///< using the global current StateClosure, which will delegate to Cache
: Invocation
{
AllocBufferFromCache (StateClosure& sta, Connectivity const& w, const uint outCh)
AllocBufferFromCache (StateClosure_OBSOLETE& sta, Connectivity const& w, const uint outCh)
: Invocation(sta, w, outCh) {}
virtual BuffHandle
@ -218,7 +218,7 @@ namespace engine {
, private Strategy
{
public:
ActualInvocationProcess (StateClosure& callingProcess, Connectivity const& w, const uint outCh)
ActualInvocationProcess (StateClosure_OBSOLETE& callingProcess, Connectivity const& w, const uint outCh)
: BufferProvider(callingProcess, w, outCh)
{ }

2
src/steam/engine/nodeoperation.hpp
View file

@ -58,7 +58,7 @@
#include "steam/engine/proc-node.hpp"
#include "steam/engine/state-closure.hpp"
#include "steam/engine/state-closure-obsolete.hpp"
#include "steam/engine/channel-descriptor.hpp"
#include "steam/engine/nodeinvocation.hpp"
#include "steam/engine/feed-manifold.hpp"

2
src/steam/engine/nodewiring.hpp
View file

@ -76,7 +76,7 @@ namespace engine {
private:
virtual BuffHandle
callDown (StateClosure& currentProcess, uint requestedOutputNr) const
callDown (StateClosure_OBSOLETE& currentProcess, uint requestedOutputNr) const
{
STATE thisStep (currentProcess, *this, requestedOutputNr);
return thisStep.retrieve (); // fetch or calculate results

33
src/steam/engine/proc-node.hpp
View file

@ -32,19 +32,21 @@
** By using the builder interface, concrete node and wiring descriptor classes are created,
** based on some templates. These concrete classes form the "glue" to tie the node network
** together and contain much of the operation behaviour in a hard wired fashion.
**
**
** @todo WIP-WIP-WIP 2024 Node-Invocation is reworked from ground up for the »Playback Vertical Slice«
**
** @see nodefactory.hpp
** @see operationpoint.hpp
*/
#ifndef ENGINE_PROC_NODE_H
#define ENGINE_PROC_NODE_H
#ifndef STEAM_ENGINE_PROC_NODE_H
#define STEAM_ENGINE_PROC_NODE_H
#include "lib/error.hpp"
#include "steam/common.hpp"
#include "steam/asset/proc.hpp"
#include "steam/mobject/parameter.hpp"
#include "steam/engine/state-closure.hpp"
#include "steam/engine/state-closure-obsolete.hpp" /////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
#include "steam/engine/channel-descriptor.hpp"
#include "lib/frameid.hpp"
#include "lib/ref-array.hpp"
@ -59,8 +61,10 @@ namespace engine {
using std::vector;
using lumiera::NodeID;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
class ProcNode;
typedef ProcNode* PNode;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
/**
@ -73,10 +77,13 @@ namespace engine {
* starting from the player. Anyhow, you can expect the basic setup to remain as-is: there will
* be a ProcNode and a Connectivity descriptor, telling how it's connected to its predecessors,
* and defining how the Node is supposed to operate
*
* @todo WIP-WIP-WIP 2024 Node-Invocation is reworked from ground up for the »Playback Vertical Slice«
*/
class Connectivity
{
public: /* === public information record describing the node graph === */
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
uint nrO;
uint nrI;
@ -90,8 +97,10 @@ namespace engine {
NodeID const& nodeID;
virtual ~Connectivity() {}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
protected:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
Connectivity (lib::RefArray<ChannelDescriptor>& o,
lib::RefArray<InChanDescriptor>& i,
ProcFunc pFunc, NodeID const& nID)
@ -102,8 +111,10 @@ namespace engine {
nrO = out.size();
nrI = in.size();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
/* ==== strategy API for configuring the node operation ==== */
friend class ProcNode; /////////////////////////////////TODO 1/12 : wouldn't it be better to extract that API into a distinct strategy?
@ -114,7 +125,8 @@ namespace engine {
* @see NodeWiring#callDown default implementation
*/
virtual BuffHandle
callDown (StateClosure& currentProcess, uint requiredOutputNr) const =0;
callDown (StateClosure_OBSOLETE& currentProcess, uint requiredOutputNr) const =0;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
};
@ -130,6 +142,7 @@ namespace engine {
* The alternative would be to push down these information-retrieval part into a
* configurable element within Connectivity, in which case we even might drop
* ProcNode as a frontend entirely.
* @todo WIP-WIP-WIP 2024 Node-Invocation is reworked from ground up for the »Playback Vertical Slice«
*/
class ProcNode
: util::NonCopyable
@ -140,18 +153,22 @@ namespace engine {
const Connectivity& wiringConfig_;
public:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
ProcNode (Connectivity const& wd)
: wiringConfig_(wd)
{ }
virtual ~ProcNode() {}; /////////////////////////TODO: do we still intend to build a hierarchy below ProcNode???
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
public:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
bool isValid() const;
/** output channel count */
uint nrO() { return wiringConfig_.nrO; }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
/** Engine Core operation: render and pull output from this node.
@ -167,14 +184,16 @@ namespace engine {
* @return handle to the buffer containing the calculated result.
*/
BuffHandle
pull (StateClosure& currentProcess, uint requestedOutputNr=0) const
pull (StateClosure_OBSOLETE& currentProcess, uint requestedOutputNr=0) const
{
return this->wiringConfig_.callDown (currentProcess, requestedOutputNr);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
inline bool
ProcNode::isValid() const
{
@ -184,4 +203,4 @@ namespace engine {
}} // namespace steam::engine
#endif /*ENGINE_PROC_NODE_H*/
#endif /*STEAM_ENGINE_PROC_NODE_H*/

2
src/steam/engine/render-invocation.cpp
View file

@ -59,7 +59,9 @@ namespace engine {
REQUIRE (channel < size());
StateProxy invocationState;
#if false /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #1367 : Rebuild the Node Invocation
return theNode_->pull(invocationState, channel);
#endif /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #1367 : Rebuild the Node Invocation
}

2
src/steam/engine/rendergraph.cpp
View file

@ -27,7 +27,7 @@
#include "steam/engine/rendergraph.hpp"
#include "steam/engine/state-closure.hpp"
#include "steam/engine/state-closure-obsolete.hpp"
#include "lib/frameid.hpp"
namespace lumiera {

2
src/steam/engine/rendergraph.hpp
View file

@ -30,7 +30,7 @@
#define STEAM_ENGINE_RENDERGRAPH_H
#include "steam/common.hpp"
#include "steam/engine/state-closure.hpp"
#include "steam/engine/state-closure-obsolete.hpp"
#include "lib/time/timevalue.hpp"

122
src/steam/engine/state-closure-obsolete.hpp Normal file
View file

@ -0,0 +1,122 @@
/*
STATE-CLOSURE.hpp - Key Interface representing a render process and encapsulating state
Copyright (C) Lumiera.org
2008, 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 state-closure.hpp
** Access point to an ongoing render's processing state.
**
** @deprecated 2024 Node-Invocation is reworked from ground up for the »Playback Vertical Slice«
*/
#ifndef STEAM_ENGINE_STATE_CLOSURE_OBSOLETE_H
#define STEAM_ENGINE_STATE_CLOSURE_OBSOLETE_H
#include "lib/error.hpp"
#include "lib/frameid.hpp"
#include "steam/engine/buffhandle.hpp"
#include <cstddef>
namespace steam {
namespace engine {
using lumiera::FrameID;
using lumiera::NodeID;
class StateAdapter;
class BuffTableStorage;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
/**
* Abstraction to access the state of a currently ongoing render/calculation process,
* as it is tied to the supporting facilities of the vault layer. An StateClosure (subclass) instance
* is the sole connection for the render node to invoke services of the vault needed
* to carry out the calculations.
*
* @see engine::RenderInvocation top-level entrance point
* @see nodeinvocation.hpp impl. used from \em within the nodes
*/
class StateClosure_OBSOLETE
{
////////////////////////////////////////////////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
* 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
* at the actual buffer address and for releasing the buffer.
*/
virtual BuffHandle allocateBuffer (const lumiera::StreamType*) =0;
/** resign control of the buffer denoted by the handle */
virtual void releaseBuffer (BuffHandle&) =0;
/** declare the data contained in the Buffer to be ready.
* The caller is required to restrain itself from modifying the data
* afterwards, as this buffer now can be used (readonly) by other
* calculation processes in parallel.
*/
virtual void is_calculated (BuffHandle const&) =0;
/** generate (or calculate) an ID denoting a media data frame
* appearing at the given position in the render network,
* for the time point this rendering process is currently
* calculating data for.
* @param NodeID the unique identification of a specific node
* @param chanNo the number of the output channel of this node
* @return a complete FrameID which unambiguously denotes this
* specific frame and can be used for caching
*/
virtual FrameID const& genFrameID (NodeID const&, uint chanNo) =0;
/** try to fetch an existing buffer containing the denoted frame
* from a cache or similar backing system (e.g. network peer).
* @return either a handle to a readonly buffer, or a null handle
* @note the client is responsible for not modifying the provided data
*/
virtual BuffHandle fetch (FrameID const&) =0;
/** necessary for creating a local BuffTableChunk */
virtual BuffTableStorage& getBuffTableStorage() =0;
protected:
virtual ~StateClosure_OBSOLETE() {};
/** resolves to the StateClosure object currently "in charge".
* Intended as a performance shortcut to avoid calling
* up through a chain of virtual functions when deep down
* in chained ProcNode::pull() calls. This allows derived
* classes to proxy the state interface.
*/
virtual StateClosure_OBSOLETE& getCurrentImplementation () =0;
friend class engine::StateAdapter;
};
}} // namespace steam::engine
#endif /*STEAM_ENGINE_STATE_CLOSURE_OBSOLETE_H*/

5
src/steam/engine/state-closure.hpp
View file

@ -23,6 +23,9 @@
/** @file state-closure.hpp
** Access point to an ongoing render's processing state.
**
** @todo WIP-WIP-WIP 2024 Node-Invocation is reworked from ground up for the »Playback Vertical Slice«
**
*/
@ -58,7 +61,7 @@ namespace engine {
*/
class StateClosure
{
////////////////////////////////////////////////TICKET #826 expected to be reworked to quite some extent (9/2011)
/////////////////////////////////////////////////////////////////////////////////////////////////////////////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

10
src/steam/engine/turnout-system.hpp
View file

@ -33,11 +33,13 @@
*/
#ifndef ENGINE_TURNOUT_SYSTEM_H
#define ENGINE_TURNOUT_SYSTEM_H
#ifndef STEAM_ENGINE_TURNOUT_SYSTEM_H
#define STEAM_ENGINE_TURNOUT_SYSTEM_H
#include "steam/engine/proc-node.hpp"
#include "steam/engine/state-closure.hpp"
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
namespace steam {
@ -45,6 +47,7 @@ namespace engine {
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
class StateProxy
: public StateClosure
{
@ -66,8 +69,9 @@ namespace engine {
virtual StateClosure& getCurrentImplementation () { return *this; }
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
}} // namespace steam::engine
#endif /*ENGINE_TURNOUT_SYSTEM_H*/
#endif /*STEAM_ENGINE_TURNOUT_SYSTEM_H*/

257
src/steam/engine/turnout.hpp Normal file
View file

@ -0,0 +1,257 @@
/*
TURNOUT.hpp - Organise the invocation state within a single pull() call
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>
2024, 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 turnout.hpp
** Organise the state related to the invocation of s single ProcNode::pull() call
** This header defines part of the "glue" which holds together the render node network
** and enables to pull result frames from the nodes. Doing so requires some invocation
** local state to be maintained, especially a table of buffers used to carry out the
** calculations. Further, getting the input buffers filled requires to issue recursive
** \c pull() calls, which on the whole creates a stack-like assembly of local invocation
** state.
** The actual steps to be carried out for a \c pull() call are dependent on the configuration
** of the node to pull. Each node has been preconfigured by the builder with a Connectivity
** descriptor and a concrete type of a StateAdapter. The actual sequence of steps is defined
** in the header nodeoperation.hpp out of a set of basic operation steps. These steps all use
** the passed in Invocation object (a sub-interface of StateAdapter) to access the various
** aspects of the invocation state.
**
** # composition of the Invocation State
**
** For each individual ProcNode#pull() call, the WiringAdapter#callDown() builds an StateAdapter
** instance directly on the stack, managing the actual buffer pointers and state references. Using this
** StateAdapter, the predecessor nodes are pulled. The way these operations are carried out is encoded
** in the actual StateAdapter type known to the NodeWiring (WiringAdapter) instance. All of these actual
** StateAdapter types are built as implementing the engine::StateClosure interface.
**
** @todo relies still on an [obsoleted implementation draft](\ref bufftable-obsolete.hpp)
** @see engine::ProcNode
** @see engine::StateProxy
** @see engine::FeedManifold
** @see nodewiring.hpp interface for building/wiring the nodes
**
** @warning as of 4/2023 a complete rework of the Dispatcher is underway ///////////////////////////////////////////TICKET #1275
**
*/
#ifndef STEAM_ENGINE_TURNOUT_H
#define STEAM_ENGINE_TURNOUT_H
#include <steam/engine/state-closure-obsolete.hpp>
#include "steam/common.hpp"
#include "steam/engine/proc-node.hpp"
#include "steam/engine/turnout-system.hpp"
#include "steam/engine/feed-manifold.hpp"
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
#include "steam/engine/channel-descriptor.hpp"
//#include "vault/gear/job.h"
//#include "steam/engine/exit-node.hpp"
//#include "lib/time/timevalue.hpp"
//#include "lib/linked-elements.hpp"
//#include "lib/util-foreach.hpp"
//#include "lib/iter-adapter.hpp"
//#include "lib/itertools.hpp"
//#include "lib/util.hpp"
//#include <utility>
//#include <stack>
namespace steam {
namespace engine {
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
/**
* Adapter to shield the ProcNode from the actual buffer management,
* allowing the processing function within ProcNode to use logical
* buffer IDs. StateAdapter is created on the stack for each pull()
* call, using setup/wiring data preconfigured by the builder.
* Its job is to provide the actual implementation of the Cache
* push / fetch and recursive downcall to render the source frames.
*/
class StateAdapter
: public StateClosure
{
protected:
StateClosure& parent_;
StateClosure& current_;
StateAdapter (StateClosure& callingProcess)
: parent_ (callingProcess),
current_(callingProcess.getCurrentImplementation())
{ }
virtual StateClosure& getCurrentImplementation () { return current_; }
public: /* === proxying the StateClosure interface === */
virtual void releaseBuffer (BuffHandle& bh) { current_.releaseBuffer (bh); }
virtual void is_calculated (BuffHandle const& bh) { current_.is_calculated (bh); }
virtual BuffHandle fetch (FrameID const& fID) { return current_.fetch (fID); }
virtual BuffTableStorage& getBuffTableStorage() { return current_.getBuffTableStorage(); }
// note: allocateBuffer() is chosen specifically based on the actual node wiring
};
/**
* Invocation context state.
* A ref to this type is carried through the chain of NEXT::step() functions
* which form the actual invocation sequence. The various operations in this sequence
* access the context via the references in this struct, while also using the inherited
* public State interface. The object instance actually used as Invocation is created
* on the stack and parametrised according to the necessities of the invocation sequence
* actually configured. Initially, this real instance is configured without FeedManifold,
* because the invocation may be short-circuited due to Cache hit. Otherwise, when
* the invocation sequence actually prepares to call the process function of this
* ProcNode, a buffer table chunk is allocated by the StateProxy and wired in.
*/
struct Invocation
: StateAdapter
{
Connectivity const& wiring;
const uint outNr;
FeedManifold* feedManifold;
protected:
/** creates a new invocation context state, without FeedManifold */
Invocation (StateClosure& callingProcess, Connectivity const& w, uint o)
: StateAdapter(callingProcess),
wiring(w), outNr(o),
feedManifold(0)
{ }
public:
uint nrO() const { return wiring.nrO; }
uint nrI() const { return wiring.nrI; }
uint buffTabSize() const { return nrO()+nrI(); }
/** setup the link to an externally allocated buffer table */
void setBuffTab (FeedManifold* b) { this->feedManifold = b; }
bool
buffTab_isConsistent ()
{
return (feedManifold)
&& (0 < buffTabSize())
&& (nrO()+nrI() <= buffTabSize())
&& (feedManifold->inBuff == &feedManifold->outBuff[nrO()] )
&& (feedManifold->inHandle == &feedManifold->outHandle[nrO()])
;
}
public:
/** specialised version filling in the additional information, i.e
* the concrete node id and the channel number in question */
virtual FrameID const&
genFrameID ()
{
return current_.genFrameID(wiring.nodeID, outNr);
}
virtual FrameID const&
genFrameID (NodeID const& nID, uint chanNo)
{
return current_.genFrameID (nID,chanNo);
}
};
////////////TICKET #249 this strategy should better be hidden within the BuffHandle ctor (and type-erased after creation)
struct AllocBufferFromParent ///< using the parent StateAdapter for buffer allocations
: Invocation
{
AllocBufferFromParent (StateClosure& sta, Connectivity const& w, const uint outCh)
: Invocation(sta, w, outCh) {}
virtual BuffHandle
allocateBuffer (const lumiera::StreamType* ty) { return parent_.allocateBuffer(ty); } ////////////TODO: actually implement the "allocate from parent" logic!
};
struct AllocBufferFromCache ///< using the global current StateClosure, which will delegate to Cache
: Invocation
{
AllocBufferFromCache (StateClosure& sta, Connectivity const& w, const uint outCh)
: Invocation(sta, w, outCh) {}
virtual BuffHandle
allocateBuffer (const lumiera::StreamType* ty) { return current_.allocateBuffer(ty); }
};
/**
* The real invocation context state implementation. It is created
* by the NodeWiring (Connectivity) of the processing node which
* is pulled by this invocation, hereby using the internal configuration
* information to guide the selection of the real call sequence
*
* \par assembling the call sequence implementation
* Each ProcNode#pull() call creates such a StateAdapter subclass on the stack,
* with a concrete type according to the Connectivity of the node to pull.
* This concrete type encodes a calculation Strategy, which is assembled
* as a chain of policy templates on top of OperationBase. For each of the
* possible configurations we define such a chain (see bottom of nodeoperation.hpp).
* The WiringFactory defined in nodewiring.cpp actually drives the instantiation
* of all those possible combinations.
*/
template<class Strategy, class BufferProvider>
class ActualInvocationProcess
: public BufferProvider
, private Strategy
{
public:
ActualInvocationProcess (StateClosure& callingProcess, Connectivity const& w, const uint outCh)
: BufferProvider(callingProcess, w, outCh)
{ }
/** contains the details of Cache query and recursive calls
* to the predecessor node(s), eventually followed by the
* ProcNode::process() callback
*/
BuffHandle retrieve ()
{
return Strategy::step (*this);
}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation
}}// namespace steam::engine
#endif /*STEAM_ENGINE_TURNOUT_H*/

2
src/steam/mobject/builder/operationpoint.cpp
View file

@ -31,7 +31,7 @@
#include "steam/engine/proc-node.hpp"
#include "steam/asset/media.hpp"
#include "steam/asset/proc.hpp"
#include "steam/engine/nodefactory.hpp"
#include "steam/engine/node-factory.hpp"
#include "steam/streamtype.hpp"
//#include "common/util.hpp"

2
tests/core/steam/engine/feed-manifold-test.cpp
View file

@ -77,7 +77,7 @@ namespace test {
virtual uint getNrI() const { return ii; }
virtual uint getNrO() const { return oo; }
virtual BuffHandle callDown (StateClosure&, uint) const
virtual BuffHandle callDown (StateClosure_OBSOLETE&, uint) const
{ throw lumiera::Error("not intended to be called"); }
};

4
tests/core/steam/engine/node-basic-test.cpp
View file

@ -26,7 +26,7 @@
#include "lib/test/run.hpp"
#include "steam/engine/nodefactory.hpp"
#include "steam/engine/node-factory.hpp"
#include "steam/engine/nodewiring.hpp"
#include "steam/engine/turnout-system.hpp"
#include "steam/engine/channel-descriptor.hpp"
@ -94,10 +94,12 @@ namespace test {
CHECK (pNode);
TestContext simulatedInvocation;
#if false /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #1367 : Rebuild the Node Invocation
BuffHandle result = pNode->pull(simulatedInvocation, 0);
CHECK (result);
// CHECK we got calculated data in the result buffer
#endif /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #1367 : Rebuild the Node Invocation
}
};

4
wiki/renderengine.html
View file

@ -6183,7 +6183,7 @@ This is the core service provided by the player subsystem. The purpose is to cre
:any details of this processing remain opaque for the clients; even the player subsystem just accesses the EngineFaçade
</pre>
</div>
<div title="PlaybackVerticalSlice" creator="Ichthyostega" modifier="Ichthyostega" created="202303272236" modified="202404222258" tags="overview impl discuss draft" changecount="39">
<div title="PlaybackVerticalSlice" creator="Ichthyostega" modifier="Ichthyostega" created="202303272236" modified="202406211422" tags="overview impl discuss draft" changecount="40">
<pre>//Integration effort to promote the development of rendering, playback and video display in the GUI//
This IntegrationSlice was started in {{red{2023}}} as [[Ticket #1221|https://issues.lumiera.org/ticket/1221]] to coordinate the completion and integration of various implementation facilities, planned, drafted and built during the last years; this effort marks the return of development focus to the lower layers (after years of focussed UI development) and will implement the asynchronous and time-bound rendering coordinated by the [[Scheduler]] in the [[Vault|Vault-Layer]]
@ -6219,7 +6219,9 @@ The Scheduler will be structured into two Layers, where the lower layer is imple
__December.23__: building the Scheduler required time and dedication, including some related topics like a [[suitable memory management scheme|SchedulerMemory]], rework and modernisation of the [[#1279 thread handling framework|https://issues.lumiera.org/ticket/1279]], using a [[worker pool|SchedulerWorker]] and developing the [[foundation for load control|SchedulerLoadControl]]. This amounts to the creation of a considerable body of new code; some &amp;rarr;[[load- and stress testing|SchedulerTest]] helps to establish &amp;rarr;[[performance characteristics and traits|SchedulerBehaviour]].
__April.24__: after completing an extended round of performance tests for the new Scheduler, development focus is shifted now shifted upwards to the [[Render Node Network|ProcNode]], where Engine activity is carried out. This part was addressed at the very start of the project, and later again -- yet could never be completed, due to a lack of clear reference points and technical requirements. Hope to achieve a breakthrough rests on this integration effort now.
__June.24__: assessment of the existing code indicated some parts not well suited to the expected usage. Notably the {{{AllocationCluster}}}, which is the custom allocator used by the render nodes network, was reworked and simplified. Moreover, a new custom container was developed, to serve as //link to connect the nodes.// Beyond that, in-depth review validated the existing design for the render nodes, while also implying some renaming and rearrangements
* 🗘 establish a test setup for developing render node functionality
* 🗘 build, connect and invoke some dummy render nodes directly in a test setup
* ⌛ introduce a middle layer for linking the JobTicket to the actual invocation
* ⌛ rework and complete the existing node invocation code

399
wiki/thinkPad.ichthyo.mm
View file

@ -80157,7 +80157,7 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
</p>
</body>
</html></richcontent>
<arrowlink COLOR="#889fa8" DESTINATION="ID_1346581014" ENDARROW="Default" ENDINCLINATION="80;-96;" ID="Arrow_ID_377227941" STARTARROW="None" STARTINCLINATION="-288;25;"/>
<arrowlink COLOR="#889fa8" DESTINATION="ID_1346581014" ENDARROW="Default" ENDINCLINATION="80;-96;" ID="Arrow_ID_377227941" STARTARROW="None" STARTINCLINATION="-288;23;"/>
<icon BUILTIN="idea"/>
</node>
</node>
@ -80180,7 +80180,7 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
</p>
</body>
</html></richcontent>
<linktarget COLOR="#889fa8" DESTINATION="ID_1346581014" ENDARROW="Default" ENDINCLINATION="80;-96;" ID="Arrow_ID_377227941" SOURCE="ID_1241935016" STARTARROW="None" STARTINCLINATION="-288;25;"/>
<linktarget COLOR="#889fa8" DESTINATION="ID_1346581014" ENDARROW="Default" ENDINCLINATION="80;-96;" ID="Arrow_ID_377227941" SOURCE="ID_1241935016" STARTARROW="None" STARTINCLINATION="-288;23;"/>
<font ITALIC="true" NAME="SansSerif" SIZE="14"/>
<icon BUILTIN="yes"/>
<node CREATED="1683766676673" ID="ID_1958408222" MODIFIED="1683766698835" TEXT="alle weitere Flexibilit&#xe4;t ist im JobFunktor bereits vorverdrahtet"/>
@ -80386,6 +80386,25 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
<node CREATED="1714779971374" ID="ID_881165967" MODIFIED="1714779986055" TEXT="die Liste der ModelPorts wandert dann in die ExitNode"/>
</node>
</node>
<node CREATED="1718840198722" ID="ID_821758494" MODIFIED="1718973353638" TEXT="Fazit (1:N)">
<linktarget COLOR="#77274c" DESTINATION="ID_821758494" ENDARROW="Default" ENDINCLINATION="-254;66;" ID="Arrow_ID_474260214" SOURCE="ID_811413379" STARTARROW="None" STARTINCLINATION="811;-49;"/>
<linktarget COLOR="#6c5499" DESTINATION="ID_821758494" ENDARROW="Default" ENDINCLINATION="-305;510;" ID="Arrow_ID_1100764489" SOURCE="ID_290743732" STARTARROW="None" STARTINCLINATION="891;35;"/>
<node CREATED="1718840201860" ID="ID_589597825" MODIFIED="1718840211116" TEXT="die ExitNode bekommt eine neue Rolle"/>
<node CREATED="1718840212128" ID="ID_815017645" MODIFIED="1718840220877" TEXT="...n&#xe4;mlich genau dieses Mapping zu leisten">
<node CREATED="1718840222671" ID="ID_965571589" MODIFIED="1718840253430" TEXT="high-Level ggfs strukturierte Model-Ports"/>
<node CREATED="1718840235653" ID="ID_1193824692" MODIFIED="1718840248359" TEXT="einfache Liste direkt renderbare Model-Ports"/>
</node>
<node CREATED="1718840493478" ID="ID_1818629071" MODIFIED="1718840531013" TEXT="RenderDrive &#x27fc; ExitNode &#x27fc; konkreter ModelPort">
<node CREATED="1718840533377" ID="ID_384875437" MODIFIED="1718840544276" TEXT="aus dem RenderDrive kommt eine Selector-ID"/>
<node CREATED="1718840546287" ID="ID_1115734390" MODIFIED="1718840557120" TEXT="die ExitNode kann diese interpretieren"/>
<node CREATED="1718841574472" ID="ID_272649775" MODIFIED="1718841591782" TEXT="und findet so zur richtigen top-Level-Node"/>
</node>
<node CREATED="1718841610297" ID="ID_1668830479" MODIFIED="1718841624857" TEXT="wenn es mehrere CalcStreams zum Feed gibt....">
<node CREATED="1718841642592" ID="ID_1316895881" MODIFIED="1718841654773" TEXT="dann gibt es auch mehrere RenderDrives"/>
<node CREATED="1718841662566" ID="ID_1395716127" MODIFIED="1718841677530" TEXT="und jedes von denen hat eine spezielle &#xbb;Inkantation&#xab;"/>
<node CREATED="1718841690787" ID="ID_1330084500" MODIFIED="1718841704342" TEXT="und findet damit zur passenden Node + DataSink"/>
</node>
</node>
</node>
</node>
</node>
@ -80570,7 +80589,8 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1714781014484" ID="ID_784858734" MODIFIED="1714869590437" TEXT="Umbau: ExitNode &#xfc;bernimmt bisherite Rolle des NodeGraphAttachment">
<linktarget COLOR="#d55e87" DESTINATION="ID_784858734" ENDARROW="Default" ENDINCLINATION="-704;27;" ID="Arrow_ID_1275017209" SOURCE="ID_760280600" STARTARROW="None" STARTINCLINATION="-466;33;"/>
<icon BUILTIN="flag-yellow"/>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1714781047574" ID="ID_811413379" MODIFIED="1714781095403" TEXT="Festzulegen: konkrete Ansteuerung des ModelPort">
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1714781047574" ID="ID_811413379" MODIFIED="1718972954666" TEXT="Festzulegen: konkrete Ansteuerung des ModelPort">
<arrowlink COLOR="#77274c" DESTINATION="ID_821758494" ENDARROW="Default" ENDINCLINATION="-254;66;" ID="Arrow_ID_474260214" STARTARROW="None" STARTINCLINATION="811;-49;"/>
<icon BUILTIN="yes"/>
</node>
<node BACKGROUND_COLOR="#f0d5c5" COLOR="#990033" CREATED="1714781065341" ID="ID_1131396679" MODIFIED="1714781088654" TEXT="zu Kl&#xe4;ren: welche Services braucht nun konkret das JobTicket?">
@ -80699,8 +80719,11 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
<font NAME="SansSerif" SIZE="10"/>
<icon BUILTIN="smiley-oh"/>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1713716178243" ID="ID_963083918" MODIFIED="1715525599457" TEXT="Interface State &#x27fc; StateClosure">
<linktarget COLOR="#a9b4c1" DESTINATION="ID_963083918" ENDARROW="Default" ENDINCLINATION="423;38;" ID="Arrow_ID_674451029" SOURCE="ID_535326092" STARTARROW="None" STARTINCLINATION="1145;-57;"/>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1713716178243" ID="ID_963083918" MODIFIED="1718931650244" TEXT="Invocation-State(Interface) &#x27fc; StateClosure">
<linktarget COLOR="#a9b4c1" DESTINATION="ID_963083918" ENDARROW="Default" ENDINCLINATION="434;27;" ID="Arrow_ID_674451029" SOURCE="ID_535326092" STARTARROW="None" STARTINCLINATION="1145;-57;"/>
<icon BUILTIN="yes"/>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1718931597978" ID="ID_1151948258" MODIFIED="1718931625095" TEXT="Output-Descriptor &#x27fc; Port(Interface)">
<icon BUILTIN="yes"/>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1715525498827" ID="ID_1523105954" MODIFIED="1715525588112" TEXT="StateAdapter &#x27fc; Turnout">
@ -80709,6 +80732,9 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1715525608159" ID="ID_646555361" MODIFIED="1715525641420" TEXT="StateProxy &#x27fc; TurnoutSystem">
<icon BUILTIN="yes"/>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1715039008633" ID="ID_1120940896" LINK="#ID_1617576533" MODIFIED="1718922202148" TEXT="WiringSituation &#x27fc; NodeWiringBuilder">
<icon BUILTIN="yes"/>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1714909003260" ID="ID_1583145480" MODIFIED="1714909025469" TEXT="WiringCoinfig &#x27fc; Connectivity">
<icon BUILTIN="yes"/>
</node>
@ -80944,6 +80970,7 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
</body>
</html></richcontent>
</node>
<node CREATED="1718931493231" ID="ID_1646405746" MODIFIED="1718931534366" TEXT="daf&#xfc;r &#xd83e;&#xdc32; hat jede Node nun N &#xbb;Ports&#xab;"/>
</node>
<node CREATED="1714870436580" ID="ID_429441528" MODIFIED="1714870447138" TEXT="DataSink vs OutputBuffer">
<node CREATED="1714870584943" ID="ID_227448109" MODIFIED="1714870642457" TEXT="seinerzeit nicht bis dahin durchgedrungen">
@ -81048,8 +81075,9 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
</html></richcontent>
</node>
</node>
<node BACKGROUND_COLOR="#f8f1cb" COLOR="#a50125" CREATED="1715625161792" ID="ID_748407633" MODIFIED="1715625275278" TEXT="Zweifel an bestehender Allocation-Cluster-Implemenierung">
<arrowlink COLOR="#fd2206" DESTINATION="ID_741455291" ENDARROW="Default" ENDINCLINATION="371;-21;" ID="Arrow_ID_148841438" STARTARROW="None" STARTINCLINATION="988;41;"/>
<node BACKGROUND_COLOR="#c8c0b6" COLOR="#690f5e" CREATED="1715625161792" ID="ID_748407633" MODIFIED="1718925925369" TEXT="Zweifel an bestehender Allocation-Cluster-Implemenierung">
<arrowlink COLOR="#6b0fc6" DESTINATION="ID_741455291" ENDARROW="Default" ENDINCLINATION="371;-21;" ID="Arrow_ID_148841438" STARTARROW="None" STARTINCLINATION="993;48;"/>
<arrowlink COLOR="#595491" DESTINATION="ID_1422136136" ENDARROW="Default" ENDINCLINATION="114;10;" ID="Arrow_ID_566134152" STARTARROW="None" STARTINCLINATION="126;6;"/>
<icon BUILTIN="messagebox_warning"/>
<node CREATED="1715625311161" ID="ID_1762606958" MODIFIED="1715625461924" TEXT="der unterliegende Memory-Manager ist ungekl&#xe4;rt">
<richcontent TYPE="NOTE"><html>
@ -81077,12 +81105,20 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
<icon BUILTIN="yes"/>
<node CREATED="1714870511447" ID="ID_698798351" MODIFIED="1714870529856" TEXT="NodeGraphAttachment in ExitNode umwandeln"/>
<node CREATED="1714870530945" ID="ID_1030439043" MODIFIED="1714870546389" TEXT="bisherige skizzierte Rolle er ExitNode zur&#xfc;ckbauen"/>
<node COLOR="#006e88" CREATED="1718925779772" ID="ID_1422136136" MODIFIED="1718925901741" TEXT="AllocationCluster umschreiben">
<linktarget COLOR="#595491" DESTINATION="ID_1422136136" ENDARROW="Default" ENDINCLINATION="114;10;" ID="Arrow_ID_566134152" SOURCE="ID_748407633" STARTARROW="None" STARTINCLINATION="126;6;"/>
<icon BUILTIN="button_ok"/>
</node>
<node CREATED="1714872094981" ID="ID_1665864694" MODIFIED="1714872109269" TEXT="Reste der BuffTable aus dem 1.Entwurf"/>
<node CREATED="1714872110793" ID="ID_535326092" MODIFIED="1714908421288" TEXT="Name &quot;State&quot; : schl&#xfc;ssigeres Benennungs-Schema">
<arrowlink DESTINATION="ID_963083918" ENDARROW="Default" ENDINCLINATION="423;38;" ID="Arrow_ID_674451029" STARTARROW="None" STARTINCLINATION="1145;-57;"/>
<node CREATED="1714872110793" ID="ID_535326092" MODIFIED="1718931650244" TEXT="Name &quot;State&quot; : schl&#xfc;ssigeres Benennungs-Schema">
<arrowlink DESTINATION="ID_963083918" ENDARROW="Default" ENDINCLINATION="434;27;" ID="Arrow_ID_674451029" STARTARROW="None" STARTINCLINATION="1145;-57;"/>
</node>
<node CREATED="1715523610870" ID="ID_1129364168" MODIFIED="1715523630439" TEXT="Invocation + StateAdapter + TurnoutSystem fallen zusammen"/>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1715526750604" ID="ID_208674861" MODIFIED="1718817889363" TEXT="RefArray modernisieren">
<node CREATED="1718931702946" ID="ID_1034026390" MODIFIED="1718931836347" TEXT="Wiring und Wiring-Situation(Builder) entflechten">
<arrowlink COLOR="#a05d70" DESTINATION="ID_1237866779" ENDARROW="Default" ENDINCLINATION="-821;-34;" ID="Arrow_ID_1472508814" STARTARROW="None" STARTINCLINATION="1345;85;"/>
</node>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1715526750604" ID="ID_208674861" MODIFIED="1718884602859" TEXT="RefArray modernisieren">
<linktarget COLOR="#4a83b7" DESTINATION="ID_208674861" ENDARROW="Default" ENDINCLINATION="-781;83;" ID="Arrow_ID_1861027884" SOURCE="ID_561930764" STARTARROW="None" STARTINCLINATION="-1002;-113;"/>
<icon BUILTIN="pencil"/>
<node CREATED="1715526756800" ID="ID_364406773" MODIFIED="1715526765735" TEXT="sollte sich Richtung Concept bewegen"/>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1715526766314" ID="ID_1523408221" MODIFIED="1715526784381" TEXT="Vorsicht: eine Neben-Verwendung in der Session (ElementTracker)">
@ -81096,16 +81132,27 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
</node>
</node>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1713819879109" ID="ID_943908122" MODIFIED="1713819899886" TEXT="Entwurf und Aufbau">
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1713819879109" ID="ID_943908122" MODIFIED="1718843746703" TEXT="Entwurf und Aufbau">
<arrowlink COLOR="#c80a37" DESTINATION="ID_845562088" ENDARROW="Default" ENDINCLINATION="-130;10;" ID="Arrow_ID_66382855" STARTARROW="None" STARTINCLINATION="42;-31;"/>
<arrowlink COLOR="#fdd3b6" DESTINATION="ID_1102491970" ENDARROW="Default" ENDINCLINATION="-366;-51;" ID="Arrow_ID_1227159439" STARTARROW="None" STARTINCLINATION="30;255;"/>
<linktarget COLOR="#fde0ca" DESTINATION="ID_943908122" ENDARROW="Default" ENDINCLINATION="-1682;204;" ID="Arrow_ID_1115019309" SOURCE="ID_1278689110" STARTARROW="None" STARTINCLINATION="-1643;116;"/>
<icon BUILTIN="flag-yellow"/>
<node CREATED="1713820093819" ID="ID_1401449333" MODIFIED="1713823888370" TEXT="Zugangsweg">
<icon BUILTIN="forward"/>
<node CREATED="1713820133641" ID="ID_888185703" MODIFIED="1713820154894" TEXT="Gliederung in drei Stufen">
<node CREATED="1713820156058" ID="ID_196721850" MODIFIED="1713820161892" TEXT="Node-Graph bauen"/>
<node CREATED="1713820162707" ID="ID_754976135" MODIFIED="1713820243651" TEXT="Turnout-System anlegen"/>
<node CREATED="1713820261701" ID="ID_308303726" MODIFIED="1713820265885" TEXT="Einzelausf&#xfc;hrung linken"/>
<node CREATED="1713820133641" ID="ID_888185703" MODIFIED="1718842764783" TEXT="Gliederung in drei Stufen">
<icon BUILTIN="forward"/>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1713820156058" ID="ID_196721850" MODIFIED="1718842750512" STYLE="bubble" TEXT="Node-Graph bauen">
<edge COLOR="#9d5e87"/>
<icon BUILTIN="full-1"/>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1713820162707" ID="ID_754976135" MODIFIED="1718842754526" STYLE="bubble" TEXT="Turnout-System anlegen">
<edge COLOR="#9d5e87"/>
<icon BUILTIN="full-2"/>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1713820261701" ID="ID_308303726" MODIFIED="1718842758220" STYLE="bubble" TEXT="Einzelausf&#xfc;hrung linken">
<edge COLOR="#9d5e87"/>
<icon BUILTIN="full-3"/>
</node>
</node>
<node CREATED="1713823582760" ID="ID_857212769" MODIFIED="1713823865318" TEXT="Kl&#xe4;rung: einfach &#x27f6; komplex">
<icon BUILTIN="yes"/>
@ -81217,7 +81264,8 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
<linktarget COLOR="#55567b" DESTINATION="ID_1605763598" ENDARROW="Default" ENDINCLINATION="122;4;" ID="Arrow_ID_610262787" SOURCE="ID_270340884" STARTARROW="Default" STARTINCLINATION="112;4;"/>
</node>
</node>
<node CREATED="1714955621585" ID="ID_1431510635" MODIFIED="1714955652952" TEXT="diese Analyse zeigt: hierf&#xfc;r ist stets irgendwo eine Spezialbehandlung notwendig">
<node CREATED="1714955621585" ID="ID_1431510635" MODIFIED="1718969080504" TEXT="diese Analyse zeigt: hierf&#xfc;r ist stets irgendwo eine Spezialbehandlung notwendig">
<arrowlink COLOR="#4441d1" DESTINATION="ID_685938023" ENDARROW="Default" ENDINCLINATION="312;-9;" ID="Arrow_ID_120542506" STARTARROW="Default" STARTINCLINATION="236;32;"/>
<node CREATED="1714955711147" ID="ID_467104305" MODIFIED="1714955727685" TEXT="und zwar im Zusammenhang mit der Pull/Aufruf-Steuerung"/>
<node CREATED="1714955841766" ID="ID_790467122" MODIFIED="1714955867147" TEXT="es kann nicht vollst&#xe4;ndig auf ein einfacheres Muster zur&#xfc;ckgef&#xfc;hrt werden"/>
<node CREATED="1714955904265" ID="ID_1418095631" MODIFIED="1714955937657" TEXT="&#x27f9; daher erscheint es sinnvoll, dies in der Infrastruktur zu handhaben (TurnoutSystem)"/>
@ -81271,7 +81319,7 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
</body>
</html></richcontent>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1715039008633" ID="ID_843551056" MODIFIED="1715039202734" TEXT="Beschlu&#xdf;: WiringSituation &#x27fc; NodeWiringBuilder">
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1715039008633" ID="ID_843551056" LINK="#ID_1120940896" MODIFIED="1715039202734" TEXT="Beschlu&#xdf;: WiringSituation &#x27fc; NodeWiringBuilder">
<icon BUILTIN="yes"/>
</node>
</node>
@ -81571,8 +81619,9 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
<icon BUILTIN="button_ok"/>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1715625094577" FOLDED="true" ID="ID_1764137888" MODIFIED="1718816065684" TEXT="mu&#xdf; Allocator-Integration kl&#xe4;ren">
<icon BUILTIN="yes"/>
<node CREATED="1715625132676" ID="ID_741455291" MODIFIED="1715625275278" TEXT="bestehende Allocation-Cluster-Impl erscheint nicht ganz passend">
<linktarget COLOR="#fd2206" DESTINATION="ID_741455291" ENDARROW="Default" ENDINCLINATION="371;-21;" ID="Arrow_ID_148841438" SOURCE="ID_748407633" STARTARROW="None" STARTINCLINATION="988;41;"/>
<node BACKGROUND_COLOR="#dfd38c" COLOR="#53237e" CREATED="1715625132676" ID="ID_741455291" MODIFIED="1718925812606" TEXT="bestehende Allocation-Cluster-Impl erscheint nicht ganz passend">
<linktarget COLOR="#6b0fc6" DESTINATION="ID_741455291" ENDARROW="Default" ENDINCLINATION="371;-21;" ID="Arrow_ID_148841438" SOURCE="ID_748407633" STARTARROW="None" STARTINCLINATION="993;48;"/>
<icon BUILTIN="messagebox_warning"/>
<node CREATED="1715625871491" ID="ID_1677812273" MODIFIED="1715626046458" TEXT="man kann das definitiv passender implementieren">
<richcontent TYPE="NOTE"><html>
<head/>
@ -84939,14 +84988,17 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
</node>
<node CREATED="1715472442363" ID="ID_1480789204" MODIFIED="1715472459879" TEXT="es arbeitet eine vorkonfigurierte Template-Method ab"/>
<node CREATED="1715473103299" ID="ID_769047663" MODIFIED="1715473112686" TEXT="Implementierungs-M&#xf6;glichkeiten hierf&#xfc;r">
<node CREATED="1715473151973" ID="ID_876263334" MODIFIED="1715473216352" TEXT="der Aufruf legt &#xbb;Weichenstellungen&#xab; in einer Datenstruktur bereit">
<node CREATED="1715473151973" ID="ID_876263334" MODIFIED="1718930881759" TEXT="der Aufruf legt &#xbb;Weichenstellungen&#xab; in einer Datenstruktur bereit">
<icon BUILTIN="button_cancel"/>
<node CREATED="1715473619835" ID="ID_1572580022" MODIFIED="1715473694560" TEXT="ein vorbereiteter Funktor populiert eine transiente Datenstruktur"/>
<node CREATED="1715473695268" ID="ID_974732321" MODIFIED="1715473704087" TEXT="diese ist dann &#xfc;ber die State-Closure zug&#xe4;nglich"/>
<node CREATED="1715473705035" ID="ID_1737871340" MODIFIED="1715473736518" TEXT="die Invocation auf einzelnen Ebenen enth&#xe4;lt Callbacks"/>
<node CREATED="1715473737327" ID="ID_744715954" MODIFIED="1715473757108" TEXT="diese holen sich die Entscheidungs-Marken aus der transienten Struktur"/>
<node CREATED="1715473794263" ID="ID_1555808272" MODIFIED="1715473808208" TEXT="&#x27f9; die Vorbereitung mu&#xdf; einen Tree-Walk machen"/>
</node>
<node CREATED="1715473220139" ID="ID_1737288938" MODIFIED="1715473454212" TEXT="die Template-Method ist in die Node-Connectivity integriert">
<node CREATED="1715473220139" ID="ID_1737288938" MODIFIED="1718931997853" TEXT="die Template-Method ist in die Node-Connectivity integriert">
<arrowlink COLOR="#627bc6" DESTINATION="ID_862937515" ENDARROW="Default" ENDINCLINATION="-137;0;" ID="Arrow_ID_1502213786" STARTARROW="None" STARTINCLINATION="-314;15;"/>
<icon BUILTIN="forward"/>
<node CREATED="1715473515292" ID="ID_1374406663" MODIFIED="1715473531430" TEXT="das Turnout-System ist rekursiv auf allen Ebenen untergebracht"/>
<node CREATED="1715473532306" ID="ID_1011716640" MODIFIED="1715473544532" TEXT="jede Ebene wird erneut mit den Job-Parametern angetriggert"/>
<node CREATED="1715473545336" ID="ID_994010903" MODIFIED="1715473594150" TEXT="jede Invocation arbeitet die Schritte auf ihrer Ebene ab"/>
@ -84955,9 +85007,96 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
</node>
</node>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1718926023053" ID="ID_1064805768" MODIFIED="1718926095493" TEXT="Verbindung mit der Node-Struktur neu ordnen">
<linktarget COLOR="#80418c" DESTINATION="ID_1064805768" ENDARROW="Default" ENDINCLINATION="347;215;" ID="Arrow_ID_1648312561" SOURCE="ID_1898452649" STARTARROW="None" STARTINCLINATION="148;-17;"/>
<icon BUILTIN="yes"/>
<node CREATED="1718926109744" ID="ID_80068724" MODIFIED="1718926113329" TEXT="was mich st&#xf6;rt">
<node CREATED="1718926114200" ID="ID_1305470404" MODIFIED="1718926280052" TEXT="die vielen Indirektionen">
<richcontent TYPE="NOTE"><html>
<head/>
<body>
<ul>
<li>
WiringDescriptor, und dann eine Impl NodeWiring
</li>
<li>
aber die eigentliche Impl steckt dann in einem Parameter-Typ STATE
</li>
<li>
die ProcNode delegiert durch ein SAM-Interface
</li>
<li>
und der tats&#228;chliche Aufruf greift aber wieder auf die In/Out-Arrays durch
</li>
<li>
der StateProxy schwirrt irgendwo dazwischen auch noch herum
</li>
</ul>
</body>
</html></richcontent>
</node>
<node CREATED="1718926311883" ID="ID_1087444062" MODIFIED="1718926375053" TEXT="Build-Proze&#xdf; und konkrete Datenstruktur sind stark verschr&#xe4;nkt">
<richcontent TYPE="NOTE"><html>
<head/>
<body>
<p>
aus dem NodeWiring-Konstruktor passieren jede Menge Callbacks in die WiringSituation
</p>
</body>
</html>
</richcontent>
</node>
<node CREATED="1718926376090" ID="ID_1237866779" MODIFIED="1718931836347" TEXT="die WiringSituation doppelt die Relationen nochmal auf">
<linktarget COLOR="#a05d70" DESTINATION="ID_1237866779" ENDARROW="Default" ENDINCLINATION="-821;-34;" ID="Arrow_ID_1472508814" SOURCE="ID_1034026390" STARTARROW="None" STARTINCLINATION="1345;85;"/>
</node>
<node CREATED="1718926456544" ID="ID_114653821" MODIFIED="1718927260591" TEXT="der tats&#xe4;chlich ausf&#xfc;hrende Code ist praktisch unauffindbar">
<richcontent TYPE="NOTE"><html>
<head/>
<body>
<p>
man geht von ProcNode durch Connectivity, dann NodeWiring ... und wenn man Gl&#252;ck hat, f&#228;llt einem der Header nodeoperaton.hpp auf...&#160; <font color="#900025">&#9888; denn sonst ist der tats&#228;chliche Einstiegspunkt mit &#252;blichen Methoden der Code-Suche <b>praktisch nicht zu finden</b></font>: Er steckt in nodewiring.hpp in der konkreten Definition der virtuellen Funktion <font face="Monospaced" color="#3417c7">callDown()</font>&#160; &#8212; und von dort in eine <i>dependent Method </i><font face="Monospaced" color="#7306ce">thisStep.retrieve()</font>, die tats&#228;chlich im Template <font face="Monospaced" color="#7f0da7">ActualInvocationProcess</font>&#160;an <font face="Monospaced" color="#6f022c">STRATEGY::step()</font>&#160; weitergereicht wird &#8212; und vermutlich ist nur mir klar, da&#223; damit die verketteten step()-Methoden in nodeoperation.hpp gemeint sind...
</p>
</body>
</html>
</richcontent>
</node>
</node>
<node CREATED="1718927311092" ID="ID_228070383" MODIFIED="1718927335687" TEXT="Idee: das durch das TurnoutSystem explizit machen">
<icon BUILTIN="idea"/>
<node BACKGROUND_COLOR="#ccb59b" COLOR="#6e2a38" CREATED="1718931041652" ID="ID_1233968441" MODIFIED="1718931055767" TEXT="von einer einfachen (aber abstrakten) Grundstruktur her denken">
<font ITALIC="true" NAME="SansSerif" SIZE="14"/>
<icon BUILTIN="yes"/>
</node>
<node CREATED="1718930943426" ID="ID_167097085" MODIFIED="1718931020851" TEXT="m&#xf6;glichst nur mit den zwei Elementen arbeiten">
<icon BUILTIN="yes"/>
<node CREATED="1718930956763" ID="ID_357786339" MODIFIED="1718931366061" TEXT="fest &#x2259; die Weiche (Turnout) &#x2259; die Template-Method f&#xfc;r die Invocation &#x2259; Port-Impl">
<linktarget COLOR="#3a55ba" DESTINATION="ID_357786339" ENDARROW="Default" ENDINCLINATION="-195;7;" ID="Arrow_ID_513022597" SOURCE="ID_960810353" STARTARROW="None" STARTINCLINATION="51;-4;"/>
</node>
<node CREATED="1718930983638" ID="ID_1434852836" MODIFIED="1718931355022" TEXT="beweglich &#x2259; die Weichenstra&#xdf;e (TurnoutSystem) &#x2259; der Invocation-State"/>
</node>
</node>
<node CREATED="1718931095430" ID="ID_953035313" MODIFIED="1718931104272" TEXT="eine Node hat N &#xbb;Ports&#xab;">
<node CREATED="1718931106428" ID="ID_1894072456" MODIFIED="1718931123903" TEXT="das sind die &#x201e;Output Descriptors&#x201c;"/>
<node CREATED="1718931127601" ID="ID_960810353" MODIFIED="1718931328224" TEXT="Interface &#x25c1;&#x2014; impl. durch Turnout">
<arrowlink COLOR="#3a55ba" DESTINATION="ID_357786339" ENDARROW="Default" ENDINCLINATION="-195;7;" ID="Arrow_ID_513022597" STARTARROW="None" STARTINCLINATION="51;-4;"/>
<node CREATED="1718931415834" HGAP="36" ID="ID_862937515" MODIFIED="1718931989102" TEXT="Turnout ist generisch und parametrisiert" VSHIFT="6">
<linktarget COLOR="#627bc6" DESTINATION="ID_862937515" ENDARROW="Default" ENDINCLINATION="-137;0;" ID="Arrow_ID_1502213786" SOURCE="ID_1737288938" STARTARROW="None" STARTINCLINATION="-314;15;"/>
</node>
</node>
</node>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1718932452300" ID="ID_1311517716" MODIFIED="1718932606380" TEXT="Turnout-System als 2.Layer denken">
<icon BUILTIN="yes"/>
<node CREATED="1718932460163" ID="ID_846170415" MODIFIED="1718932474781" TEXT="die Node mu&#xdf; ohne Turnout-System verst&#xe4;ndlich sein"/>
<node CREATED="1718932475681" ID="ID_119429683" MODIFIED="1718932573975" TEXT="das Turnout-System mu&#xdf; aus den Ports rekursiv hervorgehen"/>
<node CREATED="1718932576531" ID="ID_1954245677" MODIFIED="1718932597076" TEXT="mit dem Turnout-System wird die konkrete Buffer-Verwaltung hinzugef&#xfc;rt (Feed-Manifold)"/>
</node>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1713823682795" ID="ID_868323088" MODIFIED="1713823821819" TEXT="Kl&#xe4;ren der Probleme mit den Prototypen">
<icon BUILTIN="flag-yellow"/>
<node BACKGROUND_COLOR="#dfb29e" COLOR="#a50125" CREATED="1718927789851" ID="ID_1793832055" MODIFIED="1718927827690" TEXT="Gefahr der kombinatorischen Explosion">
<icon BUILTIN="clanbomber"/>
</node>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1713823751762" ID="ID_1428576691" MODIFIED="1713823821819" TEXT="Node-Basisf&#xe4;lle">
<icon BUILTIN="flag-yellow"/>
@ -84978,6 +85117,14 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
<node COLOR="#435e98" CREATED="1714181927456" ID="ID_7655935" MODIFIED="1714181946722" TEXT="Tracking-Ticket #1364 &#xbb;Render Node Network&#xab;">
<icon BUILTIN="info"/>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1718845242691" ID="ID_377937950" MODIFIED="1718845248435" TEXT="#1367 build a node invocation">
<icon BUILTIN="flag-yellow"/>
<node CREATED="1718845256006" ID="ID_130047105" MODIFIED="1718845263388" TEXT="als direkter Treiber f&#xfc;r die n&#xe4;chsten Arbeiten"/>
<node CREATED="1718845263947" ID="ID_1747091374" MODIFIED="1718845332197" TEXT="Ziel: den NodeLinkage_test aufbauen">
<arrowlink COLOR="#fe018a" DESTINATION="ID_673154392" ENDARROW="Default" ENDINCLINATION="3;-16;" ID="Arrow_ID_894402730" STARTARROW="None" STARTINCLINATION="-151;11;"/>
<icon BUILTIN="yes"/>
</node>
</node>
</node>
<node CREATED="1713823918124" ID="ID_1749289662" MODIFIED="1713823922851" TEXT="Testbarkeit">
<node CREATED="1713823928074" ID="ID_1359856614" MODIFIED="1713823939046" TEXT="Node mu&#xdf; direkt konstruierbar sein"/>
@ -84992,9 +85139,215 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
<icon BUILTIN="flag-yellow"/>
<node CREATED="1713823362710" ID="ID_66967253" MODIFIED="1713823377315" TEXT="Hilfsmittel zur Entwicklung und zum Aufbau"/>
</node>
<node BACKGROUND_COLOR="#fdfdcf" COLOR="#ff0000" CREATED="1713821694886" ID="ID_1102491970" MODIFIED="1713823534427" TEXT="NodeLinkage_test">
<node BACKGROUND_COLOR="#fdfdcf" COLOR="#ff0000" CREATED="1713821694886" ID="ID_1102491970" MODIFIED="1718843733168" TEXT="NodeLinkage_test">
<linktarget COLOR="#fdd3b6" DESTINATION="ID_1102491970" ENDARROW="Default" ENDINCLINATION="-366;-51;" ID="Arrow_ID_1227159439" SOURCE="ID_943908122" STARTARROW="None" STARTINCLINATION="30;255;"/>
<icon BUILTIN="flag-pink"/>
<node CREATED="1713823379083" ID="ID_673154392" MODIFIED="1713823395389" TEXT="die drei Stufen der Verschaltung"/>
<node CREATED="1713823379083" ID="ID_673154392" LINK="#ID_888185703" MODIFIED="1718845332197" TEXT="die drei Stufen der Verschaltung">
<linktarget COLOR="#fe018a" DESTINATION="ID_673154392" ENDARROW="Default" ENDINCLINATION="3;-16;" ID="Arrow_ID_894402730" SOURCE="ID_1747091374" STARTARROW="None" STARTINCLINATION="-151;11;"/>
<icon BUILTIN="idea"/>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1718843482825" ID="ID_312625997" MODIFIED="1718843612302" TEXT="Nodes konstruieren und verschalten">
<icon BUILTIN="full-1"/>
<icon BUILTIN="pencil"/>
<node BACKGROUND_COLOR="#f8f1cb" COLOR="#a50125" CREATED="1718884503837" ID="ID_561930764" MODIFIED="1718884602859" TEXT="RefArray steht dem im Weg">
<arrowlink COLOR="#4a83b7" DESTINATION="ID_208674861" ENDARROW="Default" ENDINCLINATION="-781;83;" ID="Arrow_ID_1861027884" STARTARROW="None" STARTINCLINATION="-1002;-113;"/>
<icon BUILTIN="messagebox_warning"/>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1718925986694" ID="ID_1898452649" MODIFIED="1718926069047" TEXT="Struktur der Connectivity neu aufbauen">
<arrowlink COLOR="#80418c" DESTINATION="ID_1064805768" ENDARROW="Default" ENDINCLINATION="347;215;" ID="Arrow_ID_1648312561" STARTARROW="None" STARTINCLINATION="148;-17;"/>
<icon BUILTIN="flag-yellow"/>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1718927862012" ID="ID_943512919" MODIFIED="1718927879670" TEXT="diesen Code einfach nur zu verwenden w&#xe4;re verantwortungslos">
<icon BUILTIN="smily_bad"/>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1718927843580" ID="ID_1971619594" MODIFIED="1718927889643" TEXT="ich mu&#xdf; wohl die Invocation-Sequenz nochmal durchdenken">
<icon BUILTIN="yes"/>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1718932766972" ID="ID_616923504" MODIFIED="1718933366650" TEXT="mount">
<icon BUILTIN="full-1"/>
</node>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1718932777602" ID="ID_95807550" MODIFIED="1718933682447" TEXT="pull">
<icon BUILTIN="full-2"/>
</node>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1718933114298" ID="ID_532676916" MODIFIED="1718933685186" TEXT="shed ">
<icon BUILTIN="full-3"/>
</node>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1718933328181" ID="ID_744768410" MODIFIED="1718933374272" TEXT="weft">
<icon BUILTIN="full-4"/>
</node>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1718933337468" ID="ID_1285026552" MODIFIED="1718933376619" TEXT="fix">
<icon BUILTIN="full-5"/>
</node>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1718932623301" ID="ID_574547501" MODIFIED="1718932634563" TEXT="daraus den reinen Connectivity-Part extrahieren">
<icon BUILTIN="flag-yellow"/>
<node CREATED="1718967556296" ID="ID_777505189" MODIFIED="1718967569143" TEXT="eine Node hat N Ports">
<node CREATED="1718969877437" ID="ID_728636253" MODIFIED="1718969889167" TEXT="hinter jedem Port sitzt als Implementierung ein Turnout"/>
<node CREATED="1718970502272" ID="ID_1448540692" MODIFIED="1718970521792" TEXT="dieser wiederum kennt seine Vorg&#xe4;nger-Ports (irgendwo auf den Leads)"/>
</node>
<node CREATED="1718967588174" ID="ID_239858554" MODIFIED="1718967771010" TEXT="eine Node hat M Leads">
<node CREATED="1718970527355" ID="ID_389606790" MODIFIED="1718970541269" TEXT="das sind zun&#xe4;chst nur Verweise auf vorgelagerte ProcNodes"/>
<node CREATED="1718970542993" ID="ID_1283270820" MODIFIED="1718970565474" TEXT="aber ein &#xbb;Weaving Pattern&#xab; wei&#xdf; diese zu bespielen"/>
</node>
<node CREATED="1718968926214" ID="ID_1139057776" MODIFIED="1718968929793" TEXT="Zusammenhang">
<node CREATED="1718968930798" ID="ID_685938023" MODIFIED="1718969467911" TEXT="Einbeziehen von Mehrfach-Verbindungen in die Verdrahtung">
<richcontent TYPE="NOTE"><html>
<head/>
<body>
<p>
Die Analyse ergab mehrere Perspektiven auf das Thema, die sich zwar stark unterscheiden, wenn man sie als <i>praktische </i>Handlungsanweisungen interpretiert, die jedoch <i>praktisch auf dasselbe hinauslaufen,</i>&#160;wenn man sie <i>gedanklich </i>auffa&#223;t. Meine Schlu&#223;folgerung daraus ist, da&#223; es stets einer &#220;bersetzung bedarf, und es daher untunlich w&#228;re, sich auf <i>ein Modell </i>festzulegen...
</p>
<ul>
<li>
topologisch haben wir es mit einem DAG zu tun, und es kann Mehrfachverbindungen auch zwischen unmittelbaren Nachbarknoten geben
</li>
<li>
eine Node-Aktivierung erzeugt immer alle Ausgaben, die dann irgendwo aufgefangen werden m&#252;ssen
</li>
<li>
im Allgemeinen ist ein Umordnen und ggfs Ausw&#228;hlen und Verteilen dieser Ausgaben erforderlich
</li>
<li>
der Berechnungs-Vorgang hat K Eingaben
</li>
<li>
jede Eingabe ist <i>ein bestimmtes Ergebnis</i>&#160;von <i>einem bestimmten Vorl&#228;ufer</i>
</li>
</ul>
</body>
</html></richcontent>
<linktarget COLOR="#4441d1" DESTINATION="ID_685938023" ENDARROW="Default" ENDINCLINATION="312;-9;" ID="Arrow_ID_120542506" SOURCE="ID_1431510635" STARTARROW="Default" STARTINCLINATION="236;32;"/>
</node>
<node CREATED="1718969510891" ID="ID_731501936" MODIFIED="1718969527622" TEXT="der konkrete pull()-Vorgang geht &#xfc;ber einen Port ein"/>
<node CREATED="1718969609927" ID="ID_53218748" MODIFIED="1718969692420" TEXT="die angesto&#xdf;ene Berechnung hat K Vorg&#xe4;nger-Ports"/>
<node CREATED="1718969776178" ID="ID_555584342" MODIFIED="1718969816366" TEXT="diese sind geeignet auf die M Leads verteilt"/>
<node CREATED="1718969828751" ID="ID_1291787748" MODIFIED="1718969841808" TEXT="die enstprechende Anordnung liegt im FeedManifold"/>
<node CREATED="1718969843508" ID="ID_576519964" MODIFIED="1718969857205" TEXT="der Port wei&#xdf; wie er die FeedManifold konstruiert"/>
</node>
<node BACKGROUND_COLOR="#f0d5c5" COLOR="#990033" CREATED="1718970570053" ID="ID_1805790656" MODIFIED="1718970577800" TEXT="wo liegt das Weaving-Pattern?">
<icon BUILTIN="help"/>
<node CREATED="1718970583860" ID="ID_1633702616" MODIFIED="1718972261524" TEXT="Modell-1">
<node CREATED="1718970590730" ID="ID_863045795" MODIFIED="1718970607012" TEXT="es ist in den den jeweiligen Turnout eingebettet"/>
<node CREATED="1718970816076" ID="ID_1383908911" MODIFIED="1718970824575" TEXT="der Turnout hat K Vorg&#xe4;nger-Ports"/>
<node CREATED="1718970826211" ID="ID_440886795" MODIFIED="1718970846564" TEXT="diese sind bereits ein implizites Mapping auf die M Leads"/>
<node CREATED="1718970847888" ID="ID_122010161" MODIFIED="1718971950836" TEXT="jeder Pull eines Vorg&#xe4;nger-Ports produziert genau einen passenden Input-Datenframe"/>
</node>
<node CREATED="1718970672279" ID="ID_1135114209" MODIFIED="1718972255508" TEXT="Modell-2">
<node CREATED="1718970679694" ID="ID_1805087258" MODIFIED="1718970686485" TEXT="es liegt als Matrix in den Leads"/>
<node CREATED="1718972076325" ID="ID_416047871" MODIFIED="1718972087958" TEXT="jeder Turnout kennt seine eigene Port-Index-Nr"/>
<node CREATED="1718972089173" ID="ID_991142027" MODIFIED="1718972154798" TEXT="in jedem Lead lieft f&#xfc;r jeden Port-Index ein Weaving-Pattern bereit"/>
<node CREATED="1718972167774" ID="ID_326725306" MODIFIED="1718972194006" TEXT="dieses beschreibt N ports auf dem Lead, und wie ihre Ausgaben zu routen sind"/>
</node>
<node CREATED="1718972235955" ID="ID_175440268" MODIFIED="1718972238335" TEXT="Diskussion">
<node CREATED="1718972239305" ID="ID_379021447" MODIFIED="1718972272306" TEXT="der Unterschied zwischen beiden Modellen ist subtil und weitreichend"/>
<node CREATED="1718972278205" ID="ID_11449823" MODIFIED="1718972292993" TEXT="Modell-1...">
<node CREATED="1718972294363" ID="ID_552849313" MODIFIED="1718972295430" TEXT="ist radikal-explizit"/>
<node CREATED="1718972298722" ID="ID_220061580" MODIFIED="1718972341631">
<richcontent TYPE="NODE"><html>
<head/>
<body>
<p>
fa&#223;t das Konzept eines &#187;Port&#171; <b>enger</b>
</p>
</body>
</html></richcontent>
</node>
<node CREATED="1718972373156" ID="ID_482942647" MODIFIED="1718972400080">
<richcontent TYPE="NODE"><html>
<head/>
<body>
<p>
n&#228;mlich indem der Ergebnis-Datenframe<i>&#160;pa&#223;genau</i>&#160;sein mu&#223;
</p>
</body>
</html></richcontent>
</node>
<node CREATED="1718972342572" ID="ID_899011498" MODIFIED="1718972433752" TEXT="dadurch bekommt eine Node ggfs. mehr Ports f&#xfc;r alle Szenarien"/>
<node CREATED="1718972468946" ID="ID_93640902" MODIFIED="1718972480652" TEXT="diese Information wird im Builder-Scope interpretiert"/>
</node>
<node CREATED="1718972497118" ID="ID_1398053629" MODIFIED="1718972501145" TEXT="Modell-2...">
<node CREATED="1718972545847" ID="ID_853246942" MODIFIED="1718972555828" TEXT="l&#xe4;&#xdf;t mehr Nutzungsspielraum f&#xfc;r einen Port"/>
<node CREATED="1718972574955" ID="ID_896567243" MODIFIED="1718972598617" TEXT="das bedeutet, der Port ist noch inh&#xe4;rent strukturiert in Port-Varianten"/>
<node CREATED="1718972719258" ID="ID_1660719408" MODIFIED="1718972745408" TEXT="zur Ausf&#xfc;hrungszeit flie&#xdf;en noch Metadaten und es passiert eine Sub-Selektion"/>
<node CREATED="1718972747023" ID="ID_584351037" MODIFIED="1718972783627" TEXT="daf&#xfc;r haben die meisten Nodes nur einen Port und es ist mehr dynamisch schaltbar"/>
</node>
<node CREATED="1718972815657" ID="ID_290743732" MODIFIED="1718973353638" TEXT="&#xe4;hnliche Richtungen zeigen sich bereits bei der Analyse der Exit-Nodes">
<richcontent TYPE="NOTE"><html>
<head/>
<body>
<p>
Auch dort zeigt sich die Wahl zwischen einer high-level-Sicht, welche in den Ports noch Raum f&#252;r sub-Differenzierung l&#228;&#223;t, und somit n&#228;her an der Dom&#228;nen-Modellierung liegt &#8212; und auf der anderen Seite einer radikalen low-Level-L&#246;sung, die auf restlos explizit gemachten M&#246;glichkeiten besteht
</p>
</body>
</html>
</richcontent>
<arrowlink COLOR="#6c5499" DESTINATION="ID_821758494" ENDARROW="Default" ENDINCLINATION="-305;510;" ID="Arrow_ID_1100764489" STARTARROW="None" STARTINCLINATION="891;35;"/>
</node>
<node CREATED="1718973368922" ID="ID_1449964726" MODIFIED="1718973388233" TEXT="eine dynamische Sub-Selektion erfolgt in jedem Fall &#x2014; nur eben unterschiedlich">
<node CREATED="1718973391671" ID="ID_178387385" MODIFIED="1718973429752" TEXT="Modell-1 macht diese ausgabeseitig, im &#xbb;Shed&#xab;"/>
<node CREATED="1718973430810" ID="ID_1525572652" MODIFIED="1718973448199" TEXT="Model-2 macht diese eingabeseitig, nach dem &#xbb;Pull&#xab;"/>
</node>
<node CREATED="1718973534866" ID="ID_576388539" MODIFIED="1718973554847" TEXT="Modell-2 l&#xf6;st bei mir den &#x201e;Komplexit&#xe4;ts-Alarm&#x201c; aus">
<node CREATED="1718973588430" ID="ID_1262623597" MODIFIED="1718973600088" TEXT="das l&#xe4;&#xdf;t gef&#xe4;hrlich viel Spielraum"/>
<node CREATED="1718973601148" ID="ID_1194970620" MODIFIED="1718973648066" TEXT="es entspricht der &#xbb;erst mal einfach anfangen&#xab;-Halutung"/>
<node CREATED="1718973648894" ID="ID_37286948" MODIFIED="1718973672087" TEXT="leider folgt daraus meist das &#x201e;we&apos;ll figure it out&#x201c; - Syndrom"/>
<node CREATED="1718973766216" ID="ID_1051215356" MODIFIED="1718973784527" TEXT="Model-1 dagegen schiebt die Komplexit&#xe4;t in die (zuk&#xfc;nftige) Entscheidungs-Ebene hoch"/>
</node>
<node BACKGROUND_COLOR="#ccb59b" COLOR="#6e2a38" CREATED="1718973806511" ID="ID_1047998990" MODIFIED="1718973826478">
<richcontent TYPE="NODE"><html>
<head/>
<body>
<p>
ich neige zunehmend Richtung <b>Model-1</b>
</p>
</body>
</html>
</richcontent>
<font ITALIC="true" NAME="SansSerif" SIZE="14"/>
<icon BUILTIN="yes"/>
</node>
</node>
</node>
</node>
<node BACKGROUND_COLOR="#fdfdcf" COLOR="#ff0000" CREATED="1718973873148" ID="ID_522658569" MODIFIED="1718978668919" TEXT="Anordnung im Code">
<icon BUILTIN="yes"/>
<node CREATED="1718973890621" ID="ID_1277434827" MODIFIED="1718973901348" TEXT="ProcNode ist das high-level-Interface">
<node CREATED="1718973914503" ID="ID_126069350" MODIFIED="1718973927976" TEXT="impliziert auch das Port-Interface"/>
</node>
<node CREATED="1718974826492" ID="ID_1652598144" MODIFIED="1718974834719" TEXT="Turnout wird ein Baukasten-System">
<node CREATED="1718974852248" ID="ID_603732270" MODIFIED="1718974877977" TEXT="das Turnout-Template imlementiert aber bereits ein Grund-Schema"/>
<node CREATED="1718974881341" ID="ID_779365453" MODIFIED="1718974889485" TEXT="insofern lege ich mich jetzt mehr fest als 2012"/>
<node CREATED="1718975200988" ID="ID_260487045" MODIFIED="1718975263349" TEXT="Einstiegspunkt: Port::enactTurnout(coord) &#x27fc; TurnoutSystem"/>
<node CREATED="1718975677753" ID="ID_1527027445" MODIFIED="1718975694581" TEXT="Turnout verwendet eine Kette von WeavingPatterns"/>
</node>
<node CREATED="1718975296253" ID="ID_173252871" MODIFIED="1718975299600" TEXT="TurnoutSystem">
<node CREATED="1718975300492" ID="ID_1007921082" MODIFIED="1718975308959" TEXT="arbeitet auf dem Port-Interface"/>
<node CREATED="1718975309547" ID="ID_154889872" MODIFIED="1718975315360" TEXT="wird vom Turnout erzeugt"/>
<node CREATED="1718975332631" ID="ID_607210840" MODIFIED="1718975353400" TEXT="ist selber ein Execution-Context-Builder"/>
<node CREATED="1718975646318" ID="ID_173228319" MODIFIED="1718975652841" TEXT="bietet die Schritte">
<node CREATED="1718975653877" ID="ID_710670497" MODIFIED="1718975655896" TEXT="mount"/>
<node CREATED="1718975656628" ID="ID_1539709880" MODIFIED="1718975659328" TEXT="pull"/>
<node CREATED="1718975660099" ID="ID_1656358686" MODIFIED="1718975661736" TEXT="commit"/>
</node>
</node>
<node CREATED="1718975849003" ID="ID_1545161094" MODIFIED="1718975858717" TEXT="die Node-Factory bleibt zun&#xe4;chst au&#xdf;en vor">
<node CREATED="1718975861065" ID="ID_1907625416" MODIFIED="1718975870468" TEXT="diese geh&#xf6;rt ehr in den Kontext des Builders"/>
<node CREATED="1718975871248" ID="ID_522836015" MODIFIED="1718975888569" TEXT="die fa&#xdf;t die Schritte zusammen, die man auch explizit machen kann"/>
<node CREATED="1718975902428" ID="ID_1445965423" MODIFIED="1718975920749" TEXT="vorzugsweise gibt es einzelne Builder-Functions f&#xfc;r Turnout"/>
<node CREATED="1718975923921" ID="ID_620438698" MODIFIED="1718975932092" TEXT="hinzu kommt au&#xdf;erdem der AllocationCluster"/>
</node>
<node BACKGROUND_COLOR="#f0d5c5" COLOR="#990033" CREATED="1718975949293" ID="ID_8397683" MODIFIED="1718975957653" TEXT="noch unklar: Weaving-Patterns?">
<icon BUILTIN="help"/>
</node>
</node>
</node>
</node>
<node BACKGROUND_COLOR="#d2beaf" COLOR="#5c4d6e" CREATED="1718843534139" ID="ID_1144935511" MODIFIED="1718843607043" TEXT="Turnout-System aufbauen">
<icon BUILTIN="full-2"/>
<icon BUILTIN="hourglass"/>
</node>
<node BACKGROUND_COLOR="#d2beaf" COLOR="#5c4d6e" CREATED="1718843561830" ID="ID_1092570310" MODIFIED="1718843607042" TEXT="Invocations ausl&#xf6;sen">
<icon BUILTIN="full-3"/>
<icon BUILTIN="hourglass"/>
</node>
</node>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1713823407007" ID="ID_392149724" MODIFIED="1713823477637" STYLE="bubble" TEXT="&#x25b6; f&#xf6;rdert den Kern des Aufbaus &#x25c0;">
<edge COLOR="#985353"/>
</node>