public void NativeMultiHashMap_Double_Deallocate_Throws() { var hashMap = new NativeMultiHashMap <int, int>(16, Allocator.TempJob); hashMap.Dispose(); Assert.Throws <InvalidOperationException>(() => { hashMap.Dispose(); }); }
protected override void OnDestroy() { foreach (NativeQueue <COMMAND> CommandsQueue in CommandsQueues) { CommandsQueue.Dispose(); } CommandsMap.Dispose(); }
protected override void OnDestroy() { base.OnDestroy(); sharedIndices.Dispose(); entityCountBySharedIndex.Dispose(); chunkCountDataBySharedIndex.Dispose(); indicesInSquadBySharedIndices.Dispose(); }
public NativeMultiHashMap <int, int> CreateHashMap() { if (_HasInitMap) { _HashMap.Dispose(); } _HasInitMap = true; _HashMap = new NativeMultiHashMap <int, int>(_context.CurBoidCount, Unity.Collections.Allocator.Persistent); return(_HashMap); }
protected override void OnDestroyManager() { if (cloudID2MarkedCellsMap.IsCreated) { cloudID2MarkedCellsMap.Dispose(); } if (Cell2OwningCloud.IsCreated) { Cell2OwningCloud.Dispose(); } }
protected override JobHandle OnUpdate(JobHandle inputDeps) { int cellTagMap_size = (int)m_cloudTagDesiredQuantitySystem.TotalTags * 2; if (lastsize_cellTagMap != cellTagMap_size) { cellTagMap.Dispose(); cellTagMap = new NativeMultiHashMap <int, int>(cellTagMap_size, Allocator.Persistent); } else { cellTagMap.Clear(); } lastsize_cellTagMap = cellTagMap_size; if (lastsize_tagQuantityByCloud != m_tagCloudGroup.Length) { tagQuantityByCloud.Dispose(); tagQuantityByCloud = new NativeArray <int>(m_tagCloudGroup.Length, Allocator.Persistent); } lastsize_tagQuantityByCloud = m_tagCloudGroup.Length; if (lastsize_cloudIDPositions != m_tagCloudGroup.Length) { cloudIDPositions.Dispose(); cloudIDPositions = new NativeHashMap <int, CloudIDPosRadius>(m_tagCloudGroup.Length, Allocator.Persistent); } else { cloudIDPositions.Clear(); } lastsize_cloudIDPositions = m_tagCloudGroup.Length; FillMapLists fillMapListsJob = new FillMapLists { cellTagMap = cellTagMap.ToConcurrent(), tagQuantity = tagQuantityByCloud, CloudData = m_tagCloudGroup.CloudData, Position = m_tagCloudGroup.Position, cloudPos = cloudIDPositions.ToConcurrent(), cellIDmap = m_cellIdMapSystem.cellId2Cellfloat3 }; var fillMapDep = fillMapListsJob.Schedule(m_tagCloudGroup.Length, 64, inputDeps); fillMapDep.Complete(); return(fillMapDep); }
public void NativeMultiHashMap_Double_Deallocate_Throws() { var hashMap = new NativeMultiHashMap <int, int>(16, Allocator.TempJob); hashMap.Dispose(); #if UNITY_2020_2_OR_NEWER Assert.Throws <ObjectDisposedException>( #else Assert.Throws <InvalidOperationException>( #endif () => { hashMap.Dispose(); }); }
void Update() { if (Input.GetKeyDown(KeyCode.F5)) { Setup(); } if (Input.GetKeyDown(KeyCode.F6)) { ResetPositionsOnly(); } if (hashMap.IsCreated) { hashMap.Dispose(); } hashMap = new NativeMultiHashMap <int, int>(NumCells, Allocator.TempJob); _jobHashMap = new HashCellsJob() { hashMap = hashMap.ToConcurrent(), position = _cellPositions, envSettings = envSettings }; _jobCellularForce = new CellularForceJob() { numCells = NumCells, numGroups = NumGroups, position = _cellPositions, velocity = _cellVelocities, groupIndex = _cellGroupIndex, forceMatrix = _cellGroupsForceMatrix, hashMap = hashMap, envSettings = envSettings, deltaTime = Time.deltaTime, }; _jobPos = new PositionUpdateJob() { position = _cellPositions, velocity = _cellVelocities, deltaTime = Time.deltaTime, }; _jobsHandleHashMap = _jobHashMap.Schedule(NumCells, 128); _jobsHandleCellularForce = _jobCellularForce.Schedule(NumCells, 128, _jobsHandleHashMap); _jobHandlePosition = _jobPos.Schedule(_cellTfmAccessArray, _jobsHandleCellularForce); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { if (AgentMarkers.Capacity < agentGroup.Agents.Length * qtdMarkers * 4) { AgentMarkers.Dispose(); AgentMarkers = new NativeMultiHashMap <int, float3>(agentGroup.Agents.Length * qtdMarkers * 4, Allocator.Persistent); } else { AgentMarkers.Clear(); } if (!CellTagSystem.AgentIDToPos.IsCreated) { return(inputDeps); } if (createDict) { createDict = false; CreateCells(); } //Get QuadTree quadrants that need to be schedueled var schedule = new NativeArray <int3>(qt.GetScheduled(), Allocator.Temp); //Debug.Log(schedule.Length); //list<quadrants> --> [[cell1, cell2, ..., celln], [celln+1, ...], ...] //[cell1, cell2, ..., celln] --> ComponentDataArray<Position> //Job <-- Position, MarkedCells { markerCell --> checkAgents } var job = new TakeMarkers { AgentMarkers = AgentMarkers.ToConcurrent(), Densities = LocalDensities.ToConcurrent(), cellToAgent = CellTagSystem.CellToMarkedAgents, cells = schedule, AgentIDToPos = CellTagSystem.AgentIDToPos }; var sq = job.Schedule(schedule.Length, Settings.BatchSize, inputDeps); sq.Complete(); schedule.Dispose(); frame++; return(sq); }
protected override void OnDestroy() { if (translations.IsCreated) { translations.Dispose(); } if (velocities.IsCreated) { velocities.Dispose(); } if (CollisionBuckets.IsCreated) { CollisionBuckets.Dispose(); } }
protected override JobHandle OnUpdate(JobHandle inputDeps) { if (_massData.Length == 0 || _springData.Length == 0) { return(inputDeps); } NativeMultiHashMap <Entity, float3> hashMap = new NativeMultiHashMap <Entity, float3>(_massData.Length * 4, Allocator.Temp); HashSpringForceJob hashMassSpringJob = new HashSpringForceJob { _hashMap = hashMap.ToConcurrent(), _springEntityPairs = _springData.EntityPairs, _springElasticities = _springData.Elasticities, _springLines = _springData.Lines }; JobHandle hashMassSPringHandle = hashMassSpringJob.Schedule(_springData.Length, 64, inputDeps); MassSpringForceJob massSpringForceJob = new MassSpringForceJob { _massSpringHashMap = hashMap, _massEntities = _massData.Entities, _massPhysicals = _massData.Physicals }; JobHandle massSpringForceHandle = massSpringForceJob.Schedule(_massData.Length, 64, hashMassSPringHandle); massSpringForceHandle.Complete(); hashMap.Dispose(); return(massSpringForceHandle); }
public void NativeMultiHashMap_Key_Collisions() { var hashMap = new NativeMultiHashMap <int, int>(hashMapSize, Allocator.TempJob); var writeStatus = new NativeArray <int>(hashMapSize, Allocator.TempJob); var readValues = new NativeArray <int>(hashMapSize, Allocator.TempJob); var writeData = new MultiHashMapWriteParallelForJob() { hashMap = hashMap.AsParallelWriter(), status = writeStatus, keyMod = 16, }; var readData = new MultiHashMapReadParallelForJob() { hashMap = hashMap, values = readValues, keyMod = writeData.keyMod, }; var writeJob = writeData.Schedule(hashMapSize, 1); var readJob = readData.Schedule(hashMapSize, 1, writeJob); readJob.Complete(); for (int i = 0; i < hashMapSize; ++i) { Assert.AreEqual(0, writeStatus[i], "Job failed to write value to hash map"); Assert.AreEqual(hashMapSize / readData.keyMod, readValues[i], "Job failed to read from hash map"); } hashMap.Dispose(); writeStatus.Dispose(); readValues.Dispose(); }
public void Dispose() { // Free all allocated chunks for all allocated archetypes while (m_LastArchetype != null) { while (!m_LastArchetype->ChunkList.IsEmpty) { var chunk = m_LastArchetype->ChunkList.Begin; chunk->Remove(); UnsafeUtility.Free(chunk, Allocator.Persistent); } m_LastArchetype = m_LastArchetype->PrevArchetype; } // And all pooled chunks while (!m_EmptyChunkPool->IsEmpty) { var chunk = m_EmptyChunkPool->Begin; chunk->Remove(); UnsafeUtility.Free(chunk, Allocator.Persistent); } m_TypeLookup.Dispose(); m_ArchetypeChunkAllocator.Dispose(); }
public void NativeHashMap_MergeCountShared() { var count = 1024; var sharedKeyCount = 16; var sharedCount = new NativeArray <int>(count, Allocator.TempJob); var sharedIndices = new NativeArray <int>(count, Allocator.TempJob); var totalSharedCount = new NativeArray <int>(1, Allocator.TempJob); var hashMap = new NativeMultiHashMap <int, int>(count, Allocator.TempJob); for (int i = 0; i < count; i++) { hashMap.Add(i & (sharedKeyCount - 1), i); sharedCount[i] = 1; } var mergeSharedValuesJob = new MergeSharedValues { sharedCount = sharedCount, sharedIndices = sharedIndices, }; var mergetedSharedValuesJobHandle = mergeSharedValuesJob.Schedule(hashMap, 64); mergetedSharedValuesJobHandle.Complete(); for (int i = 0; i < count; i++) { Assert.AreEqual(count / sharedKeyCount, sharedCount[sharedIndices[i]]); } sharedCount.Dispose(); sharedIndices.Dispose(); totalSharedCount.Dispose(); hashMap.Dispose(); }
public void Dispose() { _nodeToParent.Dispose(); _nodeStates.Dispose(); _preconditions.Dispose(); _effects.Dispose(); }
public void NativeMultiHashMap_RemoveKeyAndValue() { var hashMap = new NativeMultiHashMap <int, long> (1, Allocator.Temp); hashMap.Add(10, 0); hashMap.Add(10, 1); hashMap.Add(10, 2); hashMap.Add(20, 2); hashMap.Add(20, 2); hashMap.Add(20, 1); hashMap.Add(20, 2); hashMap.Add(20, 1); hashMap.Remove(10, 1L); ExpectValues(hashMap, 10, new [] { 0L, 2L }); ExpectValues(hashMap, 20, new [] { 1L, 1L, 2L, 2L, 2L }); hashMap.Remove(20, 2L); ExpectValues(hashMap, 10, new [] { 0L, 2L }); ExpectValues(hashMap, 20, new [] { 1L, 1L }); hashMap.Remove(20, 1L); ExpectValues(hashMap, 10, new [] { 0L, 2L }); ExpectValues(hashMap, 20, new long [0]); hashMap.Dispose(); }
public void NativeMultiHashMap_RemoveKeyValueThrowsInvalidParam() { var hashMap = new NativeMultiHashMap <int, long>(1, Allocator.Temp); Assert.Throws <ArgumentException>(() => hashMap.Remove(5, 5)); hashMap.Dispose(); }
public void Dispose(JobHandle jobHandle = default) { if (ActionLookup.IsCreated) { ActionLookup.Dispose(jobHandle); } if (ResultingStateLookup.IsCreated) { ResultingStateLookup.Dispose(jobHandle); } if (PredecessorGraph.IsCreated) { PredecessorGraph.Dispose(jobHandle); } if (StateInfoLookup.IsCreated) { StateInfoLookup.Dispose(jobHandle); } if (ActionInfoLookup.IsCreated) { ActionInfoLookup.Dispose(jobHandle); } if (StateTransitionInfoLookup.IsCreated) { StateTransitionInfoLookup.Dispose(jobHandle); } }
/// <summary> /// 释放,如果为true,则重新加载数据 /// 注意,该操作会释放大量GC /// </summary> /// <param name="isReset"></param> public void Dispose(bool isReset) { JobHandle.CompleteAll(handleList.AsArray()); pointReadList.Dispose(); pointReadWriteList.Dispose(); pointTransformsList.Dispose(); constraintReadList1.Dispose(); ConstraintReadByPointIndex.Dispose(); for (int i = 0; i < constraintReadList.Length; i++) { constraintReadList[i].Dispose(); } if (isReset) { pointTransformsList = new TransformAccessArray(0); m_constraintList = new List <ConstraintRead[]>(); m_pointReadList = new List <PointRead>(); m_pointReadWriteList = new List <PointReadWrite>(); } else { handleList.Dispose(); collidersReadList.Dispose(); collidersReadWriteList.Dispose(); colliderTransformsList.Dispose(); } }
public void Dispose() { if (HashMap.IsCreated) { HashMap.Dispose(); } }
protected override JobHandle CooldownJobs(JobHandle inputDeps) { NativeMultiHashMap <Entity, GameplayEffectDurationComponent> Cooldowns = new NativeMultiHashMap <Entity, GameplayEffectDurationComponent>(CooldownEffectsQuery.CalculateEntityCount() * 2 + GrantedAbilityQuery.CalculateEntityCount(), Allocator.TempJob); // Collect all effects which act as cooldowns for this ability inputDeps = new GatherCooldownGameplayEffectsJob { GameplayEffectDurations = Cooldowns.AsParallelWriter() }.Schedule(CooldownEffectsQuery, inputDeps); // Add a default value of '0' for all entities as well inputDeps = new CooldownAbilityIsZeroIfAbsentJob { GameplayEffectDurations = Cooldowns.AsParallelWriter() }.Schedule(GrantedAbilityQuery, inputDeps); // Get the effect with the longest cooldown remaining inputDeps = new GatherLongestCooldownPerEntity { GameplayEffectDurationComponent = Cooldowns }.Schedule(GrantedAbilityQuery, inputDeps); Cooldowns.Dispose(inputDeps); return(inputDeps); }
public void Dispose() { // Move all chunks to become pooled chunks while (m_LastArchetype != null) { while (!m_LastArchetype->ChunkList.IsEmpty) { var chunk = (Chunk *)m_LastArchetype->ChunkList.Begin; SetChunkCount(chunk, 0); } m_LastArchetype->FreeChunksBySharedComponents.Dispose(); m_LastArchetype = m_LastArchetype->PrevArchetype; } // And all pooled chunks while (!m_EmptyChunkPool->IsEmpty) { var chunk = m_EmptyChunkPool->Begin; chunk->Remove(); UnsafeUtility.Free(chunk, Allocator.Persistent); } m_ManagedArrays = null; m_TypeLookup.Dispose(); m_ArchetypeChunkAllocator.Dispose(); }
void dispose_resources() { if (enemy_bullet_hashmap_.IsCreated) { enemy_bullet_hashmap_.Dispose(); } if (player_bullet_hashmap_.IsCreated) { player_bullet_hashmap_.Dispose(); } if (enemy_hashmap_.IsCreated) { enemy_hashmap_.Dispose(); } if (player_hashmap_.IsCreated) { player_hashmap_.Dispose(); } if (enemy_bullet_colliders_.IsCreated) { enemy_bullet_colliders_.Dispose(); } if (player_bullet_colliders_.IsCreated) { player_bullet_colliders_.Dispose(); } if (enemy_colliders_.IsCreated) { enemy_colliders_.Dispose(); } if (player_colliders_.IsCreated) { player_colliders_.Dispose(); } }
/// <summary> /// Schedules an attribute job /// </summary> /// <param name="inputDependencies">JobHandle</param> /// <param name="query">The EntityQuery used for filtering group</param> /// <param name="AttributeHash">Attribute MultiHashMap mapping entity to attribute value</param> /// <param name="job">Returned job handle</param> /// <typeparam name="TOper">The type of operator for this attribute job</typeparam> private void ScheduleAttributeJob <TOper>(ref JobHandle inputDependencies, ref EntityQuery query, ref NativeMultiHashMap <Entity, float> AttributeHash, out JobHandle job) where TOper : struct, IAttributeOperator, IComponentData { var nEntities = query.CalculateEntityCount(); var hashCapacity = AttributeHash.Capacity; AttributeHash.Clear(); if (nEntities == 0) { job = inputDependencies; return; } ; if (hashCapacity < nEntities) // We need to increase hash capacity { AttributeHash.Capacity = (int)(nEntities * 1.1); } else if (hashCapacity > nEntities * 4) // We need to reduce hash capacity { AttributeHash.Dispose(); AttributeHash = new NativeMultiHashMap <Entity, float>(nEntities, Allocator.Persistent); } // // AttributeHash = new NativeMultiHashMap<Entity, float>(query.CalculateEntityCount(), Allocator.TempJob); inputDependencies = new GetAttributeValuesJob_Sum <TOper, TAttributeTag> { owners = GetArchetypeChunkComponentType <AttributesOwnerComponent>(false), attributeModifiers = GetArchetypeChunkComponentType <AttributeModifier <TOper, TAttributeTag> >(false), AttributeModifierValues = AttributeHash.AsParallelWriter() }.Schedule(query, inputDependencies); job = inputDependencies; }
public void NativeMultiHashMap_ValueIterator() { var hashMap = new NativeMultiHashMap <int, int> (1, Allocator.Temp); hashMap.Add(5, 0); hashMap.Add(5, 1); hashMap.Add(5, 2); var list = new NativeList <int>(Allocator.TempJob); GCAllocRecorder.ValidateNoGCAllocs(() => { list.Clear(); foreach (var value in hashMap.GetValuesForKey(5)) { list.Add(value); } }); list.Sort(); Assert.AreEqual(list.ToArray(), new int[] { 0, 1, 2 }); foreach (var value in hashMap.GetValuesForKey(6)) { Assert.Fail(); } list.Dispose(); hashMap.Dispose(); }
protected override void OnDestroy() { if (Walkables.IsCreated) { Walkables.Dispose(); } }
protected override JobHandle OnUpdate(JobHandle inputDeps) { int massCount = massQuery.CalculateEntityCount(); int springCount = springQuery.CalculateEntityCount(); if (massCount == 0 || springCount == 0) { return(inputDeps); } NativeMultiHashMap <Entity, float3> hashMap = new NativeMultiHashMap <Entity, float3>(massCount * 4, Allocator.TempJob); HashSpringForceJob hashMassSpringJob = new HashSpringForceJob { _hashMap = hashMap.AsParallelWriter() }; JobHandle hashMassSPringHandle = hashMassSpringJob.Schedule(this, inputDeps); MassSpringForceJob massSpringForceJob = new MassSpringForceJob { _massSpringHashMap = hashMap }; JobHandle massSpringForceHandle = massSpringForceJob.Schedule(this, hashMassSPringHandle); massSpringForceHandle.Complete(); hashMap.Dispose(); return(massSpringForceHandle); }
public void Read_And_Write_Without_Fences() { var hashMap = new NativeMultiHashMap <int, int>(hashMapSize, Allocator.Temp); var writeStatus = new NativeArray <int>(hashMapSize, Allocator.Temp); var readValues = new NativeArray <int>(hashMapSize, Allocator.Temp); var writeData = new MultiHashMapWriteParallelForJob(); writeData.hashMap = hashMap; writeData.status = writeStatus; writeData.keyMod = hashMapSize; var readData = new MultiHashMapReadParallelForJob(); readData.hashMap = hashMap; readData.values = readValues; readData.keyMod = writeData.keyMod; var writeJob = writeData.Schedule(hashMapSize, 1); Assert.Throws <InvalidOperationException> (() => { readData.Schedule(hashMapSize, 1); }); writeJob.Complete(); hashMap.Dispose(); writeStatus.Dispose(); readValues.Dispose(); }
/// <summary> /// /// </summary> public void Dispose() { buffer.Dispose(); offset.Dispose(); length.Dispose(); hash.Dispose(); }
public void Read_And_Write() { var hashMap = new NativeMultiHashMap <int, int>(hashMapSize, Allocator.TempJob); var writeStatus = new NativeArray <int>(hashMapSize, Allocator.TempJob); var readValues = new NativeArray <int>(hashMapSize, Allocator.TempJob); var writeData = new MultiHashMapWriteParallelForJob(); writeData.hashMap = hashMap; writeData.status = writeStatus; writeData.keyMod = hashMapSize; var readData = new MultiHashMapReadParallelForJob(); readData.hashMap = hashMap; readData.values = readValues; readData.keyMod = writeData.keyMod; var writeJob = writeData.Schedule(hashMapSize, 1); var readJob = readData.Schedule(hashMapSize, 1, writeJob); readJob.Complete(); for (int i = 0; i < hashMapSize; ++i) { Assert.AreEqual(0, writeStatus[i], "Job failed to write value to hash map"); Assert.AreEqual(1, readValues[i], "Job failed to read from hash map"); } hashMap.Dispose(); writeStatus.Dispose(); readValues.Dispose(); }