Burst silently failing to create static readonly field

The short of it is Burst appears to fail to properly initialize static readonly structs that reference other structs that are created with implicit casts. Not only fails but fails silently and leaves the values uninitialized. Below is a simple code sample that shows the failure.

Code (CSharp):

1. using Unity.Burst;
2. using Unity.Collections;
3. using Unity.Jobs;
4. using UnityEngine;
5.  
6. public class TestStaticReadonly : MonoBehaviour
7. {
8.     // This value eq
9.     private static readonly CustomStruct READONLY_FIELD = CustomStruct.VALUE;
10.  
11.     private struct CustomStruct
12.     {
13.         // Specifically appears to have to do with the implicit cast!
14.         public static readonly CustomStruct VALUE = 5;
15.    
16.         // Below works just fine!
17.         // public static readonly CustomStruct VALUE = new CustomStruct(5);
18.    
19.         public int internalValue;
20.  
21.         public CustomStruct(int internalValue)
22.         {
23.             this.internalValue = internalValue;
24.         }
25.  
26.         public static implicit operator CustomStruct(int value)
27.         {
28.             return new CustomStruct(value);
29.         }
30.     }
31.  
32.     private struct Job : IJob
33.     {
34.         public NativeArray<int> result;
35.    
36.         public void Execute()
37.         {
38.             result[0] = READONLY_FIELD.internalValue;
39.         }
40.     }
41.  
42.     [BurstCompile]
43.     private struct BurstJob : IJob
44.     {
45.         public NativeArray<int> result;
46.    
47.         public void Execute()
48.         {
49.             result[0] = READONLY_FIELD.internalValue;
50.         }
51.     }
52.  
53.     private void Update()
54.     {
55.         NativeArray<int> result = new NativeArray<int>(1, Allocator.TempJob);
56.    
57.         Job job = new Job();
58.         job.result = result;
59.    
60.         job.Schedule().Complete();
61.    
62.         // Prints 5
63.         Debug.Log("Regular Job: " + result[0]);
64.  
65.         result[0] = 0;
66.    
67.         BurstJob burstJob = new BurstJob();
68.         burstJob.result = result;
69.    
70.         burstJob.Schedule().Complete();
71.    
72.         // Prints 0 but we're expecting 5
73.         Debug.Log("Burst Job: " + result[0]);
74.    
75.         result.Dispose();
76.     }
77. }

Is this a known issue? The work around appears to not do implicit casts which I can probably find all instances and resolved but it'll be a VERY easy miss. I do have safety checks on and I put on synchronous compiling cause otherwise the burst job DOES return 5 until the compiling is done.

I'm currently on Unity 2019.3.0b5

*EDIT* The issue appears to be more nuanced. Removing the implicit cast in my project code still left a static readonly uninitialized.

Thanks!

 

I was on the latest verified (1.1.2)

Updating to 1.2.0-preview.5 resolved that sample script I supplied (1.1.3-preview.1 did not). However for my actual project 1.2.0-preview.5 introduced a lot of instability with Burst.

If I use Burst with synchronous compilation then the editor crashes when I hit play (going to the editor log doesn't give any real information).

If I use Burst with asynchronous compilation then once the jobs finish compiling they throw a bunch of IndexOutOfRange exceptions (I assume with NativeArrays that are used by the job but currently unconfirmed).

If I don't use Burst then everything works fine.

Is that version just considered unstable? In that case turning off burst for now until the static readonly version becomes stable is an option.

 

The only thing I changed in this test was upgrading burst from 1.1.2 to 1.2.0-preview.5.

I'll see if I can isolate a reproduction and share the script.

 

I've identified the cause of the issues in my primary project but it fails to cause a problem by itself in a fresh project. Since I've fixed it in the primary project I'm gonna have to move on from trying to get it to fail in the fresh project. However here's what I was doing. I was using unsafe pointers in order to keep a list of sorts. Without burst and before 1.2.0-preview.5 this functioned correctly but it's what is causing the errors in the burst preview. Below is the code that I tried to get to fail in the fresh project.

Code (CSharp):

1. using Unity.Burst;
2. using Unity.Collections;
3. using Unity.Jobs;
4. using Unity.Mathematics;
5. using UnityEngine;
6. using UnityEngine.Assertions;
7. using Debug = UnityEngine.Debug;
8.  
9. public class TestBurstJobException : MonoBehaviour
10. {
11.     internal struct UnsafeEntry
12.     {
13.         public byte entryCount;
14.  
15.         public int2 entry1;
16.         public int2 entry2;
17.         public int2 entry3;
18.         public int2 entry4;
19.  
20.         public unsafe void AddEntry(int2 entry)
21.         {
22.             Assert.IsTrue(entryCount < 4);
23.  
24.             fixed (UnsafeEntry* pMe = &this)
25.             {
26.                 int2* start = (int2*) (((byte*) pMe) + sizeof(byte));
27.                 *(start + entryCount) = entry;
28.             }
29.  
30.             entryCount++;
31.         }
32.  
33.         public unsafe int2 GetEntry(int index)
34.         {
35.             fixed (UnsafeEntry* pMe = &this)
36.             {
37.                 int2* start = (int2*) (((byte*) pMe) + sizeof(byte));
38.                 return *(start + index);
39.             }
40.         }
41.     }
42.    
43.     [BurstCompile]
44.     private struct MyJob : IJob
45.     {
46.         public UnsafeEntry entry;
47.  
48.         [ReadOnly]
49.         public NativeArray<int> entries;
50.  
51.         public NativeArray<int> result;
52.  
53.         public int width;
54.        
55.         public void Execute()
56.         {
57.             int r = 0;
58.  
59.             for (int i = 0; i < entry.entryCount; i++)
60.             {
61.                 int2 e = entry.GetEntry(i);
62.                 r += entries[e.x + e.y * width];
63.             }
64.  
65.             result[0] = r;
66.         }
67.     }
68.  
69.     private void Update()
70.     {
71.         int size = 100;
72.        
73.         NativeArray<int> entries = new NativeArray<int>(size * size, Allocator.TempJob);
74.        
75.         int2 e1 = new int2(0, 0);
76.         int2 e2 = new int2(98, 23);
77.         int2 e3 = new int2(50, 50);
78.  
79.         entries[e1.x + e1.y * size] = 1;
80.         entries[e2.x + e2.y * size] = 2;
81.         entries[e3.x + e3.y * size] = 3;
82.        
83.         UnsafeEntry myS = new UnsafeEntry();
84.         myS.AddEntry(e1);
85.         myS.AddEntry(e2);
86.         myS.AddEntry(e3);
87.  
88.         MyJob job = default;
89.         job.entries = entries;
90.         job.entry = myS;
91.         job.width = size;
92.         job.result = new NativeArray<int>(1, Allocator.TempJob);
93.        
94.         job.Schedule().Complete();
95.        
96.         Debug.Log(job.result[0]);
97.        
98.         job.result.Dispose();
99.         entries.Dispose();
100.     }
101. }

Oddly enough (to me) the entry struct has bogus data when setting (according to the debugger) but correct data when pulling data out. I don't know why? And don't have the memory tools to dig deeper.

 

Yep see that now (Marsh.OffsetOf is a pretty decent debug function!). I fixed the issue in my primary project by leveraging the UnsafeUtility functions instead of directly doing the pointer math myself and that resolved the Burst exceptions (which I still couldn't get to reproduce in a fresh project).

Good to note that how the fields are laid out in memory may not necessarily match how are typed out in the struct (and I can imagine some potential frustrating issues using NativeArray.Reinterpret though looks like it does a size safety check). What's the general suggested guidelines there if we do find ourselves needing to play a little closer to the metal? If you're doing some memory specific stuff to use LayoutKind.Explicit and enforce offsets?

Thanks for the assistance!

 

I'll take a look at those!

Thanks for the tips