Burst static restrictions

I'm curious what the intent is with static fields and methods generally, so I don't go off creating something that just gets broken later on.

We need static to keep encapsulation with jobs. Jobs need to be able work against larger abstractions that exist outside of a specific job, or even outside of ECS. Currently proper encapsulation and code reuse is more painful then it should be.

When I say we need static, that's until/if we get a better solution provided. It's not terribly difficult to get around these restrictions, but I don't think the value of stopping stupid from being stupid outweighs forcing us to either write bad code or do an end run around the constraints. But honestly I don't know what the intent here is. Like for all I know this could be a technical constraint or hard problem with burst.

 

Do you mean specifically Burst or threaded Jobs? If for Jobs (and in effect for Burst also) the intent is here : https://github.com/Unity-Technologi...ystem.md#do-not-access-static-data-from-a-job

 

Well burst is the only place it's enforced right now that I can tell. And not all cases are equal.

So the problem isn't really per say blocking statics. They are just the only good simple solution right now. I'm fine with no statics as long as there is some other good way around the problem.

It prevents you from encapsulating logic with data that lives in containers and then using that from inside a job. So you have one of two choices when that encapsulation is something you want to use in multiple locations one of them being a job. You duplicate code or you break encapsulation. One of the two take your choice.

IMO I think they do care about this, but they likely care more about stupid accessing Monobehaviour from a job. But that leaves professionals out in the cold kind of, or at least doing end runs around the current constraints. Which isn't difficult to do I just hate going there.

 

Thanks for the reply on this it really does help with structuring code knowing the full story here. Makes more sense now also.

 

talking about constant folding, burst should handle const too !

 

@xoofx How is accessing static readonly managed arrays supposed to work? Would it pin the data before running the job?

 

Hi! Does this rule out assigning a static readonly variable in a static constructor, like this?

Code (CSharp):

1. public static class FooUtility
2. {
3.     private readonly static EntityArchetype fooArchetype;
4.  
5.     static FooUtility()
6.     {
7.         fooArchetype = World.Active.EntityManager.CreateArchetype(ComponentType.ReadWrite<Foo>());
8.     }
9.  
10.     public void FooUtilityMethod()
11.     {
12.         // uses fooArchetype so the user doesn't have to pass it in, avoids user error, etc.
13.     }
14. }

Since you don't actually reference the allocation, does that limit the usage of readonly statics to inline-assigned constants?

 

Please do have a look at Shared Static. It will let you read and write static values.

https://docs.unity3d.com/Packages/com.unity.burst@1.2/manual/index.html#shared-static
Here is what i did come up with with this:

Code (CSharp):

1. using Unity.Burst;
2. using Unity.Entities;
3. using Unity.Mathematics;
4.  
5. public class HapticsSystem : SystemBase
6. {
7.     public static void ShakeHands (float shakeDuration, float shakeStrength, float currentTime)
8.     {
9.         HapticsMutableStaticData.Field.Data.shakeTill = currentTime + shakeDuration;
10.         HapticsMutableStaticData.Field.Data.shaking = true;
11.         Vibration.Vibrate(shakeStrength);
12.  
13.     }
14.     protected override void OnUpdate ()
15.     {
16.         if (HapticsMutableStaticData.Field.Data.shaking && Time.ElapsedTime > HapticsMutableStaticData.Field.Data.shakeTill)
17.         {
18.             Vibration.Vibrate(0);
19.             HapticsMutableStaticData.Field.Data.shaking = false;
20.         }
21.     }
22. }
23.  
24. public abstract class HapticsMutableStaticData
25. {
26.     public struct HapticsData
27.     {
28.         public bool shaking;
29.         public float shakeTill;
30.     }
31.     public static readonly SharedStatic<HapticsData> Field = SharedStatic<HapticsData>.GetOrCreate<HapticsMutableStaticData, DataFieldKey>();
32.     private class DataFieldKey {}
33. }

 

Looks great , how to use that with arrays ? Seems like its not supported atm ?

Code (CSharp):

1. Invalid managed type found for `Unity.Collections.NativeArray`1<Unity.Mathematics.int2>&` as a generic argument of the struct `Unity.Burst.SharedStatic`1<Unity.Collections.NativeArray`1<Unity.Mathematics.int2>>`.: the type `ref Unity.Collections.NativeArray`1<Unity.Mathematics.int2>` is a managed type and  is not supported

For the following :

Code (CSharp):

1. public abstract class TableData
2. {
3.     private class UVOffsetsKey { }
4.     public static readonly SharedStatic<NativeArray<int2>> UVOffsets
5.         = SharedStatic<NativeArray<int2>>.GetOrCreate<TableData, UVOffsetsKey>();
6.  
7.     static TableData()
8.     {
9.         UVOffsets.Data = new NativeArray<int2>(new int2[] {
10.  
11.                 new int2( 0, 1 ) ,  //  0 ------ 1
12.                 new int2( 1, 1 ) ,  //  |        |
13.                 new int2( 1, 0 ) ,  //  |        |
14.                 new int2( 0, 0 ) ,  //  3 ------ 2
15.  
16.         }, Allocator.Persistent);
17.     }
18. }
19.  
20. public static class TableDataOld
21. {
22.     public static readonly int[] UVOffsets =
23.     {
24.         0, 1  , //  0 ------ 1
25.         1, 1  , //  |        |
26.         1, 0  , //  |        |
27.         0, 0  , //  3 ------ 2
28.     };
29. }

 

Currently

NativeArray 

internally has managed

DisposeSentinel

, so it cannot be used in SharedStatic. Maybe you can use

UnsafeList<T>

or

FixedListBytesXXX<T>

instead?