/// <summary>
/// Safely disposes of this container and deallocates its memory when the jobs that use it have completed.
/// </summary>
/// <remarks>You can call this function dispose of the container immediately after scheduling the job. Pass
/// the [JobHandle](https://docs.unity3d.com/ScriptReference/Unity.Jobs.JobHandle.html) returned by
/// the [Job.Schedule](https://docs.unity3d.com/ScriptReference/Unity.Jobs.IJobExtensions.Schedule.html)
/// method using the `jobHandle` parameter so the job scheduler can dispose the container after all jobs
/// using it have run.</remarks>
/// <param name="dependency">All jobs spawned will depend on this JobHandle.</param>
/// <returns>A new job handle containing the prior handles as well as the handle for the job that deletes
/// the container.</returns>
public JobHandle Dispose(JobHandle dependency)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
// [DeallocateOnJobCompletion] is not supported, but we want the deallocation
// to happen in a thread. DisposeSentinel needs to be cleared on main thread.
// AtomicSafetyHandle can be destroyed after the job was scheduled (Job scheduling
// will check that no jobs are writing to the container).
DisposeSentinel.Clear(ref m_DisposeSentinel);
#endif
var jobHandle = m_Stream.Dispose(dependency);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.Release(m_Safety);
#endif
return(jobHandle);
}
/// <summary>
/// Safely disposes of this container and deallocates its memory when the jobs that use it have completed.
/// </summary>
/// <remarks>You can call this function dispose of the container immediately after scheduling the job. Pass
/// the [JobHandle](https://docs.unity3d.com/ScriptReference/Unity.Jobs.JobHandle.html) returned by
/// the [Job.Schedule](https://docs.unity3d.com/ScriptReference/Unity.Jobs.IJobExtensions.Schedule.html)
/// method using the `jobHandle` parameter so the job scheduler can dispose the container after all jobs
/// using it have run.</remarks>
/// <param name="jobHandle">The job handle or handles for any scheduled jobs that use this container.</param>
/// <returns>A new job handle containing the prior handles as well as the handle for the job that deletes
/// the container.</returns>
public JobHandle Dispose(JobHandle inputDeps)
{
// [DeallocateOnJobCompletion] is not supported, but we want the deallocation
// to happen in a thread. DisposeSentinel needs to be cleared on main thread.
// AtomicSafetyHandle can be destroyed after the job was scheduled (Job scheduling
// will check that no jobs are writing to the container).
DisposeSentinel.Clear(ref m_DisposeSentinel);
var jobHandle = new DisposeJob {
Container = this
}.Schedule(inputDeps);
AtomicSafetyHandle.Release(m_Safety);
m_Buffer = null;
m_Length = 0;
return(jobHandle);
}
/// <summary>
/// Safely disposes of this list and deallocates its memory when the jobs that use it have completed.
/// </summary>
/// <remarks>You can call this function dispose of the list immediately after scheduling the job. Pass
/// the [JobHandle](https://docs.unity3d.com/ScriptReference/Unity.Jobs.JobHandle.html) returned by
/// the [Job.Schedule](https://docs.unity3d.com/ScriptReference/Unity.Jobs.IJobExtensions.Schedule.html)
/// method using the `jobHandle` parameter so the job scheduler can dispose the list after all jobs
/// using it have run.</remarks>
/// <param name="jobHandle">The job handle or handles for any scheduled jobs that use this list.</param>
/// <returns>A new job handle containing the prior handles as well as the handle for the job that deletes
/// the list.</returns>
public JobHandle Dispose(JobHandle jobHandle)
{
// [DeallocateOnJobCompletion] is not supported, but we want the deallocation to happen in a thread.
// DisposeSentinel needs to be cleared on main thread.
// AtomicSafetyHandle can be destroyed after the job was scheduled (Job scheduling will check that no jobs are writing to the container)
#if ENABLE_UNITY_COLLECTIONS_CHECKS
DisposeSentinel.Clear(ref m_DisposeSentinel);
#endif
var jobData = new DisposeListJob {
List = this
};
jobHandle = jobData.Schedule(jobHandle);
m_ListData = null;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.Release(m_Safety);
#endif
return(jobHandle);
}
public JobHandle Dispose(JobHandle inputDeps)
{
bool flag = this.m_AllocatorLabel == Allocator.Invalid;
if (flag)
{
throw new InvalidOperationException("The NativeArray can not be Disposed because it was not allocated with a valid allocator.");
}
bool flag2 = this.m_Buffer == null;
if (flag2)
{
throw new InvalidOperationException("The NativeArray is already disposed.");
}
bool flag3 = this.m_AllocatorLabel > Allocator.None;
JobHandle result;
if (flag3)
{
DisposeSentinel.Clear(ref this.m_DisposeSentinel);
JobHandle jobHandle = new NativeArrayDisposeJob
{
Data = new NativeArrayDispose
{
m_Buffer = this.m_Buffer,
m_AllocatorLabel = this.m_AllocatorLabel,
m_Safety = this.m_Safety
}
}.Schedule(inputDeps);
AtomicSafetyHandle.Release(this.m_Safety);
this.m_Buffer = null;
this.m_Length = 0;
this.m_AllocatorLabel = Allocator.Invalid;
result = jobHandle;
}
else
{
this.m_Buffer = null;
this.m_Length = 0;
result = inputDeps;
}
return(result);
}
public JobHandle Dispose(JobHandle inputDeps)
{
if (m_Buffer == null)
{
return(inputDeps);
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
DisposeSentinel.Clear(ref m_DisposeSentinel);
#endif
var jobHandle = new DisposeJob {
Container = this
}.Schedule(inputDeps);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.Release(m_Safety);
#endif
m_Buffer = null;
return(jobHandle);
}
public JobHandle ScheduleDispose(JobHandle inputDeps)
{
// [DeallocateOnJobCompletion] is not supported, but we want the deallocation to happen in a thread.
// DisposeSentinel needs to be cleared on main thread.
// AtomicSafetyHandle can be destroyed after the job was scheduled
#if ENABLE_UNITY_COLLECTIONS_CHECKS
DisposeSentinel.Clear(ref m_DisposeSentinel);
#endif
var jobHandle = new DisposeJob {
BlockStream = this
}.Schedule(inputDeps);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.Release(m_Safety);
#endif
m_Block = null;
return(jobHandle);
}
public JobHandle Dispose(JobHandle inputDeps)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
// [DeallocateOnJobCompletion] is not supported, but we want the deallocation
// to happen in a thread. DisposeSentinel needs to be cleared on main thread.
// AtomicSafetyHandle can be destroyed after the job was scheduled (Job scheduling
// will check that no jobs are writing to the container).
DisposeSentinel.Clear(ref m_DisposeSentinel);
var jobHandle = new UnsafeDisposeJob {
vertices = m_Vertices, chainedIndices = m_ChainedIndices, hashTable = m_HashTable, allocator = m_AllocatorLabel
}.Schedule(inputDeps);
AtomicSafetyHandle.Release(m_Safety);
#else
var jobHandle = new UnsafeDisposeJob {
vertices = m_Vertices, chainedIndices = m_ChainedIndices, hashTable = m_HashTable, allocator = m_AllocatorLabel
}.Schedule(inputDeps);
#endif
return(jobHandle);
}
public JobHandle Dispose(JobHandle dependsOn)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
DisposeSentinel.Clear(ref m_DisposeSentinel);
var jobHandle = new NativeArrayViewHandleDisposeJob
{
Data = new NativeArrayViewHandleDispose(m_GCHandle, m_Safety),
}
.Schedule(dependsOn);
AtomicSafetyHandle.Release(m_Safety);
return(jobHandle);
#else
return(new NativeArrayViewHandleDisposeJob
{
Data = new NativeArrayViewHandleDispose(m_GCHandle),
}
.Schedule(dependsOn));
#endif
}
public JobHandle Dispose(JobHandle inputDeps)
{
if (m_AllocatorLabel == Allocator.Invalid)
{
throw new InvalidOperationException("The NativeArray can not be Disposed because it was not allocated with a valid allocator.");
}
if (m_Buffer == null)
{
throw new InvalidOperationException("The NativeArray is already disposed.");
}
if (m_AllocatorLabel > Allocator.None)
{
// [DeallocateOnJobCompletion] is not supported, but we want the deallocation
// to happen in a thread. DisposeSentinel needs to be cleared on main thread.
// AtomicSafetyHandle can be destroyed after the job was scheduled (Job scheduling
// will check that no jobs are writing to the container).
DisposeSentinel.Clear(ref m_DisposeSentinel);
var jobHandle = new NativeArrayDisposeJob {
Data = new NativeArrayDispose {
m_Buffer = m_Buffer, m_AllocatorLabel = m_AllocatorLabel, m_Safety = m_Safety
}
}.Schedule(inputDeps);
AtomicSafetyHandle.Release(m_Safety);
m_Buffer = null;
m_Length = 0;
m_AllocatorLabel = Allocator.Invalid;
return(jobHandle);
}
m_Buffer = null;
m_Length = 0;
return(inputDeps);
}
public JobHandle Dispose(JobHandle inputDeps)
{
CheckNotDisposed();
if (CollectionHelper.ShouldDeallocate(m_AllocatorLabel))
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
// [DeallocateOnJobCompletion] is not supported, but we want the deallocation
// to happen in a thread. DisposeSentinel needs to be cleared on main thread.
// AtomicSafetyHandle can be destroyed after the job was scheduled (Job scheduling
// will check that no jobs are writing to the container).
DisposeSentinel.Clear(ref m_DisposeSentinel);
#endif
var jobHandle = new NativeReferenceDisposeJob
{
Data = new NativeReferenceDispose
{
m_Data = m_Data,
m_AllocatorLabel = m_AllocatorLabel,
#if ENABLE_UNITY_COLLECTIONS_CHECKS
m_Safety = m_Safety
#endif
}
}.Schedule(inputDeps);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.Release(m_Safety);
#endif
m_Data = null;
m_AllocatorLabel = Allocator.Invalid;
return(jobHandle);
}
m_Data = null;
return(inputDeps);
}
/// <summary>
/// Schedule a job to release the set's unmanaged memory after the given
/// dependency jobs. Do not use it after this job executes. Do
/// not call <see cref="Dispose()"/> on copies of the set either.
///
/// This operation requires write access.
///
/// This complexity of this operation is O(1) plus the allocator's
/// deallocation complexity.
/// </summary>
public JobHandle Dispose(JobHandle inputDeps)
{
RequireWriteAccess();
#if ENABLE_UNITY_COLLECTIONS_CHECKS
// Clear the dispose sentinel, but don't Dispose it
DisposeSentinel.Clear(ref m_DisposeSentinel);
#endif
// Schedule the job
DisposeJob disposeJob = new DisposeJob {
Set = this
};
JobHandle jobHandle = disposeJob.Schedule(inputDeps);
// Release the atomic safety handle now that the job is scheduled
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.Release(m_Safety);
#endif
m_State = null;
return(jobHandle);
}
public unsafe JobHandle Dispose(JobHandle inputDeps)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
DisposeSentinel.Clear(ref m_DisposeSentinel);
#endif
JobHandle jobHandle = new TypeHandleArrayDisposeJob()
{
DisposeJobData = new TypeHandleArrayDisposeJobData()
{
m_Buffer = m_Buffer,
m_AllocatorLabel = m_AllocatorLabel,
#if ENABLE_UNITY_COLLECTIONS_CHECKS
m_Safety = m_Safety
#endif
}
}.Schedule(inputDeps);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.Release(m_Safety);
#endif
m_Buffer = (void *)null;
m_Length = 0;
return(jobHandle);
}
public void Dispose()
{
DisposeSentinel.Clear(ref m_DisposeSentinel);
}