X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fresources%2Fresourcemanager.cpp;h=f25e6ad1db1b53e609b68cf8d8d9559848da7b66;hp=30f75013252fe2397819cb5cb5a49330e54347de;hb=38712d8ecc57d043a2419ffbaeeb57f7a6586f14;hpb=7aaec9a70b8d7733429bec043f8e33e02956f266 diff --git a/source/resources/resourcemanager.cpp b/source/resources/resourcemanager.cpp index 30f75013..f25e6ad1 100644 --- a/source/resources/resourcemanager.cpp +++ b/source/resources/resourcemanager.cpp @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -21,17 +21,6 @@ resource_load_error::resource_load_error(const string &name, const exception &ex { } -ResourceManager::ResourceManager(): - policy(LOAD_ON_DEMAND), - async_loads(true), - total_data_size(0), - size_limit(0), - frame(0), - min_retain_frames(30), - max_retain_frames(0), - next_unload(0) -{ } - ResourceManager::~ResourceManager() { thread.terminate(); @@ -50,7 +39,7 @@ void ResourceManager::set_async_loads(bool a) async_loads = a; } -void ResourceManager::set_size_limit(UInt64 s) +void ResourceManager::set_size_limit(uint64_t s) { size_limit = s; } @@ -118,8 +107,7 @@ void ResourceManager::load_resource(Resource &r) if(async_loads) { managed.state = ManagedResource::LOAD_QUEUED; - LoadQueue::iterator i; - for(i=queue.begin(); (i!=queue.end() && (*i)->load_priority>=managed.load_priority); ++i) ; + auto i = find_if(queue, [&managed](ManagedResource *q){ return q->load_priority>managed.load_priority; }); queue.insert(i, &managed); } else @@ -156,15 +144,15 @@ void ResourceManager::remove_resource(Resource &r) ManagedResource::State state = managed.state; if(state==ManagedResource::LOAD_QUEUED) { - LoadQueue::iterator i = find(queue.begin(), queue.end(), &managed); + auto i = find(queue, &managed); if(i!=queue.end()) queue.erase(i); } else if(state>ManagedResource::LOAD_QUEUED && state::const_iterator i=managed.observers.begin(); i!=managed.observers.end(); ++i) - (*i)->resource_removed(r); + for(ResourceObserver *o: managed.observers) + o->resource_removed(r); MutexLock lock(map_mutex); remove_existing(resources, &r); @@ -202,9 +190,9 @@ void ResourceManager::tick() unload_by_age(); next_unload = frame; - for(ResourceMap::iterator i=resources.begin(); i!=resources.end(); ++i) - if(i->second.state==ManagedResource::LOADED) - next_unload = min(next_unload, i->second.last_used); + for(const auto &kvp: resources) + if(kvp.second.state==ManagedResource::LOADED) + next_unload = min(next_unload, kvp.second.last_used); next_unload = (next_unloadlast_used+min_retain_framesstate = ManagedResource::NOT_LOADED; + for(ManagedResource *r: queue) + r->state = ManagedResource::NOT_LOADED; queue.clear(); return; } @@ -237,11 +225,11 @@ void ResourceManager::unload_by_age() { unsigned unload_limit = frame-max_retain_frames; - for(ResourceMap::iterator i=resources.begin(); i!=resources.end(); ++i) - if(i->second.state==ManagedResource::LOADED && i->second.last_usedsecond.unload(); - total_data_size -= i->second.data_size; + kvp.second.unload(); + total_data_size -= kvp.second.data_size; } } @@ -252,14 +240,14 @@ void ResourceManager::unload_by_size() while(total_data_size>size_limit) { ManagedResource *best = 0; - UInt64 best_impact = 0; - for(ResourceMap::iterator i=resources.begin(); i!=resources.end(); ++i) - if(i->second.state==ManagedResource::LOADED && i->second.last_usedsecond.data_size*(frame-i->second.last_used); + uint64_t impact = kvp.second.data_size*(frame-kvp.second.last_used); if(!best || impact>best_impact) { - best = &i->second; + best = &kvp.second; best_impact = impact; } } @@ -336,8 +324,8 @@ void ResourceManager::ManagedResource::finish_loading(bool successful) state = LOADED; data_size = resource->get_data_size(); - for(vector::const_iterator i=observers.begin(); i!=observers.end(); ++i) - (*i)->resource_loaded(*resource); + for(ResourceObserver *o: observers) + o->resource_loaded(*resource); } else { @@ -356,8 +344,8 @@ void ResourceManager::ManagedResource::unload() resource->unload(); state = NOT_LOADED; - for(vector::const_iterator i=observers.begin(); i!=observers.end(); ++i) - (*i)->resource_unloaded(*resource); + for(ResourceObserver *o: observers) + o->resource_unloaded(*resource); } void ResourceManager::ManagedResource::add_observer(ResourceObserver &w) @@ -368,7 +356,7 @@ void ResourceManager::ManagedResource::add_observer(ResourceObserver &w) void ResourceManager::ManagedResource::remove_observer(ResourceObserver &w) { - vector::iterator end = remove(observers.begin(), observers.end(), &w); + auto end = remove(observers.begin(), observers.end(), &w); if(end!=observers.end()) observers.erase(end, observers.end()); } @@ -407,7 +395,8 @@ void ResourceManager::LoadingThread::main() } MutexLock lock(queue_mutex); - sync_queue.splice(sync_queue.end(), async_queue, async_queue.begin()); + sync_queue.push_back(async_queue.front()); + async_queue.pop_front(); wait_for_work = async_queue.empty(); } else @@ -415,7 +404,7 @@ void ResourceManager::LoadingThread::main() } } -ResourceManager::ManagedResource *ResourceManager::LoadingThread::front(LoadQueue &que) +ResourceManager::ManagedResource *ResourceManager::LoadingThread::front(deque &que) { MutexLock lock(queue_mutex); if(que.empty()) @@ -459,10 +448,10 @@ bool ResourceManager::LoadingThread::try_remove_resource(ManagedResource &r) { MutexLock lock(queue_mutex); - LoadQueue::iterator i = find(async_queue.begin(), async_queue.end(), &r); + auto i = find(async_queue, &r); if(i==async_queue.end()) { - i = find(sync_queue.begin(), sync_queue.end(), &r); + i = find(sync_queue, &r); if(i!=sync_queue.end()) { sync_queue.erase(i); @@ -520,7 +509,8 @@ bool ResourceManager::LoadingThread::sync() { MutexLock lock(queue_mutex); bool was_empty = async_queue.empty(); - async_queue.splice(async_queue.end(), sync_queue, sync_queue.begin()); + async_queue.push_back(sync_queue.front()); + sync_queue.pop_front(); if(was_empty) sem.signal(); } @@ -529,10 +519,10 @@ bool ResourceManager::LoadingThread::sync() return any_finished; } -UInt64 ResourceManager::LoadingThread::get_and_reset_loaded_data_size() +uint64_t ResourceManager::LoadingThread::get_and_reset_loaded_data_size() { MutexLock lock(data_size_mutex); - UInt64 result = loaded_data_size; + uint64_t result = loaded_data_size; loaded_data_size = 0; return result; }