What's the benefit of Burst compiling ISystem struct?

[danielkanda]

In our codebase we have ISystem structs where we add the [BurstCompile] attribute to OnCreate/OnUpdate/OnDestroy callbacks where possible.

I always assumed that if I added [BurstCompile] to the system struct that meant that all methods inside would also be Burst compiled, but based on some quick testing that does not appear to be the case.

This begs the question, what is the benefit of also adding the [BurstCompile] attribute to the system itself? And if I have some system callbacks that are not Burstable, does this cause an issue?

[Spy-Master]

When, where, and why to put [BurstCompile], with mild under-the-hood explanation

People are very often confused about where they should put [BurstCompile], and what gets bursted when they put it where, so I figured I’d write something up explaining everything in one place. The first two things to know, from which all else flows, but seems a bit surprising at first: Burst can only ever burst static methods, period, end of story. If you want this to happen outside of the special cases outlined below, just put [BurstCompile] on a static method and on its declaring type.* Whe…

Read the above post.

The gist for ISystem is that to have Burst-compiled callbacks OnCreate/OnUpdate/etc., you just need to add BurstCompile on the method.

For any normal Burst entry points (static methods, as instance methods aren’t supported without special things like job Execute methods and ISystem callbacks that do ultimately use static methods to wrap your instance methods), you need the attribute on both the method and the containing type. BurstCompile needs to be on the ISystem for normal Burst methods, just like any other type. The difference is that BurstCompile is added automatically behind the scenes when the system source generator creates code to support SystemAPI and entity job usages. If the system generator doesn’t produce output for the system (from the system not needing source generation), BurstCompile needs to be manually added to the type.