private void ReleaseUnusedAssetCaches() { while (true) { m_TempAssetCaches.Clear(); foreach (var assetCache in m_UnretainedAssetCaches) { if (assetCache.CanRelease()) { m_TempAssetCaches.Add(assetCache); } } if (m_TempAssetCaches.Count <= 0) { break; } foreach (var assetCache in m_TempAssetCaches) { m_AssetCaches.Remove(assetCache.Path); m_UnretainedAssetCaches.Remove(assetCache); m_WaitingForSlotAssetCaches.Remove(assetCache); assetCache.Reset(); m_AssetCachePool.Release(assetCache); } m_TempAssetCaches.Clear(); } }
public void TestAcquireAndRelease() { List <PoolableObject> objects = new List <PoolableObject>(m_RefPool.Capacity + 1); // Acquire Capacity + 1 objects. for (int i = 0; i < m_RefPool.Capacity + 1; i++) { objects.Add(m_RefPool.Acquire()); Assert.AreEqual(i + 1, PoolableObject.CurrentIndex); Assert.AreEqual(i + 1, m_RefPool.Statistics.AcquireCount); Assert.AreEqual(i + 1, m_RefPool.Statistics.CreateCount); } // Release all of them. for (int i = m_RefPool.Capacity; i >= 0; i--) { var obj = objects[i]; m_RefPool.Release(obj); } Assert.AreEqual(m_RefPool.Capacity + 1, m_RefPool.Statistics.ReleaseCount); Assert.AreEqual(1, m_RefPool.Statistics.DropCount); Assert.AreEqual(m_RefPool.Count, m_RefPool.Capacity); objects.Clear(); // Acquire again. There should be only one new object. for (int i = 0; i < m_RefPool.Capacity + 1; i++) { m_RefPool.Acquire(); if (i < m_RefPool.Capacity) { Assert.AreEqual(m_RefPool.Capacity + 1, PoolableObject.CurrentIndex); Assert.AreEqual(m_RefPool.Capacity + 1, m_RefPool.Statistics.CreateCount); } else { Assert.AreEqual(m_RefPool.Capacity + 2, PoolableObject.CurrentIndex); Assert.AreEqual(m_RefPool.Capacity + 2, m_RefPool.Statistics.CreateCount); } } }
private void ReleaseAssetAccessors() { if (m_AssetAccessorsToRelease.Count <= 0) { return; } foreach (var assetAccessor in m_AssetAccessorsToRelease) { assetAccessor.Reset(); m_AssetAccessorPool.Release(assetAccessor); } m_AssetAccessorsToRelease.Clear(); }
private void ReleaseUnretainedAssetCaches() { while (m_UnretainedAssetCaches.Count != 0) { m_TempAssetCaches.Clear(); m_TempAssetCaches.AddRange(m_UnretainedAssetCaches); foreach (var assetCache in m_TempAssetCaches) { m_AssetCaches.Remove(assetCache.Path); m_UnretainedAssetCaches.Remove(assetCache); assetCache.Reset(); m_AssetCachePool.Release(assetCache); } m_TempAssetCaches.Clear(); } }
private void ReleaseUnusedResourceCaches() { if (m_UnretainedResourceCaches.Count <= 0) { return; } bool releaseAll = true; // We need all resources (AssetBundles) that have dependencies between each other to be released/unloaded at the same time; // Otherwise, there will be occasional but confusing asset missing issues. // Here we use the simplest strategy. Once all unretained resources can be released safely, we do it all. Otherwise, we don't release any. foreach (var resourceCache in m_UnretainedResourceCaches) { if (!resourceCache.CanRelease()) { InternalLog.Info($"[AssetModule.Loader ReleaseUnusedResourceCaches] Cannot release {resourceCache.Path}. Drop."); releaseAll = false; break; } } if (!releaseAll) { return; } InternalLog.Info($"[AssetModule.Loader ReleaseUnusedResourceCaches] Release {m_UnretainedResourceCaches.Count} resources."); foreach (var resourceCache in m_UnretainedResourceCaches) { // if (resourceCache.Status.ToString().StartsWith("Waiting")) // { // InternalLog.Warning($"{resourceCache.Status}, {resourceCache.Path}"); // } m_ResourceCaches.Remove(resourceCache.Path); m_WaitingForSlotResourceCaches.Remove(resourceCache); resourceCache.Reset(); m_ResourceCachePool.Release(resourceCache); } m_UnretainedResourceCaches.Clear(); }
private void ReleaseUnusedResourceCaches() { if (m_UnretainedResourceCaches.Count <= 0) { return; } //CoreLog.Debug($"Unretained count: {m_UnretainedResourceCaches.Count}"); m_TempResourceCaches.Clear(); DFSUnretainedResourceCaches(); //CoreLog.Debug($"To-release count: {m_TempResourceCaches.Count}"); foreach (var resourceCache in m_TempResourceCaches) { m_ResourceCaches.Remove(resourceCache.Path); m_UnretainedResourceCaches.Remove(resourceCache); resourceCache.Reset(); m_ResourceCachePool.Release(resourceCache); } m_TempResourceCaches.Clear(); }
/// <summary> /// Release a download task to the pool. /// </summary> /// <param name="downloadTask">The download task.</param> public void Release(IDownloadTask downloadTask) { m_DownloadTaskRawPool.Release((DownloadTask)downloadTask); }
private void StopAndResetAssetLoadingTask(AssetLoadingTask task) { m_RunningAssetLoadingTasks.Remove(task); task.OnReset(); m_AssetLoadingTaskPool.Release(task); }
private void StopAndResetResourceLoadingTask(ResourceLoadingTask task) { m_RunningResourceLoadingTasks.Remove(task); task.OnReset(); m_ResourceLoadingTaskPool.Release(task); }