GlobalInitialization

int lumiera_init(s.b.) initializes the subsystems, global registries, NoBug and other things. Must be called once at startup.

void lumiera_destroy(void) shuts down, frees resources, cleans up.

we use a global Lifecycle manager now

individual components enrol themselves and get their lifecycle hooks invoked

the Application is structured into Subsystems. These can depend on each other and are started and stopped explicitly.

by policy, clean-up and unwinding is always considered optional — but we care to implement a complete shutdown and memory unwinding for sake of sanity.

You may have noted that I implemented an Appconfig class (for some very elementary static configuration constants. See common/appconfig.hpp I choose to implement it as Meyers Singleton, so it isn’t dependent on global static initialisation, and I put the NOBUG_INIT call there too, so it gets issued automatically.

Generally speaking, I can’t stress enough to be reluctant with static init, so count me to be much in support for this design draft. While some resources can be pulled up on demand (and thus be a candidate for some of the many singleton flavours), some things simply need to be set up once, and its always better to do it explicitly and in a defined manner.

For the proc layer, I plan to concentrate much of the setup and (re)configuration within the loading of a session, and I intend to make the session manager create an empty default session at a well defined point, probably after parsing the commandline in main (and either this or the loading of a existing session will bring the proc layer up into fully operational state

About NoBug initialization: I’ve seen that you made a nobugcfg where you centralized all nobug setup. Problem here is that a change in that file forces a whole application rebuild. I’d like to factor that out that each subsystem and subsubsystem does its own NOBUG_FLAG_INIT() initializations, the global NOBUG_INIT should be done in main() (of testsuites, tools, app) and not even in the global initialization handler. Note that I use this global initialization in a nested way

lumiera_init ()
{
  lumiera_backend_init();
  ...
}

lumiera_backend_init()
{
  ...backend-global nobug flags ..
  ...backend subsystems _init() ..
  ...
}

Regarding organisation of includes: I agree that my initial approach ties things too much together. This is also true for the global "lumiera.h" which proved to be of rather limited use. Probably we’ll be better of if every layer has a separate set of basic or global definition headers. I think the usage pattern of the flags (btw. the idea of making a flag hierarchy is very good!) will be much different in the backend, the proc layer and the gui.

Initialisation of the very basic services is tricky, as always. Seemingly this includes NoBug. Of course one wants to use assertions and some diagnostics logging already in constructor code, and, sadly enough it can’t be avoided completely to run such already in the static initialisation phase before entering main(). My current solution (putting NOBUG_INIT it in the Appconfig ctor) is not airtight, I think we can’t avoid going for something like a Schwartz counter here.

Then there is the initialisation of common services. For these, it’s just fine to do a dedicated call from main (e.g. to init the backend services and for creating the basic empty session for proc and firing off the event loop for the GUI). I think it’s no problem to 'disallow' any IO, any accessing of services in the other layers prior to this point.

What is with shutdown? personally, I’d like to call a explicit shutdown hook at the end of main and to disallow any IO and usage of services outside each subsystem after this point. Currently, I have the policy for the proc layer to require every destructor to be called and everything to be deallocated, meaning that quite a lot of code is running after the end of main() — most of which is library generated.

Regarding organisation of includes:… agreed

Initialisation of the very…

Then there is the initialisation of common services… agreed

What is with shutdown?…

Moved lumiera.h and nobugcfg.h to proc/lumiera.hpp and nobugcfg.hpp (i.e. consider them now as Proc-Layer only)

Changed Appconfig to support simple lifecycle hooks, especially a ON_BASIC_INIT. Rationale is that I don’t have a lot of "magic" code in the Appconfig ctor, rather each subsystem in need of a basic initialisation can install a small callback. It can do so for other lifecycle events too.

Added the usual magic static ctor to install those callbacks in case they really need an early init. Thus now nobugcfg.hpp can install a callback to issue NOBUG_INIT, error.hpp does the same for the unknown-exception handler. I’ll expect the config query system to need something similar soon.

For all remaining initialisation (in case it can’t be done on demand, which of course is always preferable) now main() issues and explicit call Appconfig::lifecycle (ON_GLOBAL_INIT) and similar fire off ON_GLOBAL_SHUTDOWN at end. Similar for the tests. We could add an init-call for the backend there too, either directly or by registering an callback, just as it fits in better.

This system is extensible: for example I plan to let the SessionManager issue ON_SESSION_INIT and ON_SESSION_CLOSE events. E.g. AssetManager could now just install his callbacks to clean up the internal Asset registry

this RfC proposes only one tiny and lightweight feature.

Startup and Shutdown of an application like Lumiera requires way more than this. More specifically, we have to consider modularisation.

in hindsight, I was naiive to agree with this proposal. It can not be that easy.

my comments do indeed indicate the direction the further development did take: today, Lumiera does the exact opposite of this proposal, there is no central init call — we use modularised hooks instead and each subsystem is self contained. We even have a subsystem manager to handle dependencies in startup and shtudown.