ichthyo/LUMIERA.clone
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Scheduler: devise the arrangement of basic components

Browse source 
- define organisation of vault-layer namespaces
- define the ground plan of the scheduler implementation
This commit is contained in:
Fischlurch 2023-06-24 03:14:17 +02:00
parent 130bc095d9
commit 3169ba88ad
35 changed files with 1056 additions and 90 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/doxygen.dox
View file

@ -88,6 +88,10 @@ with the *ASCIIDOC* tool and published at the [Lumiera website](http://Lumiera.o
@ingroup vault
*/
/** @defgroup memory Memory Management
@ingroup vault
*/
/* ==== Global Namespaces ==== */

5
src/stage/gtk-base.hpp
View file

@ -84,7 +84,10 @@
/* ======= Namespace Definitions ======= */
/** Lumiera GTK UI implementation root. */
/**
* Lumiera GTK UI implementation root.
* @ingroup gui
*/
namespace stage {
/* some commonly used error marks for the UI... */

5
src/steam/common.hpp
View file

@ -41,7 +41,7 @@
/* frequently used common types... */
/* ===== frequently used common types ===== */
#include "lib/p.hpp"
#include "lib/util.hpp"
@ -60,6 +60,7 @@
* session support system, the playback-and-render-control subsystem and
* the API and backbone of the renderengine. Most render implementation
* code resides in the vault layer or is loaded from plug-ins though.
* @ingroup steam
*/
namespace steam {
@ -88,7 +89,7 @@ namespace steam {
/**
* Render engine code as part of the Steam-Layer.
* Lumiera's render engine core and operational control.
* Backbone of the engine, render nodes base and cooperation.
* A good deal of the active engine code is outside the scope of the
* Steam-Layer, e.g. code located in vault services and plugins.

4
src/steam/engine/exit-node.hpp
View file

@ -35,7 +35,7 @@
#include "lib/hash-value.h"
#include "lib/iter-adapter-stl.hpp"
#include "lib/time/timevalue.hpp"
#include "vault/engine/job.h" //////////////////////////////////////////////////////////////////TICKET #1295 : rather need a way to retrieve a real JobFunctor building block from the ProcNode
#include "vault/gear/job.h" //////////////////////////////////////////////////////////////////TICKET #1295 : rather need a way to retrieve a real JobFunctor building block from the ProcNode
#include <utility>
#include <deque>
@ -51,7 +51,7 @@ namespace engine {
class ExitNode;
using ExitNodes = std::deque<engine::ExitNode>;
using vault::engine::JobFunctor;
using vault::gear::JobFunctor;
namespace {// hard wired placeholder config....
const Duration DUMMY_JOB_RUNTIME{FSecs{1,50}};

3
src/steam/engine/job-planning.hpp
View file

@ -68,7 +68,7 @@
#define STEAM_ENGINE_JOB_PLANNING_H
#include "steam/common.hpp"
#include "vault/engine/job.h"
#include "vault/gear/job.h"
#include "steam/engine/job-ticket.hpp"
#include "steam/play/output-slot.hpp"
#include "steam/play/timings.hpp"
@ -88,6 +88,7 @@ namespace engine {
using lib::time::Time;
using lib::time::TimeVar;
using lib::time::Duration;
using vault::gear::Job;

7
src/steam/engine/job-ticket.cpp
View file

@ -31,7 +31,7 @@
#include "steam/engine/job-ticket.hpp"
#include "vault/engine/nop-job-functor.hpp"
#include "vault/gear/nop-job-functor.hpp"
#include "lib/depend.hpp"
#include "lib/util.hpp"
@ -39,14 +39,15 @@
namespace steam {
namespace engine {
using vault::engine::JobClosure;
using vault::gear::Job;
using vault::gear::JobClosure;
using lib::HashVal;
using lib::unConst;
using lib::time::FSecs;
namespace { // Details...
lib::Depend<vault::engine::NopJobFunctor> nopFunctor;
lib::Depend<vault::gear::NopJobFunctor> nopFunctor;
/* ======== hard wired =================*/
const FSecs JOB_MINIMUM_RUNTIME{1,1000};

8
src/steam/engine/job-ticket.hpp
View file

@ -36,7 +36,7 @@
#define STEAM_ENGINE_JOB_TICKET_H
#include "steam/common.hpp"
#include "vault/engine/job.h"
#include "vault/gear/job.h"
#include "steam/engine/exit-node.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/linked-elements.hpp"
@ -52,9 +52,9 @@
namespace steam {
namespace engine {
using vault::engine::Job;
using vault::engine::JobFunctor;
using vault::engine::JobClosure; /////////////////////////////////////////////////////////////////////TICKET #1287 : fix actual interface down to JobFunctor (after removing C structs)
using vault::gear::Job;
using vault::gear::JobFunctor;
using vault::gear::JobClosure; /////////////////////////////////////////////////////////////////////TICKET #1287 : fix actual interface down to JobFunctor (after removing C structs)
using lib::LinkedElements;
using lib::time::Duration;
using lib::time::Time;

6
src/steam/engine/render-drive.hpp
View file

@ -43,7 +43,7 @@
#include "steam/mobject/model-port.hpp"
#include "steam/engine/dispatcher.hpp"
#include "steam/play/timings.hpp"
#include "vault/engine/job.h"
#include "vault/gear/job.h"
//#include "lib/nocopy.hpp"
@ -51,8 +51,8 @@ namespace steam {
namespace engine {
// using std::function;
using vault::engine::JobParameter;
using vault::engine::JobClosure;
using vault::gear::JobParameter;
using vault::gear::JobClosure;
using mobject::ModelPort;
// using lib::time::TimeSpan;
// using lib::time::FSecs;

116
src/vault/common.hpp Normal file
View file

@ -0,0 +1,116 @@
/*
COMMON.hpp - common types and definitions for the Vault-Layer
Copyright (C) Lumiera.org
2023, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/** @file vault/common.hpp
** Basic set of definitions and includes commonly used together (Vault).
** Including common.hpp gives you a common set of elementary declarations
** widely used within the C++ code of the Vault-Layer. Besides that, this
** header is used to attach the doxygen documentation comments for all
** the primary Vault-Layer namespaces
**
** @see main.cpp
**
*/
#ifndef VAULT_COMMON_H
#define VAULT_COMMON_H
/* ===== frequently used common types ===== */
#include "lib/error.hpp" // pulls in NoBug via loggging.h
#include "lib/nocopy.hpp"
#include "lib/symbol.hpp"
#include "lib/time/timevalue.hpp"
/**
* Vault-Layer implementation namespace root.
* The lowest layer in Lumiera's architecture provides the interface to
* the operating system and similar fundamental high-performance services:
* - Scheduler
* - Frame Cache
* - I/O support
* - persistent storage format
* - specialised memory management
* @ingroup vault
*/
namespace vault {
/**
* I/O subsystem and support.
* System level and platform services.
*/
namespace io { }
/**
* Output management and connectors.
*/
namespace out { }
/**
* Memory Management.
*/
namespace mem { }
/**
* Active working gear and plumbing.
* Notably the Scheduler and performance observation and self-regulation are implemented here.
*/
namespace gear { }
/**
* The frame and media cache.
*/
namespace cache { }
/**
* Lumiera Render Toolkit.
* This is a set of adapters and thin wrappers on top of external implementation,
* to provide some commonplace generic functionality in an abstracted way for use
* from the actual render jobs.
*/
namespace toolkit { }
/**
* Persistent storage formats.
* Support for structured data storage and exchange, for session and command log.
* Import / Export and metadata handling
*/
namespace storage { }
} //(End)namespace steam
#endif /*VAULT_COMMON_H*/

80
src/vault/gear/activity-lang.hpp Normal file
View file

@ -0,0 +1,80 @@
/*
ACTIVITY-LANG.hpp - definition language framework for scheduler activities
Copyright (C) Lumiera.org
2023, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/** @file activity-lang.hpp
** A language framework to define and interconnect scheduler activity verbs.
** This is an interface to build valid activity descriptors, connect them with
** other activities and provide parameter data. The resulting definition terms
** can be passed to the scheduler's messaging queue to cause the described
** activities to be performed in the context of the Lumiera render engine.
**
** @note this is a wild fantasy
** @see ////TODO_test usage example
** @see scheduler.cpp implementation
**
** @todo WIP-WIP-WIP 6/2023 »Playback Vertical Slice«
**
*/
#ifndef SRC_VAULT_GEAR_ACTIVITY_LANG_H_
#define SRC_VAULT_GEAR_ACTIVITY_LANG_H_
#include "vault/gear/activity.hpp"
//#include "lib/symbol.hpp"
//#include "lib/util.hpp"
//#include <string>
namespace vault{
namespace gear {
// using util::isnil;
// using std::string;
/**
* Basic (abstracted) view of...
*
* @see SomeSystem
* @see NA_test
*/
class ActivityLang
{
string nothing_;
public:
// explicit
ActivityLang ()
: nothing_(b)
{ }
// using default copy/assignment
};
}} // namespace vault::gear
#endif /*SRC_VAULT_GEAR_ACTIVITY_LANG_H_*/

83
src/vault/gear/activity.hpp Normal file
View file

@ -0,0 +1,83 @@
/*
ACTIVITY.hpp - elementary operation to be handled by the scheduler
Copyright (C) Lumiera.org
2023, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/** @file activity.hpp
** Descriptor for a piece of operational logic performed by the scheduler.
** The Scheduler in Lumiera's Vault coordinates the rendering activities,
** by passing and responding to _Activity messages,_ thereby observing
** temporal limits (deadlines) and dependency constraints. A predefined
** and fixed set of _Activity verbs_ defines atomic operations the engine
** is able to perform, directed by the scheduler. Complex calculation
** tasks are constructed from interconnected activities, passing through
** the messaging and priority queue of the scheduler. While an Activity
** is in processing, the corresponding descriptor data record is maintained
** by the BlockStream custom memory manager.
**
** @note right now this is a pipe dream
** @see ////TODO_test usage example
** @see scheduler.cpp implementation
**
** @todo WIP-WIP-WIP 6/2023 »Playback Vertical Slice«
**
*/
#ifndef SRC_VAULT_GEAR_ACTIVITY_H_
#define SRC_VAULT_GEAR_ACTIVITY_H_
#include "vault/common.hpp"
//#include "lib/symbol.hpp"
//#include "lib/util.hpp"
//#include <string>
namespace vault{
namespace gear {
// using util::isnil;
// using std::string;
/**
* Basic (abstracted) view of...
*
* @see SomeSystem
* @see NA_test
*/
class Activity
{
public:
// explicit
Activity ()
{ }
// using default copy/assignment
};
}} // namespace vault::gear
#endif /*SRC_VAULT_GEAR_ACTIVITY_H_*/

62
src/vault/gear/block-flow.cpp Normal file
View file

@ -0,0 +1,62 @@
/*
BlockFlow - specialised custom allocator to manage scheduler data
Copyright (C) Lumiera.org
2023, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* *****************************************************/
/** @file block-flow.cpp
** Implementation details of the custom memory manager backing scheduler operation.
**
** @note currently the greatest challenge is de-allocation
**
** @see ////TODO_test usage example
**
** @todo WIP-WIP-WIP 6/2023 »Playback Vertical Slice«
**
*/
#include "vault/gear/block-flow.hpp"
//#include "lib/symbol.hpp"
//#include "include/logging.h"
//#include <string>
//using std::string;
//using util::isnil;
namespace vault{
namespace gear {
namespace { // internal details
} // internal details
// NA::~NA() { }
/**
*/
}} // namespace vault::gear

87
src/vault/gear/block-flow.hpp Normal file
View file

@ -0,0 +1,87 @@
/*
BLOCK-FLOW.hpp - specialised custom allocator to manage scheduler data
Copyright (C) Lumiera.org
2023, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/** @file block-flow.hpp
** Memory management scheme for activities and parameter data passed through
** the Scheduler within the Lumiera render engine. While — conceptually — the
** intended render operations are described as connected activity terms, sent
** as messages through the scheduler, the actual implementation requires a fixed
** descriptor record sitting at a stable memory location while the computation
** is underway. Moreover, activities can spawn further activities, implying that
** activity descriptor records can emanate from multiple threads concurrently,
** and the duration to keep those descriptors in valid state is contingent.
** On the other hand, ongoing rendering produces a constant flow of further
** activities, necessitating timely clean-up of obsolete descriptors.
** Used memory should be recycled, calling for an arrangement of
** pooled allocation tiles, extending the underlying block
** allocation on increased throughput.
**
** @note currently this rather marks the intended memory management pattern,
** while the actual allocations are still performed on the heap.
** @see ////TODO_test usage example
** @see scheduler.cpp implementation
**
** @todo WIP-WIP-WIP 6/2023 »Playback Vertical Slice«
**
*/
#ifndef SRC_VAULT_GEAR_BLOCK_FLOW_H_
#define SRC_VAULT_GEAR_BLOCK_FLOW_H_
#include "vault/common.hpp"
//#include "lib/symbol.hpp"
#include "lib/nocopy.hpp"
//#include "lib/util.hpp"
//#include <string>
namespace vault{
namespace gear {
// using util::isnil;
// using std::string;
/**
* Basic (abstracted) view of...
*
* @see SomeSystem
* @see NA_test
*/
class BlockFlow
: util::NonCopyable
{
public:
explicit
BlockFlow (int woof)
{ }
};
}} // namespace vault::gear
#endif /*SRC_VAULT_GEAR_BLOCK_FLOW_H_*/

6
src/vault/engine/engine-config.cpp → src/vault/gear/engine-config.cpp
View file

@ -29,7 +29,7 @@
*/
#include "vault/engine/engine-config.hpp"
#include "vault/gear/engine-config.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/rational.hpp"
@ -40,7 +40,7 @@ using util::Rat;
namespace vault{
namespace engine {
namespace gear {
namespace { // Hard wired placeholder settings...
@ -83,4 +83,4 @@ namespace engine {
return DEFAULT_JOB_PLANNING_TURNOVER;
}
}} // namespace vault::engine
}} // namespace vault::gear

10
src/vault/engine/engine-config.hpp → src/vault/gear/engine-config.hpp
View file

@ -29,8 +29,8 @@
*/
#ifndef VAULT_ENGINE_ENGINE_CONFIG_H
#define VAULT_ENGINE_ENGINE_CONFIG_H
#ifndef VAULT_GEAR_ENGINE_CONFIG_H
#define VAULT_GEAR_ENGINE_CONFIG_H
@ -39,7 +39,7 @@
namespace vault{
namespace engine {
namespace gear {
using lib::time::Duration;
@ -100,5 +100,5 @@ namespace engine {
Duration currentJobPlanningRhythm() const;
};
}} // namespace vault::engine
#endif/*VAULT_ENGINE_ENGINE_CONFIG_H*/
}} // namespace vault::gear
#endif/*VAULT_GEAR_ENGINE_CONFIG_H*/

14
src/vault/engine/job.cpp → src/vault/gear/job.cpp
View file

@ -33,16 +33,16 @@
*/
#include "vault/engine/job.h"
#include "vault/engine/nop-job-functor.hpp"
#include "vault/gear/job.h"
#include "vault/gear/nop-job-functor.hpp"
#include "lib/util.hpp"
#include <boost/functional/hash.hpp>
#include <typeinfo>
namespace vault {
namespace engine {
namespace vault{
namespace gear {
namespace { // Details...
@ -146,10 +146,10 @@ namespace engine {
}
}} // namespace vault::engine
}} // namespace vault::gear
namespace {
using vault::engine::Job;
using vault::gear::Job;
inline Job&
forwardInvocation (lumiera_jobDefinition& jobDef)
@ -194,4 +194,4 @@ lumiera_invokey_eq (void* l, void* r)
{
return lumiera_uid_eq ((LumieraUid)l, (LumieraUid)r);
}
}
}/* extern "C" */

12
src/vault/engine/job.h → src/vault/gear/job.h
View file

@ -48,8 +48,8 @@
*/
#ifndef VAULT_ENGINE_JOB_H
#define VAULT_ENGINE_JOB_H
#ifndef VAULT_GEAR_JOB_H
#define VAULT_GEAR_JOB_H
#include "lib/llist.h"
@ -199,8 +199,8 @@ typedef lumiera_jobDescriptor* LumieraJobDescriptor;
namespace vault {
namespace engine {
namespace vault{
namespace gear {
using lib::time::TimeValue;
using lib::time::Time;
@ -325,7 +325,7 @@ namespace engine {
}} // namespace vault::engine
}} // namespace vault::gear
@ -354,4 +354,4 @@ int lumiera_invokey_eq (void* l, void* r);
#ifdef __cplusplus
}
#endif
#endif /*VAULT_ENGINE_JOB_H*/
#endif /*VAULT_GEAR_JOB_H*/

14
src/vault/engine/nop-job-functor.hpp → src/vault/gear/nop-job-functor.hpp
View file

@ -31,18 +31,18 @@
*/
#ifndef VAULT_ENGINE_NOP_JOB_FUNCTOR_H
#define VAULT_ENGINE_NOP_JOB_FUNCTOR_H
#ifndef VAULT_GEAR_NOP_JOB_FUNCTOR_H
#define VAULT_GEAR_NOP_JOB_FUNCTOR_H
#include "lib/hash-standard.hpp"
#include "vault/engine/job.h"
#include "vault/gear/job.h"
#include "lib/time/timevalue.hpp"
namespace vault {
namespace engine{
namespace vault{
namespace gear {
using lib::time::Time;
using lib::HashVal;
@ -103,5 +103,5 @@ namespace engine{
};
}} // namespace vault::engine
#endif /*VAULT_ENGINE_NOP_JOB_FUNCTOR_H*/
}} // namespace vault::gear
#endif /*VAULT_GEAR_NOP_JOB_FUNCTOR_H*/

75
src/vault/gear/scheduler-control.hpp Normal file
View file

@ -0,0 +1,75 @@
/*
SCHEDULER-CONTROL.hpp - coordination layer of the render engine scheduler
Copyright (C) Lumiera.org
2023, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/** @file scheduler-control.hpp
** Layer-2 of the Scheduler: coordination of activities.
** This is the upper layer of the implementation and provides high-level functionality.
**
** @see ////TODO_test usage example
** @see scheduler.cpp implementation
**
** @todo WIP-WIP-WIP 6/2023 »Playback Vertical Slice«
**
*/
#ifndef SRC_VAULT_GEAR_SCHEDULER_CONTROL_H_
#define SRC_VAULT_GEAR_SCHEDULER_CONTROL_H_
#include "vault/common.hpp"
#include "lib/nocopy.hpp"
//#include "lib/symbol.hpp"
//#include "lib/util.hpp"
//#include <string>
namespace vault{
namespace gear {
// using util::isnil;
// using std::string;
/**
* Scheduler Layer-2 : coordination.
*
* @see SomeSystem
* @see NA_test
*/
class SchedulerControl
: util::NonCopyable
{
public:
explicit
SchedulerControl (int const& b)
{ }
};
}} // namespace vault::gear
#endif /*SRC_VAULT_GEAR_SCHEDULER_CONTROL_H_*/

12
src/vault/engine/scheduler-diagnostics.hpp → src/vault/gear/scheduler-diagnostics.hpp
View file

@ -33,19 +33,19 @@
*/
#ifndef VAULT_ENGINE_SCHEDULER_DIAGNOSTICS_H
#define VAULT_ENGINE_SCHEDULER_DIAGNOSTICS_H
#ifndef VAULT_GEAR_SCHEDULER_DIAGNOSTICS_H
#define VAULT_GEAR_SCHEDULER_DIAGNOSTICS_H
#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/hash-value.h"
#include "lib/time/timevalue.hpp"
#include "vault/engine/scheduler-frontend.hpp"
#include "vault/gear/scheduler-frontend.hpp"
namespace vault{
namespace engine {
namespace gear {
// using std::string;
using lib::time::Time;
@ -141,5 +141,5 @@ namespace engine {
}} // namespace vault::engine
#endif
}} // namespace vault::gear
#endif /*VAULT_GEAR_SCHEDULER_DIAGNOSTICS_H*/

6
src/vault/engine/scheduler-frontend.cpp → src/vault/gear/scheduler-frontend.cpp
View file

@ -29,10 +29,10 @@
#include "lib/error.h"
#include "vault/engine/scheduler-frontend.hpp"
#include "vault/gear/scheduler-frontend.hpp"
namespace vault{
namespace engine {
namespace gear {
/** storage for the (singleton) scheduler access frontend */
@ -62,4 +62,4 @@ namespace engine {
}} // namespace vault::engine
}} // namespace vault::gear

14
src/vault/engine/scheduler-frontend.hpp → src/vault/gear/scheduler-frontend.hpp
View file

@ -29,18 +29,18 @@
*/
#ifndef VAULT_ENGINE_SCHEDULER_FRONTEND_H
#define VAULT_ENGINE_SCHEDULER_FRONTEND_H
#ifndef VAULT_GEAR_SCHEDULER_FRONTEND_H
#define VAULT_GEAR_SCHEDULER_FRONTEND_H
#include "lib/depend.hpp"
#include "lib/time/timevalue.hpp"
#include "vault/engine/job.h"
#include "vault/gear/job.h"
namespace vault{
namespace engine {
namespace gear {
using lib::time::Time;
@ -56,7 +56,7 @@ namespace engine {
* @ingroup scheduler
* @todo this is planned to become the frontend
* to the render node network, which can be considered
* at the lower end of the middle layer; the actual
* at the lower end of the middle layer; the actual
* render operations are mostly implemented by the vault layer
* @todo define the low-level scheduler interface and hook in
* the necessary calls to implement this frontend.
@ -178,5 +178,5 @@ namespace engine {
};
}} // namespace vault::engine
#endif
}} // namespace vault::gear
#endif /*VAULT_GEAR_SCHEDULER_FRONTEND_H*/

76
src/vault/gear/scheduler-invocation.hpp Normal file
View file

@ -0,0 +1,76 @@
/*
SCHEDULER-INVOCATION.hpp - invocation layer of the render engine scheduler
Copyright (C) Lumiera.org
2023, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/** @file scheduler-invocation.hpp
** Layer-1 of the Scheduler: dispatch and invocation of activities.
** This is the lower layer of the implementation and provides low-level functionality.
**
** @note as of X/2023 this is complete bs
** @see ////TODO_test usage example
** @see scheduler.cpp implementation
**
** @todo WIP-WIP-WIP 6/2023 »Playback Vertical Slice«
**
*/
#ifndef SRC_VAULT_GEAR_SCHEDULER_INVOCATION_H_
#define SRC_VAULT_GEAR_SCHEDULER_INVOCATION_H_
#include "vault/common.hpp"
#include "lib/nocopy.hpp"
//#include "lib/symbol.hpp"
//#include "lib/util.hpp"
//#include <string>
namespace vault{
namespace gear {
// using util::isnil;
// using std::string;
/**
* Scheduler Layer-2 : invocation.
*
* @see SomeSystem
* @see NA_test
*/
class SchedulerInvocation
: util::NonCopyable
{
public:
explicit
SchedulerInvocation (int const& moo)
{ }
};
}} // namespace vault::gear
#endif /*SRC_VAULT_GEAR_SCHEDULER_INVOCATION_H_*/

65
src/vault/gear/scheduler.cpp Normal file
View file

@ -0,0 +1,65 @@
/*
Scheduler - coordination of render activities under timing and dependency constraints
Copyright (C) Lumiera.org
2023, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* *****************************************************/
/** @file scheduler.cpp
** Implementation of messaging, dispatch and prioritisation of render activities.
** The _scheduling_ functionality is assembled from low-level operational building blocks.
**
** @note as of X/2023 this is complete bs
** @todo WIP ///////////////////////TICKET #
**
** @see ////TODO_test usage example
** @see scheduler.cpp implementation
**
** @todo WIP-WIP-WIP 6/2023 »Playback Vertical Slice«
**
*/
#include "vault/gear/scheduler.hpp"
//#include "lib/symbol.hpp"
//#include "include/logging.h"
//#include <string>
//using std::string;
//using util::isnil;
namespace vault{
namespace gear {
namespace { // internal details
} // internal details
// NA::~NA() { }
/**
*/
}} // namespace vault::gear

83
src/vault/gear/scheduler.hpp Normal file
View file

@ -0,0 +1,83 @@
/*
SCHEDULER.hpp - coordination of render activities under timing and dependency constraints
Copyright (C) Lumiera.org
2023, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/** @file scheduler.hpp
** Service for coordination and dispatch of render activities.
** The implementation of scheduling services is provided by an integration
** of two layers of functionality:
** - Layer-1 allows to enqueue and prioritise render activity records
** - Layer-2 connects and coordinates activities to conduct complex calculations
**
** @see ////TODO_test usage example
** @see scheduler.cpp implementation
**
** @todo WIP-WIP-WIP 6/2023 »Playback Vertical Slice«
**
*/
#ifndef SRC_VAULT_GEAR_SCHEDULER_H_
#define SRC_VAULT_GEAR_SCHEDULER_H_
#include "lib/error.hpp"
#include "vault/gear/block-flow.hpp"
#include "vault/gear/scheduler-control.hpp"
#include "vault/gear/scheduler-invocation.hpp"
//#include "lib/symbol.hpp"
#include "lib/nocopy.hpp"
//#include "lib/util.hpp"
//#include <string>
namespace vault{
namespace gear {
// using util::isnil;
// using std::string;
/**
* Schedule and coordinate render activities.
* @todo WIP-WIP 6/2023
* @see SomeSystem
* @see NA_test
*/
class Scheduler
{
int nothing_;
public:
explicit
Scheduler (int const& boo)
: nothing_(boo)
{ }
// using default copy/assignment
};
}} // namespace vault::gear
#endif /*SRC_VAULT_GEAR_SCHEDULER_H_*/

64
src/vault/gear/work-force.cpp Normal file
View file

@ -0,0 +1,64 @@
/*
WorkForce.hpp - actively coordinated pool of workers for rendering
Copyright (C) Lumiera.org
2023, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* *****************************************************/
/** @file work-force.cpp
** Implementation of render worker coordination.
**
** @note as of X/2023 this is complete bs
** @todo WIP ///////////////////////TICKET #
**
** @see ////TODO_test usage example
** @see scheduler.cpp implementation
**
** @todo WIP-WIP-WIP 6/2023 »Playback Vertical Slice«
**
*/
#include "vault/gear/work-force.hpp"
//#include "lib/symbol.hpp"
//#include "include/logging.h"
//#include <string>
//using std::string;
//using util::isnil;
namespace vault{
namespace gear {
namespace { // internal details
} // internal details
// NA::~NA() { }
/**
*/
}} // namespace vault::gear

75
src/vault/gear/work-force.hpp Normal file
View file

@ -0,0 +1,75 @@
/*
WORK-FORCE.hpp - actively coordinated pool of workers for rendering
Copyright (C) Lumiera.org
2023, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/** @file work-force.hpp
** A pool of workers for multithreaded rendering.
**
** @see ////TODO_test usage example
** @see scheduler.cpp implementation
**
** @todo WIP-WIP-WIP 6/2023 »Playback Vertical Slice«
**
*/
#ifndef SRC_VAULT_GEAR_WORK_FORCE_H_
#define SRC_VAULT_GEAR_WORK_FORCE_H_
#include "vault/common.hpp"
#include "lib/nocopy.hpp"
//#include "lib/symbol.hpp"
//#include "lib/util.hpp"
//#include <string>
namespace vault{
namespace gear {
// using util::isnil;
// using std::string;
/**
* Pool of worker threads for rendering.
*
* @see SomeSystem
* @see NA_test
*/
class WorkForce
: util::NonCopyable
{
short nothing_;
public:
explicit
WorkForce (char const& b)
: nothing_(b)
{ }
};
}} // namespace vault::gear
#endif /*SRC_VAULT_GEAR_WORK_FORCE_H_*/

5
tests/core/steam/engine/job-hash-test.cpp
View file

@ -29,6 +29,7 @@
#include "lib/util.hpp"
#include "vault/real-clock.hpp"
#include "vault/gear/job.h"
#include "steam/engine/mock-dispatcher.hpp"
#include <boost/functional/hash.hpp>
@ -39,8 +40,8 @@ namespace engine{
namespace test {
using util::isSameObject;
using vault::engine::Job;
using vault::engine::JobParameter;
using vault::gear::Job;
using vault::gear::JobParameter;

6
tests/core/steam/engine/mock-dispatcher.cpp
View file

@ -40,7 +40,7 @@
#include "steam/engine/mock-dispatcher.hpp"
#include "vault/engine/nop-job-functor.hpp"
#include "vault/gear/nop-job-functor.hpp"
#include "lib/test/test-helper.hpp"
#include "lib/time/timevalue.hpp"
#include "vault/real-clock.hpp"
@ -66,7 +66,7 @@ namespace test {
using std::unordered_map;
using util::access_or_default;
using vault::engine::JobParameter;
using vault::gear::JobParameter;
const int MAX_PARAM_A(1000); ///< random test values 0...1000
@ -186,7 +186,7 @@ namespace test {
DummyClosure dummyClosure;
/** access to the fallback-implementation for empty segments */
lib::Depend<vault::engine::NopJobFunctor> nopFunctor;
lib::Depend<vault::gear::NopJobFunctor> nopFunctor;
}// (End)Implementation details

6
tests/core/steam/engine/mock-dispatcher.hpp
View file

@ -58,7 +58,7 @@
#include "steam/mobject/model-port.hpp"
#include "steam/engine/dispatcher.hpp"
#include "steam/engine/job-ticket.hpp"
#include "vault/engine/job.h"
#include "vault/gear/job.h"
#include "vault/real-clock.hpp"
#include "lib/allocator-handle.hpp"
#include "lib/time/timevalue.hpp"
@ -86,8 +86,8 @@ namespace test {
using util::isSameObject;
using fixture::Segmentation;
using vault::RealClock;
using vault::engine::Job;
using vault::engine::JobClosure;
using vault::gear::Job;
using vault::gear::JobClosure;

6
tests/core/steam/engine/mock-support-test.cpp
View file

@ -28,7 +28,7 @@
#include "lib/test/run.hpp"
#include "lib/test/test-helper.hpp"
#include "steam/engine/mock-dispatcher.hpp"
#include "vault/engine/nop-job-functor.hpp"
#include "vault/gear/nop-job-functor.hpp"
#include "lib/iter-explorer.hpp"
#include "lib/util-tuple.hpp"
#include "lib/util.hpp"
@ -56,7 +56,7 @@ namespace test {
* - configurable setup of a complete frame Dispatcher
* @see JobPlanningPipeline_test
* @see Dispatcher
* @see vault::engine::Job
* @see vault::gear::Job
* @see steam::fixture::Segmentation
*/
class MockSupport_test : public Test
@ -130,7 +130,7 @@ namespace test {
// build a render job to do nothing....
Job nopJob = JobTicket::NOP.createJobFor (frameTime);
CHECK (INSTANCEOF (vault::engine::NopJobFunctor, static_cast<JobClosure*> (nopJob.jobClosure))); //////////TICKET #1287 : fix actual interface down to JobFunctor (after removing C structs)
CHECK (INSTANCEOF (vault::gear::NopJobFunctor, static_cast<JobClosure*> (nopJob.jobClosure))); //////////TICKET #1287 : fix actual interface down to JobFunctor (after removing C structs)
CHECK (nopJob.parameter.nominalTime == frameTime);
InvocationInstanceID empty; ///////////////////////////////////////////////////////////////////////TICKET #1287 : temporary workaround until we get rid of the C base structs
CHECK (lumiera_invokey_eq (&nopJob.parameter.invoKey, &empty));

10
tests/core/steam/engine/scheduler-interface-test.cpp
View file

@ -32,13 +32,13 @@
#include "lib/util.hpp"
#include "vault/real-clock.hpp"
#include "vault/engine/scheduler-frontend.hpp"
#include "vault/engine/scheduler-diagnostics.hpp"
#include "vault/gear/scheduler-frontend.hpp"
#include "vault/gear/scheduler-diagnostics.hpp"
#include "steam/engine/mock-dispatcher.hpp"
namespace vault {
namespace engine {
namespace vault{
namespace gear {
namespace test {
using util::isSameObject;
@ -201,4 +201,4 @@ namespace test {
/** Register this test class... */
LAUNCHER(SchedulerInterface_test, "unit engine");
}}} // namespace vault::engine::test
}}} // namespace vault::gear::test

2
tests/core/steam/fixture/fixture-segment-test.cpp
View file

@ -44,7 +44,7 @@ namespace test {
using engine::ExitNode;
using lib::diff::MakeRec;
using engine::Job;
using vault::gear::Job;
using engine::JobTicket;
using engine::test::MockSegmentation;

6
wiki/renderengine.html
View file

@ -7044,7 +7044,7 @@ Later on we expect a distinct __query subsystem__ to emerge, presumably embeddin
&amp;rarr; QuantiserImpl</pre>
</div>
<div title="Scheduler" creator="Ichthyostega" modifier="Ichthyostega" created="202304140131" modified="202305290239" tags="Rendering spec draft" changecount="5">
<div title="Scheduler" creator="Ichthyostega" modifier="Ichthyostega" created="202304140131" modified="202306222158" tags="Rendering spec draft" changecount="7">
<pre>//Invoke and control the dependency and time based execution of [[render jobs|RenderJob]]//
The Scheduler acts as the central hub in the implementation of the RenderEngine and coordinates the //processing resources// of the application. Regarding architecture, the Scheduler is located in the Vault-Layer and //running// the Scheduler is equivalent to activating the »Vault Subsystem«. An EngineFaçade acts as entrance point, providing high-level render services to other parts of the application: [[render jobs|RenderJob]] can be activated under various timing and dependency constraints. Internally, the implementation is segregated into two layers
;Layer-2: Control
@ -7056,9 +7056,9 @@ The Scheduler acts as the central hub in the implementation of the RenderEngine
!Event based vs. time based operational control
Time bound delivery of media data is an important aspect of editing and playback -- yet other concerns are of similar importance: the ability to make optimum use of scarce resources and to complete extended processing in reasonable time, while retaining some overall responsiveness of the system. And, especially for the //final render,// it is tantamount to produce 100% correct results without any glitches -- a goal that can not be reconciled with the demand for perfect timing. These considerations alone are sufficient to indicate, that strict adherence to a pre-established calculation plan is not enough to build a viable render engine. As far as media processing is concerned, the limited I/O bandwidth is the most precious resource -- reading and writing data from persistent storage requires a lot of time, with generally unpredictable timings, necessitating asynchronous processing.
This leads to the observation that every render or playback process has to deal with rather incompatible processing patterns and trends: for one, processing has to start as soon as the event of an completed I/O-operation is published, yet on the other hand, limited computational resources must be distributed and prioritised such as to deliver the completed data as close as possible to a pre-established timing deadline, under the constraint of limited in-memory buffer capacity. The //control structure// of an render engine is thus not only a time based computation plan -- first and foremost it should be conceived as an asynchronous messaging system, with the ability however to prioritise some messages based on urgency or approaching deadlines.
This leads to the observation that every render or playback process has to deal with rather incompatible processing patterns and trends: for one, processing has to start as soon as the event of an completed I/O-operation is published, yet on the other hand, limited computational resources must be distributed and prioritised in a way suitable to deliver the completed data as close as possible to a pre-established timing deadline, under the constraint of limited in-memory buffer capacity. The //control structure// of such a render engine is thus not only a time based computation plan -- first and foremost it should be conceived as an asynchronous messaging system, with the ability however to prioritise some messages based on urgency or approaching deadlines.
The time-based ordering and prioritisation of [[render activities|RenderActivity]] is thus used as a //generic medium and agent// to support and implement complex interwoven computational tasks. On the layer-1 mentioned above, a combination of a lock-free dispatch queue is used, feeding into a single threaded priority queue organised by temporal deadlines. Most render activities are lightweight and fast updates of some state flags, while some activities are extremely long running -- and those are shifted into worker threads based on priority.
The time-based ordering and prioritisation of [[render activities|RenderActivity]] is thus used as a //generic medium and agent// to support and implement complex interwoven computational tasks. On the layer-1 mentioned above, a combination of a lock-free dispatch queue is used, feeding into a single threaded priority queue organised by temporal deadlines. Most render activities are lightweight and entail quick updates to some state flags, while certain activities are extremely long running -- and those are shifted into worker threads based on priority.
</pre>
</div>
<div title="SchedulerRequirements" modifier="Ichthyostega" created="201107080145" modified="201112171835" tags="Rendering spec draft discuss">

109
wiki/thinkPad.ichthyo.mm
View file

@ -64862,8 +64862,29 @@
<node CREATED="1544199952785" ID="ID_1989078064" MODIFIED="1544199955148" TEXT="deep down"/>
</node>
</node>
<node CREATED="1687556508704" ID="ID_431446810" MODIFIED="1687556579475" TEXT="Namespaces">
<icon BUILTIN="info"/>
<node CREATED="1687556588554" ID="ID_329807646" MODIFIED="1687556590245" TEXT="stage"/>
<node CREATED="1687556584353" ID="ID_1889681441" MODIFIED="1687556586623" TEXT="steam"/>
<node CREATED="1687556472975" ID="ID_735349056" MODIFIED="1687556555928" TEXT="vault">
<node CREATED="1687481181547" ID="ID_873971075" MODIFIED="1687481185746" TEXT="vault::io"/>
<node CREATED="1687481158310" ID="ID_616065524" MODIFIED="1687481178193" TEXT="vault::out"/>
<node CREATED="1687481369475" ID="ID_1291504357" MODIFIED="1687481387314" TEXT="vault::mem"/>
<node CREATED="1687481240852" ID="ID_144816295" MODIFIED="1687481343154" TEXT="vault::gear"/>
<node CREATED="1687481191768" ID="ID_12320912" MODIFIED="1687481195319" TEXT="vault::cache"/>
<node CREATED="1687481220759" ID="ID_568286499" MODIFIED="1687481233535" TEXT="vault::toolkit"/>
<node CREATED="1687481208317" ID="ID_1663294300" MODIFIED="1687481213324" TEXT="vault::storage"/>
</node>
</node>
</node>
<node CREATED="1584202142543" ID="ID_1162501513" MODIFIED="1584202145125" TEXT="Subsysteme">
<node CREATED="1687475100398" ID="ID_875692100" MODIFIED="1687475103561" TEXT="Gui"/>
<node CREATED="1687475104709" ID="ID_395691865" MODIFIED="1687475107788" TEXT="Session"/>
<node CREATED="1687475121914" ID="ID_1816829147" MODIFIED="1687475124942" TEXT="PlayOut"/>
<node CREATED="1687475211318" ID="ID_1096951161" MODIFIED="1687475213686" TEXT="Engine"/>
<node CREATED="1687475229300" ID="ID_768400893" MODIFIED="1687475234772" TEXT="(NetNode)"/>
<node CREATED="1687475218948" ID="ID_1699167582" MODIFIED="1687475228664" TEXT="(ScriptRunner)"/>
</node>
<node CREATED="1584202142543" ID="ID_1162501513" MODIFIED="1584202145125" TEXT="Subsysteme"/>
<node CREATED="1584202146097" ID="ID_876294763" MODIFIED="1584202148362" TEXT="ETD">
<node CREATED="1584202158174" ID="ID_1136082827" MODIFIED="1584202164409" TEXT="inh&#xe4;rente Einschr&#xe4;nkungen">
<node CREATED="1584202165470" ID="ID_1464264076" MODIFIED="1584202167873" TEXT="Diff-System">
@ -75687,8 +75708,8 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
</node>
</node>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1681742264338" ID="ID_627755845" MODIFIED="1681742273104" TEXT="in RenderDrive &#xfc;berf&#xfc;hren">
<icon BUILTIN="flag-yellow"/>
<node BACKGROUND_COLOR="#d2beaf" COLOR="#5c4d6e" CREATED="1681742264338" ID="ID_627755845" MODIFIED="1687465589629" TEXT="in RenderDrive &#xfc;berf&#xfc;hren">
<icon BUILTIN="hourglass"/>
<node BACKGROUND_COLOR="#f0d5c5" COLOR="#990033" CREATED="1684975260910" ID="ID_675928767" MODIFIED="1684975279714" TEXT="wo genau wird die Pipeline angesiedelt?">
<icon BUILTIN="help"/>
<node CREATED="1685058111671" ID="ID_1591073548" MODIFIED="1685058114306" TEXT="Datenstruktur">
@ -76563,7 +76584,7 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
</node>
</node>
</node>
<node COLOR="#338800" CREATED="1686793470108" HGAP="-9" ID="ID_1024827381" MODIFIED="1687226399165" TEXT="JobPlanning_test" VSHIFT="7">
<node COLOR="#338800" CREATED="1686793470108" FOLDED="true" HGAP="-9" ID="ID_1024827381" MODIFIED="1687226399165" TEXT="JobPlanning_test" VSHIFT="7">
<icon BUILTIN="button_ok"/>
<node COLOR="#338800" CREATED="1686793496442" ID="ID_1934790434" MODIFIED="1686873178829" TEXT="simpleUsage">
<icon BUILTIN="button_ok"/>
@ -76593,7 +76614,7 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
<icon BUILTIN="button_ok"/>
</node>
</node>
<node COLOR="#338800" CREATED="1687226442603" HGAP="-25" ID="ID_1588706779" MODIFIED="1687393224652" TEXT="JobPlanningPIpeline_test::integration()" VSHIFT="17">
<node COLOR="#338800" CREATED="1687226442603" FOLDED="true" HGAP="-25" ID="ID_1588706779" MODIFIED="1687393224652" TEXT="JobPlanningPIpeline_test::integration()" VSHIFT="17">
<icon BUILTIN="button_ok"/>
<node COLOR="#338800" CREATED="1687226500123" ID="ID_667484740" MODIFIED="1687226507025" TEXT="3-stufige Prerequisites">
<icon BUILTIN="button_ok"/>
@ -76719,10 +76740,10 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
</node>
</node>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1684967502141" ID="ID_470129345" LINK="https://issues.lumiera.org/ticket/1301" MODIFIED="1684975281405" TEXT="#1301 Render-Drive extrahieren">
<node BACKGROUND_COLOR="#d2beaf" COLOR="#5c4d6e" CREATED="1684967502141" ID="ID_470129345" LINK="https://issues.lumiera.org/ticket/1301" MODIFIED="1687465619217" TEXT="#1301 Render-Drive extrahieren">
<linktarget COLOR="#942e62" DESTINATION="ID_470129345" ENDARROW="Default" ENDINCLINATION="-1340;103;" ID="Arrow_ID_1563903339" SOURCE="ID_1293956051" STARTARROW="None" STARTINCLINATION="-1408;109;"/>
<font NAME="SansSerif" SIZE="13"/>
<icon BUILTIN="flag-yellow"/>
<font NAME="SansSerif" SIZE="12"/>
<icon BUILTIN="hourglass"/>
</node>
</node>
</node>
@ -77841,6 +77862,74 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1680564304940" ID="ID_1657236591" MODIFIED="1680565125463" TEXT="Scheduler entwerfen">
<linktarget COLOR="#f6e1c2" DESTINATION="ID_1657236591" ENDARROW="Default" ENDINCLINATION="-1219;85;" ID="Arrow_ID_49470357" SOURCE="ID_59027079" STARTARROW="None" STARTINCLINATION="-2189;368;"/>
<icon BUILTIN="flag-yellow"/>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1687471254704" ID="ID_1902396309" MODIFIED="1687471266974" TEXT="Basis und Rahmen">
<icon BUILTIN="pencil"/>
<node CREATED="1687475603990" ID="ID_363400970" MODIFIED="1687475621515" TEXT="Subsystem: Engine">
<node CREATED="1687475672009" ID="ID_1124965523" MODIFIED="1687475695860" TEXT="im Vault-Layer">
<node CREATED="1687475741885" ID="ID_262067370" MODIFIED="1687475750878" TEXT="Konsequenz: alle Interfaces m&#xfc;ssen dort liegen"/>
</node>
<node CREATED="1687475755810" ID="ID_1110198652" MODIFIED="1687475768912" TEXT="Descriptor / Lifecycle"/>
<node CREATED="1687475776684" ID="ID_1947467264" MODIFIED="1687482209668" TEXT="Aktoren">
<node CREATED="1687482088480" ID="ID_151642165" MODIFIED="1687482091993" TEXT="WorkForce"/>
<node CREATED="1687484538013" ID="ID_1739107434" MODIFIED="1687484542420" TEXT="BlockFlow"/>
<node CREATED="1687484543164" ID="ID_1128972304" MODIFIED="1687484550647" TEXT="ActLang als front-End"/>
</node>
</node>
<node CREATED="1687475814605" ID="ID_339808288" MODIFIED="1687475824090" TEXT="Betriebs-Aufbau">
<node CREATED="1687484185010" ID="ID_177219896" MODIFIED="1687484190168" TEXT="ein fest verdrahtetes Setup"/>
</node>
<node CREATED="1687475807706" ID="ID_1176659376" MODIFIED="1687475811983" TEXT="Test-Aufbau">
<node CREATED="1687481605885" ID="ID_1099864057" MODIFIED="1687481621091" TEXT="jedes der Elemente kann einzeln konstruiert werden"/>
<node CREATED="1687484195107" ID="ID_247852496" MODIFIED="1687484210802" TEXT="es gibt einen impliziten Fallback-Memory-Manager (anstelle von BlockFlow)"/>
<node CREATED="1687484233310" ID="ID_97192372" MODIFIED="1687484255607" TEXT="die meisten Tests laufen single-threaded (WorkForce wird nicht verwendet)"/>
</node>
<node CREATED="1687475840950" ID="ID_131076132" MODIFIED="1687475860880" TEXT="Elemente">
<node CREATED="1687476035955" ID="ID_745059399" MODIFIED="1687480101057" TEXT="WorkForce">
<node CREATED="1687484263258" ID="ID_715579646" MODIFIED="1687484368256" TEXT="das ist der Thread-Pool, aber als aktiver Aktor">
<richcontent TYPE="NOTE"><html>
<head>
</head>
<body>
<p>
Das w&#228;re dann eine sehr spezielle Design-Entscheidung: nicht eine passiver Threadpool, dem von einem aktiven Manager aus die Aufgaben zugewiesen werden, sondern aktive Worker, die sich selber regulieren und Arbeit holen
</p>
</body>
</html></richcontent>
</node>
</node>
<node CREATED="1687476033151" ID="ID_1605738003" MODIFIED="1687476035463" TEXT="Scheduler">
<node CREATED="1687484375451" ID="ID_888761832" MODIFIED="1687484404856" TEXT="ein passiver Service, von dem man Activities &#x201e;pullt&#x201c;"/>
</node>
<node CREATED="1687476248645" ID="ID_1405896472" MODIFIED="1687476251782" TEXT="BlockFlow">
<node CREATED="1687484406935" ID="ID_1480465932" MODIFIED="1687484460324" TEXT="ein tiling Memory-Manager mit Lifecycle/Waterlevel-Logik"/>
</node>
<node CREATED="1687480006141" ID="ID_870147992" MODIFIED="1687556434654" TEXT="ActivityLang">
<node CREATED="1687484476295" ID="ID_542107050" MODIFIED="1687484512308" TEXT="das Spezifikations-front-End: &#x201e;wirft&#x201c; Activities ab"/>
</node>
</node>
<node CREATED="1687475864475" ID="ID_1012744696" MODIFIED="1687475867351" TEXT="Code">
<node CREATED="1687475904735" ID="ID_1072640791" MODIFIED="1687556555928" TEXT="namespaces">
<node CREATED="1687556559097" ID="ID_1268061315" LINK="#ID_144816295" MODIFIED="1687556574423" TEXT="vault::gear"/>
</node>
<node CREATED="1687475909253" ID="ID_1225611567" MODIFIED="1687475920182" TEXT="Schnittstellen">
<node CREATED="1687484610198" ID="ID_1535673641" MODIFIED="1687556627249" TEXT="activity-lang.hpp"/>
<node CREATED="1687484615702" ID="ID_1695611291" MODIFIED="1687484621919" TEXT="work-force.hpp"/>
<node CREATED="1687484622953" ID="ID_1237116260" MODIFIED="1687484628393" TEXT="block-flow.hpp"/>
<node CREATED="1687484635170" ID="ID_1036236582" MODIFIED="1687484638425" TEXT="scheduler.hpp"/>
</node>
<node CREATED="1687475927002" ID="ID_1686499468" MODIFIED="1687475972136" TEXT="Baueinheiten">
<node CREATED="1687484825582" ID="ID_940173275" MODIFIED="1687556670006" TEXT="SchedulerControl">
<node CREATED="1687484855082" ID="ID_1615253188" MODIFIED="1687484859590" TEXT="&#x2261; Layer-2"/>
</node>
<node CREATED="1687484832866" ID="ID_922933023" MODIFIED="1687556674341" TEXT="SchedulerInvocation">
<node CREATED="1687484837790" ID="ID_563933668" MODIFIED="1687484852947" TEXT="&#x2261; Layer-1"/>
</node>
<node CREATED="1687556757899" ID="ID_1532413492" MODIFIED="1687556761169" TEXT="scheduler.cpp"/>
<node CREATED="1687568938113" ID="ID_1621332483" MODIFIED="1687568944537" TEXT="block-flow.cpp"/>
</node>
</node>
</node>
<node CREATED="1680565469342" ID="ID_250843894" MODIFIED="1680566937368" TEXT="Priority-Scheduling">
<linktarget COLOR="#fec499" DESTINATION="ID_250843894" ENDARROW="Default" ENDINCLINATION="-644;84;" ID="Arrow_ID_1702721830" SOURCE="ID_12567096" STARTARROW="None" STARTINCLINATION="-233;30;"/>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1684973294743" ID="ID_495348423" MODIFIED="1684973356775" TEXT="Strukturen und Repr&#xe4;sentation">
@ -78506,7 +78595,7 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
</p>
</body>
</html></richcontent>
<node CREATED="1685321279620" ID="ID_1359467423" MODIFIED="1685321303575" TEXT="Prio-1 : aus der Notivication-Queue neue Activities entnehmen"/>
<node CREATED="1685321279620" ID="ID_1359467423" MODIFIED="1685321303575" TEXT="Prio-1 : aus der Notification-Queue neue Activities entnehmen"/>
<node CREATED="1685321306206" ID="ID_109301359" MODIFIED="1685321359515" TEXT="Prio-2 : diese Activities in die Priority-Queue einstellen"/>
<node CREATED="1685321368627" ID="ID_335558978" MODIFIED="1685321394736" TEXT="Prio-3 : von der Spitze der Priority-Queue aktuell dringende Activities abnehmen"/>
</node>
@ -78543,7 +78632,7 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
<icon BUILTIN="idea"/>
<node CREATED="1685321805315" ID="ID_1461293102" MODIFIED="1685321813542" TEXT="die Laufzeit f&#xfc;r Notifications ist kurz"/>
<node CREATED="1685321814058" ID="ID_1167518732" MODIFIED="1685321822805" TEXT="aber Notifications k&#xf6;nnen aus allen Threads kommen"/>
<node CREATED="1685321823825" ID="ID_135604936" MODIFIED="1685321848244" TEXT="das Konsumieren der Notifications dagegen passiert im mit der Proze&#xdf;steuerung"/>
<node CREATED="1685321823825" ID="ID_135604936" MODIFIED="1687466146764" TEXT="das Konsumieren der Notifications dagegen passiert mit der Proze&#xdf;steuerung"/>
<node CREATED="1685321848944" ID="ID_1429281514" MODIFIED="1685321863381" TEXT="und diese wird chunk-wise single-threaded ausgef&#xfc;hrt"/>
<node CREATED="1685321874220" ID="ID_1713195430" MODIFIED="1685321882281" TEXT="ab diesem Punkt sind Activities langlebig"/>
</node>