Some questions about the organizer.

[obfuscate]

Hello there!

I'm a newbie with EnTT and I'm trying to use entt::organizer to build an execution graph of systems and I've got some questions.

I use version 3.15.0 from vcpkg (in case of it does matter).

Some test code:

struct CompA {};
struct CompB {};
struct CompC {};

struct Time
{
	float dt = 0.0f;
};

struct System0
{
	using View = entt::view<entt::get_t<const CompA>>;

	void tick(View view, const float dt) {}
};
struct System1
{
	using View = entt::view<entt::get_t<const CompB>>;

	void tick(View view, const float dt) {}
};
struct System2
{
	using View = entt::view<entt::get_t<const CompC>>;

	void tick(View view, const float dt) {}
};
struct System3
{
	using View = entt::view<entt::get_t<CompA>>;

	void tick(View view, const float dt) {}
};
struct System3
{
	using View = entt::view<entt::get_t<CompA>>;

	void tick(View view, const float dt) {}
};
struct System4
{
	using View = entt::view<entt::get_t<CompB>>;

	void tick(View view, const float dt) {}
};
struct System5
{
	using View = entt::view<entt::get_t<CompC>>;

	void tick(View view, const float dt) {}
};
struct System7
{
	using View0 = entt::view<entt::get_t<const CompB>>;
	using View1 = entt::view<entt::get_t<const CompC>>;
	using View2 = entt::view<entt::get_t<const CompA>>;

	void tick(View0 view0, View1 view1, View2 view2, const float dt) {}
};

entt::organizer organizer;
organizer.emplace<&System0::tick>(sys0, "sys0");
organizer.emplace<&System1::tick>(sys1, "sys1");
organizer.emplace<&System2::tick>(sys2, "sys2");
organizer.emplace<&System3::tick>(sys3, "sys3");
organizer.emplace<&System3::tick>(sys4, "sys4");
organizer.emplace<&System3::tick>(sys5, "sys5");
organizer.emplace<&System7::tick>(sys7, "sys7");
auto graph = organizer.graph();
for (auto&& node : graph)
{
  ...
}

1. Why does const float dt produce linear graph where each system has got RW access and therefore depends on a previous system?
   
   
   P.S: I understand that I can replace const float into const Time& and it solves the problem, but anyway looks like const float shouldn't produce RW edges...
2. Why adding const entt::registry& to the tick methods does produce also a linear graph? But in that case RW counter isn't incremented, but only sys0 is top level and other nodes have an in edge as the prev node.
3. In case when systems aren't known in advance (for example all my gameplay logic is separated onto many dlls providing unique features, therefore I can't manually place them in the right order), how can I support ordering between them?
4. Just a silly question: Why doesn't organizer sort functors by RW access firstly? Looks like it is good way firstly complete all "systems" with RW access and only after that start doing RO job.
5. Does organizer support groups, reactive storages, etc?

[skypjack]

On the verge of a national holiday 😅 sorry to keep you waiting, but this requires me to debug and test the code you posted.

[skypjack]

The second one. In my mind, Sys0, Sys1 and Sys2 are independent, but adding "const entt::registry&" to their methods turn them into the sequence 0 -> 1 -> 2.

I think this is a bug then. Can you open an issue with the reproducible example that you already have? Probably I know way it works like this. Fixing it should be easy, but I need to write a non-regression test at least. Just let me know. Otherwise, I can open the issue on myself. Thanks.

[skypjack]

So, to summarize, there isn't such API and you don't want to add it because of simplicity?

It's not there, right. I don't want to add it? 🤔 I'm not opposed actually, but it requires some changes probably. It's not something that I can implement and test in an afternoon. 🙂

[skypjack]

Are reactive mixins also supported in that easy way?

I don't see where you are using the reactive storage with the organizer. 🤔
Anyway, a reactive storage should be safe if we assume that you are not going to add multiple instances of the same type in parallel (which would be a race, so you're not). This means that it works correctly when you schedule your systems and run them in parallel, unless you did something wrong. 😅
A very it works until it doesn't like answer, but that's what it is actually. Let's say that if it breaks, then the bug is somewhere else, most likely in the scheduling design. Makes more sense?

[obfuscate]

I think this is a bug then. Can you open an issue with the reproducible example that you already have? Probably I know way it works like this. Fixing it should be easy, but I need to write a non-regression test at least. Just let me know. Otherwise, I can open the issue on myself. Thanks.

Oh, fine, I'll try to open an issue asap.

I don't see where you are using the reactive storage with the organizer. 🤔

It seems because I don't understand how can I pass it to the organizer. I'm a little bit struggle with it. I found a workaround (like in example), but I'm not sure that it is a good way.

I'm not opposed actually, but it requires some changes probably. It's not something that I can implement and test in an afternoon. 🙂

So in that case I may try to open an issue/feature request then :)

[obfuscate]

@skypjack there is an issue #1258

[obfuscate]

And one more question:
6. Is it okay to call prepare for a graph's node a few times?

[skypjack]

I think this is more a matter of performance than anything else. A call to prepare forces the creation of the pools if they don't exist. The second time, you're just walking over the if guards before returning to the caller.

[obfuscate]

Sounds fine, I recreate a graph only when a user adds a new module, so it is very seldom operation, but I'm to lazy to recreate the whole internal structures:)
Thanks a lot for this answer!

[obfuscate]

Silly question number 7:
For example my tick method has the next signature:

struct System0
{
	using View = entt::view<entt::get_t<const CompA>>;

	void tick(View view, const Time& time) {}
};

I emplace this method to the organizer: organizer.emplace<&System0::tick>(sys0, "sys0");.
As far as I understood I should use methods callback and data from the graph's node, something like that:

auto graph = organizer.graph();
for (auto&& node : graph)
{
  auto func = node.callback();
  auto data = node.data();
  func(data, registry);
}

But how can I pass for example my Time structure (or any another custom type) to this callback?

[skypjack]

You don't pass values. You can emplace member functions (and have the this) or free functions with a payload (as it happens here), but it's up to you to guarantee that the lifetime of the payload overcomes that of the graph.

[obfuscate]

Ok, you linked your unit test, let's consider it:)

struct clazz {
    void ro_int_char_double(entt::view<entt::get_t<const int, const char>>, const double &) {}
    void rw_int(entt::view<entt::get_t<int>>) {}
    void rw_int_char(entt::view<entt::get_t<int, char>>) {}
    void rw_int_char_double(entt::view<entt::get_t<int, char>>, double &) {}

    static void ro_int_with_payload(const clazz &, entt::view<entt::get_t<const int>>) {}
    static void ro_char_with_payload(const clazz &, entt::group<entt::owned_t<const char>>) {}
    static void ro_int_char_with_payload(clazz &, entt::view<entt::get_t<const int, const char>>) {}
};
...
organizer.emplace<&clazz::ro_int_char_double>(instance, "t1");
    organizer.emplace<&clazz::ro_int_with_payload>(instance, "t2");
    organizer.emplace<&clazz::ro_char_with_payload, const clazz>(instance, "t3");
    organizer.emplace<&clazz::ro_int_char_with_payload, clazz>(instance, "t4");
    organizer.emplace<&clazz::rw_int_char>(instance, "t5");

In case of ro_int_char_double what does mean const double & ? How will it pass to that function via graph::node::callback(data, registry)?

[skypjack]

From the documentation:

These are the parameters that a free function or a member function can accept:

• <not relevant here>
• <not relevant here>
• A possibly constant reference to any type T (that is, a context variable).

It gets the double variable (this is a dumb example, granted, but it can be any type) from the context of the registry.

[obfuscate]

So, in that case we may pass some data via context, super!

But it seems when I tried to do the following stuff, it didn't work (Time::dt was always zero):

struct Time
{
   float dt = 0.0f;
};

struct System0
{
	using View = entt::view<entt::get_t<const CompA>>;

	void tick(View view, const Time& time) {}
};

world::initialize()
{
   registry.ctx().emplace<Time>();
   organizer.emplace<&System0::tick>(sys0, "sys0");
   auto graph = organizer.graph();
   for (auto&& node : graph)
   {
	node.prepare(registry);
   }
}

world::tick(const float dt)
{
    registry.ctx().get<Time>().dt = dt;

   auto graph = organizer.graph();
   for (auto&& node : graph)
   {
	auto callback = node.callback();
	auto data = node.data();
	callback(data, registry); //-- in System0::tick Time is always zero.
   }
}

[obfuscate]

Question 8: Is there a way to create a sync point using entt::organizer? Could you provide an example?

[skypjack]

Like this one?

[obfuscate]

There is key point in using just entt::registry& to create a sync point or it is require also enumerate other "views"?

[skypjack]

You can have the registry as the only argument (or I need to fix it otherwise 😅). Moreover, from the documentation:

As for the registry, if a function does not explicitly request it or requires a constant reference to it, it is considered a read-only access. Otherwise, it is considered as read-write access. All functions have the registry among their resources.

Maybe this is tricky. What it means is: if all functions have the registry as a resource, the first one that gets it as non-const is a sync point (rw access vs ro accesses). That's easier to figure out like this probably?

[obfuscate]

Bump...

[skypjack]

Good one 😅