AsyncGPUReadback.RequestIntoNativeArray causes InvalidOperationException on NativeArray

I tried another approach: create a nativearray each AsyncGPUReadback.RequestIntoNativeArray call but when i can't deallocate this data, i got this error:

InvalidOperationException: The Unity.Collections.NativeArray`1[System.Byte] has been set to undisposable and cannot be deallocated. 

Code (CSharp):

1.  
2.             Debug.Log("create request");
3.             NativeArray<byte> buffer = new NativeArray<byte>(w * h * 16, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
4.  
5.             AsyncGPUReadbackRequest request = AsyncGPUReadback.RequestIntoNativeArray(ref buffer, rt);
6.             float acc = 0;
7.             while (!request.done && acc < 1f)
8.             {
9.                 acc += Time.deltaTime;
10.                 yield return null;
11.             }
12.  
13.             OnReadbackComplete(request);
14.             buffer.Dispose();
15.  
16.             Debug.Log("release request");

Any help is very welcome.

 

Thank you so much, I made it work with something like this

Code (CSharp):

1.         private Queue<NativeArray<byte>> buffers;
2.  

 

This issue is still happening on 2022.2.1f1.

Code (CSharp):

1. NativeArray<float> floatArray = new NativeArray<float>(floatBuffer.count, Allocator.Persistent);
2. NativeArray<States> statesArray = new NativeArray<States>(statesBuffer.count, Allocator.Persistent);
3.  
4. // Requests from GPU to CPU
5. AsyncGPUReadbackRequest[] requests = new AsyncGPUReadbackRequest[]
6. {
7. AsyncGPUReadback.RequestIntoNativeArray(ref floatArray, floatBuffer),
8. AsyncGPUReadback.RequestIntoNativeArray(ref statesArray, statesBuffer),
9. };
10.  
11. while (!requests.All(x => x.done))
12. {
13.     yield return null;
14. }
15.  
16. // Processes GPU data
17. if (!requests.Any(x => x.hasError))
18. {
19.     // Try and access any of the created native arrays. Errors out
20. }

This code also leads to "InvalidOperationException: NativeArray can no longer be accessed, since its owner has been invalidated."

Definitely doesn't seem to be the case from the example above, so https://issuetracker.unity3d.com/is...uses-invalidoperationexception-on-nativearray isn't properly fixed unless I'm misunderstanding something.

 

Suffering from it as well, in 2022.2.10.

OK, I solved it for now, but not sure if this will suit everybody.

I am using the readback for objectpicking (using colors as ID). It seems you cannot execute the readbacks in an (Late)Update and wait for the request to finish. The request might happen before the other is finished. Indeed, similar someone else mentioned a bit earlier.

I just solved it using a boolean check, setting it to false if the event is triggered - and then a new request is allowed to be made (setting the bool to true). In my case I do not want to deal with queues, it is not needed anyway.

 

Bump.
Still a problem in 2022.2.8f1. It only happens when a request into a native array is made before a previous request has been resolved, as mentioned above. Is this a bug or is it not supported to queue multiple requests like this?

 

Hi, thank you for replying.
I have submitted a bug report 36698, though my case seems to be a bit more specific than I originally thought.

Basically AsyncGPUReadback.RequestIntoNativeArray causes an InvalidOperationException when requesting data into a NativeArray created with NativeArray.GetSubArray.

AsyncGPUReadback.Request works normally, but then you have to do an extra array copy, so while it works it would be nice to get this fixed.
Thanks

 

Turns out its a bug.
https://issuetracker.unity3d.com/is...g-asyncgpureadback-dot-requestintonativearray

 

And now we need to wait around 6 months to get a fix into latest stable version of Unity. Which is better than nothing, thanks for reporting!

 

I'm still getting this error in 2021.3.15f1. Is it possible that this failed to be ported from 2021.2 to 2021.3?

 

Still happening in 2022.3.5f1

Odd thing is that it is not easily reproducible. I tried opening a project (exact same unity version + exact same code), that does some compute shader stuff and reads it back, no errors, everything works fine. Now if I open a second project with the exact same code, version, etc, and execute it, bunch of those errors pop up (yet it still functions normally, the data is read back fine)

 

We see this happening in 2022.3.3f1 (to be honest the error has been following us through all version we've updated, since back 2021).

Our flow is pretty simple and we have two code paths that throw the same error (NativeArray does not have read/write access and NativeArray should not be undisposable) which are very much the same:

- Create persistent NativeArray (only once);
- Call AsyncGPUReadback.RequestIntoNativeArray;
- Wait for completion;
- Create and schedule a job that reads from the array (after that gpu request is done);
- Run the job, call complete on the job handle (the job transfers the data from the nativearray into a different one, so the usage cycle of the nativearray used for gpu request ends here).

The sequence above executes with no errors for the first pass, but when it is called again (the buffer stays the same, its purpose is to perform these requests and job processing repeatedly using the pre-allocated memory), the specified errors are thrown when the array is touched by the gpu async request.

 

Thanks! I was aware of a few of the issues targeting this bug but this one eluded me.

 

I just ran into this bug. So, until this is fixed, is there any difference between pre-allocating a NativeArray and calling AsyncGPUReadback.RequestIntoNativeArray with a reference to it, vs. just calling AsyncGPUReadback?

It seems it is inevitable to allocate new memory every time you want to do a readback?

 

In docs it says
output - Reference to the NativeArray to write the data into. The NativeArray or underlying memory cannot be Disposed until the request is complete.

So if RequestIntoNativeArray "locks" the NativeArray passed to it, how does one Dispose on editor play stop? Is the intended solution just to ignore the editor leaks? Is there a way to stop RequestIntoNativeArray request while it's happening, unlocking the array?

 

Appears like the issue in https://issuetracker.unity3d.com/is...g-asyncgpureadback-dot-requestintonativearray was rejected, but it seems like the reason for it was that Unity thinks this issue only happens with arrays such that a async readback was requested multiple times in a single frame, however this issue still happens even when I request readbacks that aren't happening concurrently.