Mirrors/overte-HifiExperiments
3
0
Fork 0
mirror of https://github.com/HifiExperiments/overte.git synced 2025-08-05 06:20:03 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add lock on ResourceCache data structs

Browse source
This commit is contained in:
Atlante45 2016-04-11 10:07:55 -07:00
parent 88ca5520be
commit 7c652aa3ca
2 changed files with 36 additions and 11 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
libraries/networking/src/ResourceCache.cpp
View file

@ -39,20 +39,30 @@ void ResourceCache::refreshAll() {
// Clear all unused resources so we don't have to reload them
clearUnusedResource();
resetResourceCounters();
_resourcesLock.lockForRead();
auto resourcesCopy = _resources;
_resourcesLock.unlock();
// Refresh all remaining resources in use
foreach (auto resource, _resources) {
if (!resource.isNull()) {
resource.data()->refresh();
foreach (QSharedPointer<Resource> resource, resourcesCopy) {
if (resource) {
resource->refresh();
}
}
}
void ResourceCache::refresh(const QUrl& url) {
QSharedPointer<Resource> resource = _resources.value(url);
if (!resource.isNull()) {
QSharedPointer<Resource> resource;
{
QReadLocker locker(&_resourcesLock);
resource = _resources.value(url).lock();
}
if (resource) {
resource->refresh();
} else {
QWriteLocker locker(&_resourcesLock);
_resources.remove(url);
resetResourceCounters();
}
@ -103,8 +113,12 @@ void ResourceCache::checkAsynchronousGets() {
QSharedPointer<Resource> ResourceCache::getResource(const QUrl& url, const QUrl& fallback,
bool delayLoad, void* extra) {
QSharedPointer<Resource> resource = _resources.value(url);
if (!resource.isNull()) {
QSharedPointer<Resource> resource;
{
QReadLocker locker(&_resourcesLock);
resource = _resources.value(url).lock();
}
if (resource) {
removeUnusedResource(resource);
return resource;
}
@ -123,7 +137,10 @@ QSharedPointer<Resource> ResourceCache::getResource(const QUrl& url, const QUrl&
getResource(fallback, QUrl(), true) : QSharedPointer<Resource>(), delayLoad, extra);
resource->setSelf(resource);
resource->setCache(this);
_resources.insert(url, resource);
{
QWriteLocker locker(&_resourcesLock);
_resources.insert(url, resource);
}
removeUnusedResource(resource);
resource->ensureLoading();
@ -145,13 +162,16 @@ void ResourceCache::addUnusedResource(const QSharedPointer<Resource>& resource)
reserveUnusedResource(resource->getBytes());
resource->setLRUKey(++_lastLRUKey);
_unusedResources.insert(resource->getLRUKey(), resource);
_unusedResourcesSize += resource->getBytes();
resetResourceCounters();
QWriteLocker locker(&_unusedResourcesLock);
_unusedResources.insert(resource->getLRUKey(), resource);
}
void ResourceCache::removeUnusedResource(const QSharedPointer<Resource>& resource) {
QWriteLocker locker(&_unusedResourcesLock);
if (_unusedResources.contains(resource->getLRUKey())) {
_unusedResources.remove(resource->getLRUKey());
_unusedResourcesSize -= resource->getBytes();
@ -160,6 +180,7 @@ void ResourceCache::removeUnusedResource(const QSharedPointer<Resource>& resourc
}
void ResourceCache::reserveUnusedResource(qint64 resourceSize) {
QWriteLocker locker(&_unusedResourcesLock);
while (!_unusedResources.empty() &&
_unusedResourcesSize + resourceSize > _unusedResourcesMaxSize) {
// unload the oldest resource
@ -179,6 +200,7 @@ void ResourceCache::reserveUnusedResource(qint64 resourceSize) {
void ResourceCache::clearUnusedResource() {
// the unused resources may themselves reference resources that will be added to the unused
// list on destruction, so keep clearing until there are no references left
QWriteLocker locker(&_unusedResourcesLock);
while (!_unusedResources.isEmpty()) {
foreach (const QSharedPointer<Resource>& resource, _unusedResources) {
resource->setCache(nullptr);
@ -422,6 +444,7 @@ void Resource::setSize(const qint64& bytes) {
}
void Resource::reinsert() {
QWriteLocker locker(&_cache->_resourcesLock);
_cache->_resources.insert(_url, _self);
}

4
libraries/networking/src/ResourceCache.h
View file

@ -154,6 +154,7 @@ private:
void clearUnusedResource();
void resetResourceCounters();
QReadWriteLock _resourcesLock { QReadWriteLock::Recursive };
QHash<QUrl, QWeakPointer<Resource>> _resources;
int _lastLRUKey = 0;
@ -161,7 +162,7 @@ private:
static int _requestsActive;
void getResourceAsynchronously(const QUrl& url);
QReadWriteLock _resourcesToBeGottenLock;
QReadWriteLock _resourcesToBeGottenLock { QReadWriteLock::Recursive };
QQueue<QUrl> _resourcesToBeGotten;
std::atomic<size_t> _numTotalResources { 0 };
@ -171,6 +172,7 @@ private:
std::atomic<qint64> _unusedResourcesSize { 0 };
qint64 _unusedResourcesMaxSize = DEFAULT_UNUSED_MAX_SIZE;
QReadWriteLock _unusedResourcesLock { QReadWriteLock::Recursive };
QMap<int, QSharedPointer<Resource>> _unusedResources;
};