using unsafe in IComponentData structs

I have a large IComponentData struct with over 30 floats that I want to iterate using index. I see that float4 has this capability but is made with unsafe code. What are the potential side effect of using unsafe in this context? Since float4 has unsafe keyword in it I assume it will be fine?

 

unsafe = give up c# safety mechanism, such as null and bounds check.
a bug in unsafe code may crash your app or corrupt it in strange ways.

e.g. you can define 30 fields and access *(&this + 40) in unsafe code. the runtime will not do the checks for you.

 

"unsafe" kinda loses its meaning when you are using HPC# If I'm not mistaken, quite a lot of the ECS framework and Burst uses it.

I wouldn't worry about using float4 at all, but you should worry if you have to write any code yourself that uses the unsafe keyword.

 

Since ECS and burst already uses unsafe keyword, would I be locked out of deploying on certain platforms when I use it as well? I am not that worried about bugs as this is the only instance where I deem unsafe necessary.

 

No. Use unsafe whenever you want, just don't make your application crash.

 

Afaik that would only happen when running on a runtime like the .NET CLR, which Unity is not

 

To avoid this, I generally make use of Span<T> to ensure that accesses to the fields don't go out of bounds:

Code (CSharp):

1.  
2. // The 'unsafe' modifier, when present on a signature, doesn't actually prevent
3. // you from using a struct, class or method from safe code, as one would expect.
4. unsafe struct Example
5. {
6.     fixed float thirtyFloats[30];
7.     public Span<float> ThirtyFloats => CreateSpan(ref thirtyFloats[0], 30);
8. }
9.  
10. // CreateSpan is a custom implementation of MemoryMarshal.CreateSpan, as
11. // it isn't available in .NET Standard 2.0, only the upcoming 2.1 version.
12.  
13. // These custom implementations of CreateSpan and CreateReadOnlySpan
14. // require that you can use System.Runtime.CompilerServices.Unsafe.
15.  
16. [MethodImpl(MethodImplOptions.AggressiveInlining)]
17. public static unsafe Span<T> CreateSpan<T>(ref T reference, int length)
18.     => new Span<T>(Unsafe.AsPointer(ref reference), length);
19.  
20. [MethodImpl(MethodImplOptions.AggressiveInlining)]
21. public static unsafe ReadOnlySpan<T> CreateReadOnlySpan<T>(ref T reference, int length)
22.     => new ReadOnlySpan<T>(Unsafe.AsPointer(ref reference), length);