internal void Dispose() { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckDeallocateAndThrow(m_Safety); #endif if (m_Data != null) { EntitySharedComponentCommand *cleanup_list = m_Data->m_CleanupList; while (cleanup_list != null) { cleanup_list->BoxedObject.Free(); cleanup_list = cleanup_list->Prev; } m_Data->m_CleanupList = null; var label = m_Data->m_Allocator; while (m_Data->m_Tail != null) { var prev = m_Data->m_Tail->Prev; UnsafeUtility.Free(m_Data->m_Tail, m_Data->m_Allocator); m_Data->m_Tail = prev; } m_Data->m_Head = null; UnsafeUtility.Free(m_Data, label); m_Data = null; } }
protected void Dispose(bool disposing) { if (isCreated) { #if ENABLE_UNITY_COLLECTIONS_CHECKS // dispose of atomic safety handle: if (m_AsNativeArray) { AtomicSafetyHandle.CheckDeallocateAndThrow(m_SafetyHandle); AtomicSafetyHandle.Release(m_SafetyHandle); m_AsNativeArray = false; } #endif // dispose of compuse buffer representation: if (m_ComputeBuffer != null) { m_ComputeBuffer.Dispose(); } // free unmanaged memory buffer: UnsafeUtility.Free(m_AlignedPtr, Allocator.Persistent); m_AlignedPtr = null; } }
public static unsafe void Execute(ref T data, IntPtr listDataPtr, IntPtr bufferRangePatchData, ref JobRanges ranges, int jobIndex) { NativeParticleData particleData; var listData = (NativeListData *)listDataPtr; ParticleSystem.CopyManagedJobData(listData->system, out particleData); ParticleSystemJobData jobData = new ParticleSystemJobData(ref particleData); while (true) { int begin; int end; if (!JobsUtility.GetWorkStealingRange(ref ranges, jobIndex, out begin, out end)) { break; } JobsUtility.PatchBufferMinMaxRanges(bufferRangePatchData, UnsafeUtility.AddressOf(ref data), begin, end - begin); data.Execute(jobData, begin, end - begin); } AtomicSafetyHandle.CheckDeallocateAndThrow(jobData.m_Safety); AtomicSafetyHandle.Release(jobData.m_Safety); }
public unsafe void Dispose() { *m_Ptr = 0; Memory.Unmanaged.Free(m_Ptr, m_Allocator); AtomicSafetyHandle.CheckDeallocateAndThrow(m_Safety); AtomicSafetyHandle.Release(m_Safety); }
public void BeginExclusiveTransaction() { if (IsInTransaction) { return; } #if ENABLE_UNITY_COLLECTIONS_CHECKS for (var i = 0; i != TypeManager.GetTypeCount(); i++) { AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].SafetyHandle); AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].BufferHandle); } for (var i = 0; i != TypeManager.GetTypeCount(); i++) { AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].SafetyHandle); AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].BufferHandle); } #endif IsInTransaction = true; #if ENABLE_UNITY_COLLECTIONS_CHECKS ExclusiveTransactionSafety = AtomicSafetyHandle.Create(); #endif m_ExclusiveTransactionDependency = GetAllDependencies(); }
public unsafe static void Execute(ref T data, IntPtr listDataPtr, IntPtr bufferRangePatchData, ref JobRanges ranges, int jobIndex) { NativeListData * ptr = (NativeListData *)((void *)listDataPtr); NativeParticleData nativeParticleData; ParticleSystem.CopyManagedJobData(ptr->system, out nativeParticleData); ParticleSystemJobData particleSystemJobData = new ParticleSystemJobData(ref nativeParticleData); while (true) { int num; int num2; bool flag = !JobsUtility.GetWorkStealingRange(ref ranges, jobIndex, out num, out num2); if (flag) { break; } JobsUtility.PatchBufferMinMaxRanges(bufferRangePatchData, UnsafeUtility.AddressOf <T>(ref data), num, num2 - num); for (int i = num; i < num2; i++) { data.Execute(particleSystemJobData, i); } } AtomicSafetyHandle.CheckDeallocateAndThrow(particleSystemJobData.m_Safety); AtomicSafetyHandle.Release(particleSystemJobData.m_Safety); }
public unsafe void Dispose() { *m_Ptr = 0; UnsafeUtility.Free(m_Ptr, m_Allocator); AtomicSafetyHandle.CheckDeallocateAndThrow(m_Safety); AtomicSafetyHandle.Release(m_Safety); }
void ReleaseTemporaryHandle() { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckDeallocateAndThrow(m_TemporaryHandle); AtomicSafetyHandle.Release(m_TemporaryHandle); #endif }
public void CompleteAllJobsAndInvalidateArrays() { if (m_ComponentSafetyHandlesCount == 0) { return; } m_InvalidateArraysMarker.Begin(); for (var i = 0; i != m_ComponentSafetyHandlesCount; i++) { AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].SafetyHandle); AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].BufferHandle); } for (var i = 0; i != m_ComponentSafetyHandlesCount; i++) { if (m_ComponentSafetyHandles[i].IsSafetyHandleOwner) { AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].SafetyHandle); } AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].BufferHandle); } ClearAllTypeArrayIndices(); m_InvalidateArraysMarker.End(); }
public void Dispose() { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckDeallocateAndThrow(m_Safety); DisposeSentinel.Dispose(ref m_Safety, ref m_DisposeSentinel); #endif Deallocate(); }
public void Dispose() { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckDeallocateAndThrow(m_Safety); DisposeSentinel.Dispose(ref m_Safety, ref m_DisposeSentinel); #endif NativeHashSetData.DeallocateHashSet(buffer, allocator); buffer = null; }
public void CheckDeallocateShouldThrow() { AtomicSafetyHandle handle = AtomicSafetyHandle.Create(); AtomicSafetyHandle clone = handle; AtomicSafetyHandle.CheckDeallocateAndThrow(clone); AtomicSafetyHandle.Release(handle); Assert.Throws <InvalidOperationException>(() => AtomicSafetyHandle.CheckDeallocateAndThrow(clone)); }
public void Dispose() { AtomicSafetyHandle.CheckDeallocateAndThrow(this.m_Safety); AtomicSafetyHandle.Release(this.m_Safety); DisposeSentinel.Clear(ref this.m_DisposeSentinel); UnsafeUtility.Free(this.m_Buffer, this.m_AllocatorLabel); this.m_Buffer = IntPtr.Zero; this.m_Length = 0; }
internal void Dispose() { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckDeallocateAndThrow(m_Safety); AtomicSafetyHandle.Release(m_Safety); #endif UnsafeUtility.Free(m_Impl, Allocator.Persistent); m_Impl = null; }
public bool HasBeenDisposed() { try { AtomicSafetyHandle.CheckDeallocateAndThrow(Handle); } catch { return(true); } return(false); }
public void Dispose() { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckDeallocateAndThrow(m_Safety); if (AtomicSafetyHandle.IsTempMemoryHandle(m_Safety)) { m_Safety = AtomicSafetyHandle.Create(); } AtomicSafetyHandle.Release(m_Safety); #endif m_Impl.Dispose(); }
public unsafe static void Execute(ref T data, IntPtr listDataPtr, IntPtr unusedPtr, ref JobRanges ranges, int jobIndex) { NativeListData * ptr = (NativeListData *)((void *)listDataPtr); NativeParticleData nativeParticleData; ParticleSystem.CopyManagedJobData(ptr->system, out nativeParticleData); ParticleSystemJobData particleSystemJobData = new ParticleSystemJobData(ref nativeParticleData); data.Execute(particleSystemJobData); AtomicSafetyHandle.CheckDeallocateAndThrow(particleSystemJobData.m_Safety); AtomicSafetyHandle.Release(particleSystemJobData.m_Safety); }
public static unsafe void Execute(ref T data, IntPtr listDataPtr, IntPtr unusedPtr, ref JobRanges ranges, int jobIndex) { NativeParticleData particleData; var listData = (NativeListData *)listDataPtr; ParticleSystem.CopyManagedJobData(listData->system, out particleData); ParticleSystemJobData jobData = new ParticleSystemJobData(ref particleData); data.Execute(jobData); AtomicSafetyHandle.CheckDeallocateAndThrow(jobData.m_Safety); AtomicSafetyHandle.Release(jobData.m_Safety); }
public static unsafe void ExecuteProcessParticleSystem(ref T data, IntPtr particleSystemPtr, IntPtr unusedPtr, ref JobRanges ranges, int jobIndex) { JobDataInternal jobDataInternal; UnsafeUtility.CopyPtrToStructure((void *)particleSystemPtr, out jobDataInternal); object safetyHandle; ParticleSystemJobData jobData = new ParticleSystemJobData(ref jobDataInternal, out safetyHandle); data.ProcessParticleSystem(jobData); AtomicSafetyHandle.CheckDeallocateAndThrow((AtomicSafetyHandle)safetyHandle); AtomicSafetyHandle.Release((AtomicSafetyHandle)safetyHandle); }
public void CheckDeallocateShouldThrow() { AtomicSafetyHandle handle = AtomicSafetyHandle.Create(); AtomicSafetyHandle clone = handle; AtomicSafetyHandle.CheckDeallocateAndThrow(clone); AtomicSafetyHandle.Release(handle); #if UNITY_2020_2_OR_NEWER Assert.Throws <ObjectDisposedException>( #else Assert.Throws <InvalidOperationException>( #endif () => AtomicSafetyHandle.CheckDeallocateAndThrow(clone)); }
public unsafe bool HasBeenDisposed() { try { AtomicSafetyHandle.CheckDeallocateAndThrow(m_Safety); if (*m_Ptr == 54321) { return(false); } } catch { return(true); } return(false); }
//@TODO: Optimize as one function call to in batch bump version on every single handle... public void CompleteAllJobsAndInvalidateArrays() { if (m_HasCleanHandles) { return; } Profiler.BeginSample("CompleteAllJobsAndInvalidateArrays"); var count = TypeManager.GetTypeCount(); for (var t = 0; t != count; t++) { m_ComponentSafetyHandles[t].WriteFence.Complete(); var readFencesCount = m_ComponentSafetyHandles[t].NumReadFences; var readFences = m_ReadJobFences + t * kMaxReadJobHandles; for (var r = 0; r != readFencesCount; r++) { readFences[r].Complete(); } m_ComponentSafetyHandles[t].NumReadFences = 0; } #if ENABLE_UNITY_COLLECTIONS_CHECKS for (var i = 0; i != count; i++) { AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].SafetyHandle); AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].BufferHandle); } for (var i = 0; i != count; i++) { AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].SafetyHandle); m_ComponentSafetyHandles[i].SafetyHandle = AtomicSafetyHandle.Create(); AtomicSafetyHandle.SetAllowSecondaryVersionWriting(m_ComponentSafetyHandles[i].SafetyHandle, false); AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].BufferHandle); m_ComponentSafetyHandles[i].BufferHandle = AtomicSafetyHandle.Create(); } #endif m_HasCleanHandles = true; Profiler.EndSample(); }
public void BeginExclusiveTransaction() { for (var i = 0; i != m_ComponentSafetyHandlesCount; i++) { AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].SafetyHandle); AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].BufferHandle); } for (var i = 0; i != m_ComponentSafetyHandlesCount; i++) { AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].SafetyHandle); AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].BufferHandle); } ExclusiveTransactionSafety = AtomicSafetyHandle.Create(); ClearAllTypeArrayIndices(); }
private unsafe void HandlePositionsChangedCallback(int count, IntPtr positionsIntPtr) { if (Tilemap.tilemapPositionsChanged == null) { return; } void *positionsPtr = positionsIntPtr.ToPointer(); var positions = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <Vector3Int>(positionsPtr, count, Allocator.Invalid); var safety = AtomicSafetyHandle.Create(); NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref positions, safety); SendTilemapPositionsChangedCallback(positions); AtomicSafetyHandle.CheckDeallocateAndThrow(safety); AtomicSafetyHandle.Release(safety); }
internal void Dispose() { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckDeallocateAndThrow(m_Safety); #endif if (m_Data != null) { var label = m_Data->m_Allocator; while (m_Data->m_Tail != null) { var prev = m_Data->m_Tail->Prev; UnsafeUtility.Free(m_Data->m_Tail, m_Data->m_Allocator); m_Data->m_Tail = prev; } m_Data->m_Head = null; UnsafeUtility.Free(m_Data, label); m_Data = null; } }
//@TODO: Optimize as one function call to in batch bump version on every single handle... public void CompleteAllJobsAndInvalidateArrays() { if (m_TypeCount == 0) { return; } Profiler.BeginSample("CompleteAllJobsAndInvalidateArrays"); for (int t = 0; t < m_TypeCount; ++t) { m_ComponentSafetyHandles[t].WriteFence.Complete(); var readFencesCount = m_ComponentSafetyHandles[t].NumReadFences; var readFences = m_ReadJobFences + t * kMaxReadJobHandles; for (var r = 0; r != readFencesCount; r++) { readFences[r].Complete(); } m_ComponentSafetyHandles[t].NumReadFences = 0; } #if ENABLE_UNITY_COLLECTIONS_CHECKS for (var i = 0; i != m_TypeCount; i++) { AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].SafetyHandle); AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].BufferHandle); } for (var i = 0; i != m_TypeCount; i++) { AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].SafetyHandle); AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].BufferHandle); } #endif ClearAllTypeArrayIndices(); Profiler.EndSample(); }
public void CompleteAllJobsAndInvalidateArrays() { if (m_ComponentSafetyHandlesCount == 0) { return; } Profiler.BeginSample("InvalidateArrays"); for (var i = 0; i != m_ComponentSafetyHandlesCount; i++) { AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].SafetyHandle); AtomicSafetyHandle.CheckDeallocateAndThrow(m_ComponentSafetyHandles[i].BufferHandle); } for (var i = 0; i != m_ComponentSafetyHandlesCount; i++) { AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].SafetyHandle); AtomicSafetyHandle.Release(m_ComponentSafetyHandles[i].BufferHandle); } ClearAllTypeArrayIndices(); Profiler.EndSample(); }
public bool Complete(TimeSlice timeSlice) { JobHandle.ScheduleBatchedJobs(); // Calling 'Complete' can cause rare deadlocks. // A slightly less efficient solution is to use the dependenciesDoneEvent. // This seems to work without any rare deadlocks. // // This happens because if Complete is called the main thread may be scheduled to run the // job that waits for the main thread job. This will cause a deadlock. // dependsOn.Complete(); dependenciesDoneEvent.WaitOne(); UnityEngine.Profiling.Profiler.BeginSample("Main thread job"); bool finished = true; try { // Note: if this method throws an exception then finished will be true and the job marked as completed if (job is IJobTimeSliced sliced) { finished = sliced.Execute(timeSlice); } else { job.Execute(); } } finally { UnityEngine.Profiling.Profiler.EndSample(); if (finished) { doneEvent.Set(); #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckDeallocateAndThrow(safetyHandle); AtomicSafetyHandle.Release(safetyHandle); #endif } } return(finished); }
public void Dispose() { AtomicSafetyHandle.CheckDeallocateAndThrow(Handle); AtomicSafetyHandle.Release(Handle); }