Question What is the recommended way to copy large arrays as input into job structs?

Code (CSharp):

1.  
2. [BurstCompile]
3. struct MyJob : IJob {
4.  
5.    [ReadOnly] NativeArray<float3> datapoints; // this is a large array
6.    [WriteOnly] NativeArray<float3> results; // this is also large array
7.  
8.    public void Execute() {
9.       // blah
10.    }
11. }

Give the above job with large arrays, what is the most efficient way to copy the data to/from C# managed collections within the main thread?

If datapoints is the same for every Execute(), how can I avoid copying the input data so that all jobs to reference the same set of datapoints?

Thanks.

 

Most efficient is to not copy them at all. Use [same] native collections for both with Allocator.Persistent.

Just in case, native collections aren't deep copied when used like:

Code (CSharp):

1. NativeArray<float3> someArr;
2. NativeArray<float3> refCopy = someArr;

Only pointers inside struct are copied. Native containers are value types that act like a reference type. So there's no major overhead when copying "reference" to the container.

 

Mark data as dirty, when data changes. And process data only then.

You could even collect, which index has changed, and update only changed indexes.

On side note, you can iterate in parallel for job, to process arrays.

As long collections are unmanaged, you should be fine using burst. Which adds to the process speed.

There are also there ways, but unable to give of top of my head. Others will add comments perhaps.

 

Thanks @xVergilx will go for Allocator.Persistent for the shared data.

I am writing new jobs to be used with some existing libraries. For example, on the main thread the data structure is float[,] but the result from the job is NativeArray<float> I don't know any way to copy the data between the data structures for than a brute for nested for-loop. Any advice?

@Antypodish the shared datapoints is the same but the result will be different based on other input params (not shown in example). Good thing is datapoints will be readonly.

 

Copying two-dimensional managed array to native array is a bit more tricky.
NativeArray implementation of CopyFrom looks like this:
- CopyFrom ->
- Length equality check first then;
- CopySafe call:

Code (CSharp):

1.       private static unsafe void CopySafe(T[] src, int srcIndex, NativeArray<T> dst, int dstIndex, int length) {
2.          AtomicSafetyHandle.CheckWriteAndThrow(dst.m_Safety);
3.          NativeArray<T>.CheckCopyPtr(src);
4.          NativeArray<T>.CheckCopyArguments(src.Length, srcIndex, dst.Length, dstIndex, length);
5.          GCHandle gcHandle = GCHandle.Alloc((object) src, GCHandleType.Pinned);
6.          IntPtr num = gcHandle.AddrOfPinnedObject();
7.          UnsafeUtility.MemCpy((void*) ((IntPtr) dst.m_Buffer + dstIndex * UnsafeUtility.SizeOf<T>()),
8.                               (void*) ((IntPtr) (void*) num + srcIndex * UnsafeUtility.SizeOf<T>()),
9.                               (long) (length * UnsafeUtility.SizeOf<T>()));
10.          gcHandle.Free();
11.       }

Basically its a MemCpy.

Multidimensional arrays should be layout out in the same data block row-major order.
https://stackoverflow.com/questions/73368641/how-are-multi-dimensional-arrays-stored-net

So, make a NativeArray<float2>.
Add a test for the two arrays values first with brute-force copy to have something to compare MemCpy based copy against. Then figure out the length of required data, do a copy and in theory it should boil down to something like:

Code (CSharp):

1. // where T == float2 or unmanaged
2. // Optionally add length comparison check / throw first
3.          int byteLength = managedArrayLength * UnsafeUtility.SizeOf<T>();
4.          void* managedBuffer = UnsafeUtility.AddressOf(ref array[0,0]);
5.          void* nativeBuffer = nativeArray.GetUnsafePtr();
6.  
7.          UnsafeUtility.MemCpy(managedBuffer, nativeBuffer, byteLength);

If you want to copy back from NativeArray to managed array - swap src / dst params for the MemCpy.

 

Sometimes it's useful to create a NativeArray that is just a pointer to the managed array data (with some changes you might be able to get this to work with 2D arrays as well, AFAIK they're stored in memory as a contiguous block):
https://github.com/Per-Morten/UnityUtilities/blob/main/ViewAsNativeArrayExtensions.cs