/// <summary> /// Returns parallel reader instance. /// </summary> /// <returns>Parallel writer instance.</returns> public ParallelWriter AsParallelWriter() { ParallelWriter writer; #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); writer.m_Safety = m_Safety; AtomicSafetyHandle.UseSecondaryVersion(ref writer.m_Safety); #endif writer.m_Buffer = m_Buffer; writer.m_QueuePool = m_QueuePool; writer.m_ThreadIndex = 0; return(writer); }
public Transform this[int index] { get { AtomicSafetyHandle.CheckReadAndThrow(m_Safety); return(GetTransform(m_TransformArray, index)); } set { AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); SetTransform(m_TransformArray, index, value); } }
private void AddRangeNoResize(int sizeOf, int alignOf, void *ptr, int length) { var idx = Interlocked.Add(ref ListData->Length, length) - length; #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); if (ListData->Capacity < idx + length) { throw new Exception($"AddRangeNoResize assumes that list capacity is sufficient (Capacity {ListData->Capacity}, Lenght {ListData->Length})!"); } #endif void *dst = (byte *)Ptr + idx * sizeOf; UnsafeUtility.MemCpy(dst, ptr, length * sizeOf); }
public void CalculateLength_SyncsChangeFilterTypes() { var group = m_Manager.CreateComponentGroup(typeof(EcsTestData)); group.SetFilterChanged(typeof(EcsTestData)); var ws1 = World.GetOrCreateManager <WriteEcsTestDataSystem>(); ws1.Update(); var safetyHandle = m_Manager.ComponentJobSafetyManager.GetSafetyHandle(TypeManager.GetTypeIndex <EcsTestData>(), false); Assert.Throws <InvalidOperationException>(() => AtomicSafetyHandle.CheckWriteAndThrow(safetyHandle)); group.CalculateLength(); AtomicSafetyHandle.CheckWriteAndThrow(safetyHandle); group.Dispose(); }
public void CompleteReadAndWriteDependency(int type) { //TODO: avoid call and turn into assert if (TypeManager.IsZeroSized(type)) { return; } CompleteReadAndWriteDependencyNoChecks(type); #if ENABLE_UNITY_COLLECTIONS_CHECKS var typeWithoutFlags = type & TypeManager.ClearFlagsMask; AtomicSafetyHandle.CheckWriteAndThrow(m_ComponentSafetyHandles[typeWithoutFlags].SafetyHandle); AtomicSafetyHandle.CheckWriteAndThrow(m_ComponentSafetyHandles[typeWithoutFlags].BufferHandle); #endif }
static void CopySafe(T[] src, int srcIndex, NativeArray <T> dst, int dstIndex, int length) { AtomicSafetyHandle.CheckWriteAndThrow(dst.m_Safety); CheckCopyPtr(src); CheckCopyArguments(src.Length, srcIndex, dst.Length, dstIndex, length); var handle = GCHandle.Alloc(src, GCHandleType.Pinned); var addr = handle.AddrOfPinnedObject(); UnsafeUtility.MemCpy( (byte *)dst.m_Buffer + dstIndex * UnsafeUtility.SizeOf <T>(), (byte *)addr + srcIndex * UnsafeUtility.SizeOf <T>(), length * UnsafeUtility.SizeOf <T>()); handle.Free(); }
void CheckElementWriteAccess(int index) { #if ENABLE_UNITY_COLLECTIONS_CHECKS if (index < m_MinIndex || index > m_MaxIndex) { FailOutOfRangeError(index); } // Check versions match and write protection is not flagged int version = m_Safety.UncheckedGetNodeVersion(); if (m_Safety.version != (version & AtomicSafetyNodeVersionMask.VersionAndWriteProtect)) { AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); } #endif }
public NativeMinHeapNode <TValue, TPriority> Pop() { #if ENABLE_UNITY_COLLECTIONS_CHECKS if (size == 0) { throw new IndexOutOfRangeException($"Size is zero"); } AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif var result = this[0]; this[0] = this[size - 1]; size--; BubbleDown(); return(result); }
private void CheckReinterpretStoreRange <U>(int destIndex) where U : struct { long num = (long)UnsafeUtility.SizeOf <T>(); AtomicSafetyHandle.CheckWriteAndThrow(this.m_Safety); long num2 = (long)UnsafeUtility.SizeOf <U>(); long num3 = (long)this.Length * num; long num4 = (long)destIndex * num; long num5 = num4 + num2; bool flag = num4 <0L || num5> num3; if (flag) { throw new ArgumentOutOfRangeException("destIndex", "stored byte range must fall inside container bounds"); } }
public unsafe void CalculateEntityCount_SyncsChangeFilterTypes() { var group = m_Manager.CreateEntityQuery(typeof(EcsTestData)); group.SetChangedVersionFilter(typeof(EcsTestData)); var ws1 = World.GetOrCreateSystem <WriteEcsTestDataSystem>(); ws1.Update(); var safetyHandle = m_Manager.SafetyHandles->GetSafetyHandle(TypeManager.GetTypeIndex <EcsTestData>(), false); Assert.Throws <InvalidOperationException>(() => AtomicSafetyHandle.CheckWriteAndThrow(safetyHandle)); group.CalculateEntityCount(); AtomicSafetyHandle.CheckWriteAndThrow(safetyHandle); group.Dispose(); }
/// <summary> /// Removes all elements from this container. Any NativeHeapIndex structures obtained will be /// invalidated and cannot be used again. /// </summary> public void Clear() { unsafe { #if NHEAP_SAFE AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); for (int i = 0; i < _data->Count; i++) { var node = ReadArrayElement <HeapNode>(_data->Heap, i); _data->Table[node.TableIndex].Version++; } #endif _data->Count = 0; } }
internal void DestroyInstance() { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif PreDisposeCheck(); GetCheckedEntityDataAccess()->Dispose(); UnsafeUtility.Free(m_EntityDataAccess, Allocator.Persistent); m_EntityDataAccess = null; #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.Release(m_Safety); m_Safety = default; #endif }
public unsafe static void Copy(T[] src, int srcIndex, NativeArray <T> dst, int dstIndex, int length) { AtomicSafetyHandle.CheckWriteAndThrow(dst.m_Safety); bool flag = src == null; if (flag) { throw new ArgumentNullException("src"); } NativeArray <T> .CheckCopyArguments(src.Length, srcIndex, dst.Length, dstIndex, length); GCHandle gCHandle = GCHandle.Alloc(src, GCHandleType.Pinned); IntPtr value = gCHandle.AddrOfPinnedObject(); UnsafeUtility.MemCpy((void *)((byte *)dst.m_Buffer + dstIndex * UnsafeUtility.SizeOf <T>()), (void *)((byte *)((void *)value) + srcIndex * UnsafeUtility.SizeOf <T>()), (long)(length * UnsafeUtility.SizeOf <T>())); gCHandle.Free(); }
/// <summary> /// Resets the value contained within this result to the identity value. /// </summary> public void Reset() { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif T identity; m_Op.GetIdentity(out identity); unsafe { void *ptr = (void *)m_Buffer; for (int i = 0; i < JobsUtility.MaxJobThreadCount; i++) { UnsafeUtility.WriteArrayElementWithStride(ptr, i, JobsUtility.CacheLineSize, identity); } } }
public void CheckAccess() { #if ENABLE_UNITY_COLLECTIONS_CHECKS fixed(AtomicSafetyHandle *safety = &m_Safety0) { for (var i = 0; i < m_SafetyReadOnlyCount; i++) { AtomicSafetyHandle.CheckReadAndThrow(safety[i]); } for (var i = m_SafetyReadOnlyCount; i < m_SafetyReadOnlyCount + m_SafetyReadWriteCount; i++) { AtomicSafetyHandle.CheckWriteAndThrow(safety[i]); } } #endif }
private void CheckReinterpretStoreRange <U>(int destIndex) where U : struct { long tsize = UnsafeUtility.SizeOf <T>(); AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); long usize = UnsafeUtility.SizeOf <U>(); long byteSize = Length * tsize; long firstByte = destIndex * tsize; long lastByte = firstByte + usize; if (firstByte < 0 || lastByte > byteSize) { throw new ArgumentOutOfRangeException(nameof(destIndex), "stored byte range must fall inside container bounds"); } }
public T this[int index] { get { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckReadAndThrow(m_Safety); #endif return(m_Impl[index]); } set { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif m_Impl[index] = value; } }
/// <summary> /// Ends an exclusive entity transaction. /// </summary> /// <seealso cref="ExclusiveEntityTransaction"/> /// <seealso cref="BeginExclusiveEntityTransaction()"/> public void EndExclusiveEntityTransaction() { #if ENABLE_UNITY_COLLECTIONS_CHECKS if (m_IsInExclusiveTransaction == 1) { throw new InvalidOperationException("Transactions can only be ended from the main thread"); } AtomicSafetyHandle.CheckExistsAndThrow(m_Safety); #endif m_EntityDataAccess->DependencyManager->PreEndExclusiveTransaction(); #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif m_EntityDataAccess->DependencyManager->EndExclusiveTransaction(); m_EntityDataAccess->m_IsInExclusiveTransaction = 0; }
public void SendCandidate(int candidate) { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif int expectValue, realValue; switch (m_Mode) { case MinMax.Min: { do { expectValue = *m_MinOrMax; if (candidate < expectValue) { realValue = CompareExchange(ref *m_MinOrMax, candidate, expectValue); } else { realValue = expectValue; } } while (realValue != expectValue); } break; case MinMax.Max: { do { expectValue = *m_MinOrMax; if (candidate > expectValue) { realValue = CompareExchange(ref *m_MinOrMax, candidate, expectValue); } else { realValue = expectValue; } } while (realValue != expectValue); } break; } }
public static void Copy(T[] src, int srcIndex, NativeArray <T> dst, int dstIndex, int length) { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(dst.m_Safety); if (src == null) { throw new ArgumentNullException(nameof(src)); } if (length < 0) { throw new ArgumentOutOfRangeException(nameof(length), "length must be equal or greater than zero."); } if (srcIndex < 0 || srcIndex > src.Length || (srcIndex == src.Length && src.Length > 0)) { throw new ArgumentOutOfRangeException(nameof(srcIndex), "srcIndex is outside the range of valid indexes for the source array."); } if (dstIndex < 0 || dstIndex > dst.Length || (dstIndex == dst.Length && dst.Length > 0)) { throw new ArgumentOutOfRangeException(nameof(dstIndex), "dstIndex is outside the range of valid indexes for the destination NativeArray."); } if (srcIndex + length > src.Length) { throw new ArgumentException("length is greater than the number of elements from srcIndex to the end of the source array.", nameof(length)); } if (dstIndex + length > dst.Length) { throw new ArgumentException("length is greater than the number of elements from dstIndex to the end of the destination NativeArray.", nameof(length)); } #endif var handle = GCHandle.Alloc(src, GCHandleType.Pinned); var addr = handle.AddrOfPinnedObject(); UnsafeUtility.MemCpy( (byte *)dst.m_Buffer + dstIndex * UnsafeUtility.SizeOf <T>(), (byte *)addr + srcIndex * UnsafeUtility.SizeOf <T>(), length * UnsafeUtility.SizeOf <T>()); handle.Free(); }
public void AddRef(ref T data) { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif int tlsIdx = m_ThreadIndex; NativeBucketHeader *header = (NativeBucketHeader *)GetHeaderBlock(m_HeaderBlock, tlsIdx); CheckAndAllocateBlock(header); int incNum = Interlocked.Increment(ref header->itemsInBlock); if (incNum > m_BlockNumCapacity) { throw new ArgumentOutOfRangeException(nameof(m_BlockNumCapacity), "exceeded."); } UnsafeUtility.WriteArrayElementWithStride((void *)header->block, incNum - 1, header->unitSize, data); }
public void WritePackedUInt(uint value, NetworkCompressionModel model) { int bucket = model.CalculateBucket(value); uint offset = model.bucketOffsets[bucket]; int bits = model.bucketSizes[bucket]; ushort encodeEntry = model.encodeTable[bucket]; #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); if (m_Data->length + ((m_Data->bitIndex + encodeEntry & 0xff + bits + 7) >> 3) > m_Data->capacity) { throw new System.ArgumentOutOfRangeException(); } #endif WriteRawBitsInternal((uint)(encodeEntry >> 8), encodeEntry & 0xFF); WriteRawBitsInternal(value - offset, bits); FlushBits(); }
public unsafe void CreateArchetypeChunkArray_SyncsChangeFilterTypes() { var group = m_Manager.CreateEntityQuery(typeof(EcsTestData)); group.SetFilterChanged(typeof(EcsTestData)); var ws1 = World.GetOrCreateSystem <WriteEcsTestDataSystem>(); ws1.Update(); var safetyHandle = m_Manager.ComponentJobSafetyManager->GetSafetyHandle(TypeManager.GetTypeIndex <EcsTestData>(), false); Assert.Throws <InvalidOperationException>(() => AtomicSafetyHandle.CheckWriteAndThrow(safetyHandle)); var chunks = group.CreateArchetypeChunkArray(Allocator.TempJob); AtomicSafetyHandle.CheckWriteAndThrow(safetyHandle); chunks.Dispose(); group.Dispose(); }
public unsafe void AddUniqueVertices(ref ChiselBlobArray <float3> uniqueVertices) { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif // Add Unique vertex for (int i = 0; i < uniqueVertices.Length; i++) { var vertex = uniqueVertices[i]; var centerIndex = new int3((int)(vertex.x / kCellSize), (int)(vertex.y / kCellSize), (int)(vertex.z / kCellSize)); var hashCode = HashedVerticesUtility.GetHash(centerIndex); var prevChainIndex = ((ushort *)m_HashTable)[hashCode]; var newChainIndex = m_ChainedIndices->Length; m_Vertices->AddNoResize(vertex); m_ChainedIndices->AddNoResize((ushort)prevChainIndex); ((ushort *)m_HashTable)[(int)hashCode] = (ushort)(newChainIndex + 1); } }
public byte this[int index] { get { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckReadAndThrow(m_Safety); #endif return(*(m_Counter + index)); } set { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif *(m_Counter + index) = value; } }
/// <summary> /// Retrieve a member of the contaner by index. /// </summary> /// <param name="index">The zero-based index into the list.</param> /// <value>The list item at the specified index.</value> /// <exception cref="IndexOutOfRangeException">Thrown if index is negative or >= to <see cref="Length"/>.</exception> public T this[int index] { get { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckReadAndThrow(m_Safety); #endif CheckIndexInRange(index, m_ListData->Length); return(UnsafeUtility.ReadArrayElement <T>(m_ListData->Ptr, CollectionHelper.AssumePositive(index))); } set { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif CheckIndexInRange(index, m_ListData->Length); UnsafeUtility.WriteArrayElement(m_ListData->Ptr, CollectionHelper.AssumePositive(index), value); } }
public NativeQuadTreeNode this[int index] { get { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckReadAndThrow(m_Safety); #endif CheckIndexInRange(index, m_ListData->Length); return(UnsafeUtility.ReadArrayElement <NativeQuadTreeNode>(m_ListData->Ptr, index)); } private set { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif CheckIndexInRange(index, m_ListData->Length); UnsafeUtility.WriteArrayElement(m_ListData->Ptr, index, value); } }
public DynamicBuffer <T> this[int index] { get { if (this.m_IsReadOnly) { AtomicSafetyHandle.CheckReadAndThrow(this.m_Safety0); } else { AtomicSafetyHandle.CheckWriteAndThrow(this.m_Safety0); } if ((index < 0) || (index >= this.Length)) { throw new InvalidOperationException($"index {index} out of range in LowLevelBufferAccessor of length {this.Length}"); } return(new DynamicBuffer <T>((BufferHeader *)(this.m_BasePointer + (index * this.m_Stride)), this.m_Safety0, this.m_ArrayInvalidationSafety, this.m_IsReadOnly)); } }
// Ensure we have at least this many extra vertices in capacity public void ReserveAdditionalVertices(int extraIndices) { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif var requiredVertCapacity = m_Vertices->Length + extraIndices; var requiredVertices = m_Vertices->Length + (extraIndices * 2); if (m_Vertices->Capacity < requiredVertCapacity) { m_Vertices->SetCapacity(requiredVertices); } var requiredIndexCapacity = m_ChainedIndices->Length + extraIndices; var requiredIndices = m_ChainedIndices->Length + (extraIndices * 2); if (m_ChainedIndices->Capacity < requiredIndexCapacity) { m_ChainedIndices->SetCapacity(requiredIndices); } }
public T this[Entity entity] { get { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckReadAndThrow(m_Safety); #endif m_Entities->AssertEntityHasComponent(entity, m_TypeIndex); // if the component is zero-sized, we return a default-initialized T. // this is to support users who transition to zero-sized T and back, // or who write generics over T and don't wish to branch over zero-sizedness. if (m_IsZeroSized) { return(default(T)); } T data; void *ptr = m_Entities->GetComponentDataWithTypeRO(entity, m_TypeIndex, ref m_TypeLookupCache); UnsafeUtility.CopyPtrToStructure(ptr, out data); return(data); } set { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif m_Entities->AssertEntityHasComponent(entity, m_TypeIndex); // if the component is zero-sized, we make no attempt to set a value. // this is to support users who transition to zero-sized T and back, // or who write generics over T and don't wish to branch over zero-sizedness. if (m_IsZeroSized) { return; } void *ptr = m_Entities->GetComponentDataWithTypeRW(entity, m_TypeIndex, m_GlobalSystemVersion, ref m_TypeLookupCache); UnsafeUtility.CopyStructureToPtr(ref value, ptr); } }