public void UnsafeHashMap_Performance_RepeatLookup([Values(10, 100, 1000, 10000, 100000, 1000000, 2500000, 10000000)] int insertions) { using (var container = new UnsafeHashMap <int, int>(insertions, Allocator.Persistent)) { using (var addedKeys = new NativeList <int>(insertions, Allocator.Persistent)) { Random.InitState(0); for (int i = 0; i < insertions; i++) { int randKey = Random.Range(0, insertions); container.Add(randKey, randKey); addedKeys.Add(randKey); } Measure.Method(() => { for (int i = 0; i < insertions; i++) { int randKey = addedKeys[i]; Assert.IsTrue(container.TryGetValue(randKey, out _)); } }) .WarmupCount(10) .MeasurementCount(10) .Run(); } } }
protected override JobHandle OnUpdate(JobHandle inputDeps) { bool hasNoGrid = m_GridQuery.IsEmptyIgnoreFilter; if (hasNoGrid) { var settings = GetSingleton <AntManagerSettings>(); int mapSize = settings.MapSize; World.EntityManager.CreateEntity(typeof(PheromoneGrid)); var values = new UnsafeHashMap <int, float>(mapSize * mapSize, Allocator.Persistent); for (int i = 0; i < mapSize * mapSize; ++i) { values.Add(i, 0f); } var grid = new PheromoneGrid { Values = values }; SetSingleton(grid); } return(inputDeps); }
public void UnsafeHashMap_ForEach([Values(10, 1000)] int n) { var seen = new NativeArray <int>(n, Allocator.Temp); using (var container = new UnsafeHashMap <int, int>(32, Allocator.TempJob)) { for (int i = 0; i < n; i++) { container.Add(i, i * 37); } var count = 0; foreach (var kv in container) { int value; Assert.True(container.TryGetValue(kv.Key, out value)); Assert.AreEqual(value, kv.Value); Assert.AreEqual(kv.Key * 37, kv.Value); seen[kv.Key] = seen[kv.Key] + 1; ++count; } Assert.AreEqual(container.Count(), count); for (int i = 0; i < n; i++) { Assert.AreEqual(1, seen[i], $"Incorrect key count {i}"); } } }
internal bool RegisterParameter(int parameter) { if (parameter == 0) { return(false); } if (!uniqueParameters.TryGetValue(parameter, out var item)) { var index = uniqueParameterCount; uniqueParameterCount++; if (uniqueParameters.Capacity < uniqueParameterCount) { uniqueParameters.Capacity = Mathf.CeilToInt(uniqueParameterCount * 1.5f); } uniqueParameters.Add(parameter, new ChiselLayerParameterIndex { count = 1, index = index }); return(true); } else { item.count++; uniqueParameters[parameter] = item; return(false); } }
public ref T AllocateSystemData <T>(uint systemId) where T : struct { var ptr = UnsafeUtility.Malloc(UnsafeUtility.SizeOf <T>(), UnsafeUtility.AlignOf <T>(), Allocator.Persistent); UnsafeHashMap.Add(SystemData, systemId, (IntPtr)ptr); return(ref UnsafeUtilityEx.AsRef <T>(ptr)); }
public void UnsafeHashMap_Performance_Count([Values(10, 100, 1000, 10000, 100000, 1000000, 2500000, 10000000)] int capacity) { using (var container = new UnsafeHashMap <int, int>(capacity, Allocator.Persistent)) { container.Add(1, 1); Measure.Method(() => { container.Count(); }) .WarmupCount(10) .MeasurementCount(10) .Run(); } }
public void Execute() { var dstEntityComponentStore = DstEntityManager.GetCheckedEntityDataAccess()->EntityComponentStore; var remapping = new UnsafeHashMap <int, int>(SrcSharedComponentIndices.Length, Allocator.Temp); for (int i = 0; i < SrcSharedComponentIndices.Length; i++) { remapping.Add(SrcSharedComponentIndices[i], DstSharedComponentIndices[i]); } for (int i = 0; i < Chunks.Length; i++) { HandleChunk(i, dstEntityComponentStore, remapping); } }
public void UnsafeHashMap_Performance_RepeatInsert([Values(10, 100, 1000, 10000, 100000, 1000000, 2500000, 10000000)] int insertions) { using (var container = new UnsafeHashMap <int, int>(insertions, Allocator.Persistent)) { Random.InitState(0); Measure.Method(() => { for (int i = 0; i < insertions; i++) { int randKey = Random.Range(0, insertions); container.Add(randKey, randKey); } }) .WarmupCount(10) .MeasurementCount(10) .Run(); } }
internal int AddSystemType(long typeHash, FixedString64 debugName, UnmanagedComponentSystemDelegates delegates) { if (m_TypeHashToIndex.TryGetValue(typeHash, out int index)) { if (m_DebugNames[index] != debugName) { Debug.LogError($"Type hash {typeHash} for {debugName} collides with {m_DebugNames[index]}. Skipping this type. Rename the type to avoid the collision."); return(-1); } m_Delegates[index] = delegates; return(index); } else { int newIndex = m_Delegates.Length; m_TypeHashToIndex.Add(typeHash, newIndex); m_DebugNames.Add(debugName); m_Delegates.Add(delegates); return(newIndex); } }
void AddLiveLinkChangeSet(Hash128 sceneGUID, List <LiveLinkChangeSet> changeSets, LiveLinkMode mode) { var liveLink = GetLiveLink(sceneGUID); var editScene = _GUIDToEditScene[sceneGUID]; // The current behaviour is that we do incremental conversion until we release the hot control // This is to avoid any unexpected stalls // Optimally the undo system would tell us if only properties have changed, but currently we don't have such an event stream. var sceneDirtyID = GetSceneDirtyID(editScene); var updateLiveLink = true; if (IsHotControlActive()) { if (liveLink != null) { sceneDirtyID = liveLink.LiveLinkDirtyID; } else { updateLiveLink = false; EditorUpdateUtility.EditModeQueuePlayerLoopUpdate(); } } else { if (liveLink != null && liveLink.LiveLinkDirtyID != sceneDirtyID) { liveLink.RequestCleanConversion(); } } if (updateLiveLink) { //@TODO: need one place that LiveLinkDiffGenerators are managed. UpdateLiveLink does a Dispose() // but this must be paired with membership in _SceneGUIDToLiveLink. not good to have multiple places // doing ownership management. // // also: when implementing an improvement to this, be sure to deal with exceptions, which can occur // during conversion. if (liveLink != null) { _SceneGUIDToLiveLink.Remove(sceneGUID); } try { changeSets.Add(LiveLinkDiffGenerator.UpdateLiveLink(editScene, sceneGUID, ref liveLink, sceneDirtyID, mode, _BuildConfiguration, out var assetDependencies)); if (assetDependencies.IsCreated) { m_AssetDependencies.Clear(); foreach (var asset in assetDependencies) { m_AssetDependencies.Add(asset, 1); } assetDependencies.Dispose(); } } finally { if (liveLink != null) { _SceneGUIDToLiveLink.Add(sceneGUID, liveLink); } } } }