#include <msp/debug/demangle.h>
#include <msp/strings/format.h>
#include <msp/time/utils.h>
+#include "error.h"
#include "resourcemanager.h"
#include "resources.h"
#include "resourceobserver.h"
{ }
-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();
async_loads = a;
}
-void ResourceManager::set_size_limit(UInt64 s)
+void ResourceManager::set_size_limit(uint64_t s)
{
size_limit = s;
}
void ResourceManager::add_resource(Resource &r)
{
+ if(r.get_manager()!=this)
+ throw invalid_operation("ResourceManager::add_resource");
MutexLock lock(map_mutex);
insert_unique(resources, &r, ManagedResource(r));
}
+void ResourceManager::move_resource(Resource &from, Resource &to)
+{
+ if(to.get_manager()!=this || from.get_manager_data()!=to.get_manager_data())
+ throw invalid_operation("ResourceManager::move_resource");
+ ManagedResource *managed = reinterpret_cast<ManagedResource *>(to.get_manager_data());
+ MutexLock lock(map_mutex);
+ insert_unique(resources, &to, *managed);
+ resources.erase(&from);
+}
+
const ResourceManager::ManagedResource &ResourceManager::get_managed_resource(const Resource &r) const
{
MutexLock lock(map_mutex);
void ResourceManager::dispatch_work()
{
- queue.sort(age_order);
+ sort(queue, age_order);
if(queue.front()->last_used+min_retain_frames<frame)
{
while(total_data_size>size_limit)
{
ManagedResource *best = 0;
- UInt64 best_impact = 0;
+ uint64_t best_impact = 0;
for(auto &kvp: resources)
if(kvp.second.state==ManagedResource::LOADED && kvp.second.last_used<unload_limit)
{
- UInt64 impact = kvp.second.data_size*(frame-kvp.second.last_used);
+ uint64_t impact = kvp.second.data_size*(frame-kvp.second.last_used);
if(!best || impact>best_impact)
{
best = &kvp.second;
catch(const exception &e)
{
MutexLock lock(queue_mutex);
- error_queue.push_back(resource_load_error(managed->location.name, e));
+ error_queue.emplace_back(managed->location.name, e);
managed->state = ManagedResource::LOAD_ERROR;
}
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
}
}
-ResourceManager::ManagedResource *ResourceManager::LoadingThread::front(list<ManagedResource *> &que)
+ResourceManager::ManagedResource *ResourceManager::LoadingThread::front(deque<ManagedResource *> &que)
{
MutexLock lock(queue_mutex);
if(que.empty())
{
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();
}
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;
}