branchy

Generic branchy business logic type code is indeed about as fast in C++ as in Java.

Of course, because of high latencies, when running pointer chasing or branchy code, there's little improvement.

C/C++ is very branchy and uses slow function pointers often (vtable, switch jump tables, etc).

Sufficiently smart compilers never showed up where it mattered most for Intel: Turning branchy C/C++ system and apps code into explicitly parallel instructions.

So after a while I resolve all the branchy, bushy sub-issues and have a reasonable game plan.

They're all about branchy code such as business logic, encoding / decoding, etc.

Ahhhh, I love hacks like this:) But it is super branchy; I would definitely profile before assuming it's an improvement.

This is cool, but I wonder if compiled C# code will be too branchy to run fast on the GPU.

Those branchy ridge shapes look a lot like Diffusion-Limited Aggregate patterns.

Point in polygon is also very branchy in general case.

So generally speaking, we'd expect JIT to shine with certain branchy or unpredictable code, but static compilers to shine for basic blocks.

> Nothing but trouble merging the stored output from the tooling if you are in a branchy development.

Currently you put the workload that requires low latency on a CPU and embarrassingly parallel "non-branchy" workload on a GPU.

The ability to achieve significantly better performance for general-purpose tasks (let's call that "branchy code") with low-level languages today is more myth than reality.

Pieces of broken glass are very suitable for GPU raytracing, because rendering them is not a "branchy" task since there is no scattering, only definite reflection/refraction.

"Profile and fix the hotspots" without simultaneously thinking about architecture can yield a mass of uniformly slow branchy code with no path forward.

Branchy or code with random memory access patterns is likely to have nearly no performance gain.