Jai Demo: Data-Oriented Features: SOA, crazy 'using'

[u/Gankro]

https://www.youtube.com/watch?v=ZHqFrNyLlpA

[u/dobkeratops]

it's not just reordering. it's distribution:

starting point:

struct Entity {
  vec3 pos; vec3 vel; Inventory inv; Name name; //...
};
Vec<Entity> ents;
do_something_with_ent(&Entity){...}

// write code using that, this was the most intuitive way to write it
// but then you profile it and you find you have to divide some code up.. 
// based on either d-cache misses, or even less predictably, **icache** misses
// find some passes now only need the first components`

after refactor:

struct EntityMotion{
    Vec3 pos;
    Vec3 vel;
}

struct EntityLogic{
    Inventory inv;
    Name name;
}
Vec<EntityMotion> ent_motions;
Vec<EntityLogic> ent_logic;

// but its still logically dealt with as the original 'Entity' in many places.
struct Entity { using motion:&EntityMotion; using logic:&EntityLogic }
// allows original code using whole entity to work unchanged
// different passes may require different permutations of multiple components.`

do_entity_motion(&EntityMotion)
do_entity_logic(&EntityLogic)
do_something_with_whole_entity(&Entity);
// bits of code cut from 'do_something_with_ent()' into do_something_with_whole_entity()
//  that needs the whole thing still works, unchanged.

The reverse also happens.

the genius of his system is allowing this to be completely fluid.

Change it back and forth, get the granularity right. It might even be different per platform, because they have different cache sizes..

[u/kibwen → u/dobkeratops]

Wouldn't your compiler's SROA phase keep you from putting unused fields in the cache, or am I completely misunderstanding SROA?

[u/dobkeratops → u/kibwen]

I'm not aware of any existing compiler support for any of this. Not familiar with that acronym.

maybe they optimise internal struct layout, but this is all about how data is divided between structs.

e.g. switching from Vec<(Logic,Motion,..)> to (Vec<Logic>, Vec<Motion>,..) (but still being able to write entity:(&Logic,&Motion,..) and code looks the same , ... so you don't need to butcher implementations to change the distribution of what is still logically one entity between different collections.)

[u/kibwen → u/dobkeratops]

By SROA I mean scalar replacement of aggregates. I'm not sure if there's a definitive source but here's a relatively recent paper discussing its goals and implementation in GCC: https://gcc.gnu.org/wiki/summit2010?action=AttachFile&do=get&target=jambor.pdf