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);
}
