#ifndef MSP_GL_RESOURCEMANAGER_H_
#define MSP_GL_RESOURCEMANAGER_H_
-#include <msp/core/inttypes.h>
+#include <deque>
+#include <cstdint>
#include <msp/core/mutex.h>
+#include <msp/core/noncopyable.h>
#include <msp/core/semaphore.h>
#include <msp/core/thread.h>
#include <msp/datafile/collection.h>
};
-class ResourceManager
+class ResourceManager: public NonCopyable
{
public:
enum LoadingPolicy
Resource::AsyncLoader *loader;
State state;
unsigned last_used;
- UInt64 data_size;
+ std::uint64_t data_size;
std::vector<ResourceObserver *> observers;
ManagedResource(Resource &);
class LoadingThread: public Thread
{
private:
- Semaphore sem;
+ Msp::Semaphore sem;
Mutex queue_mutex;
- std::list<ManagedResource *> async_queue;
- std::list<ManagedResource *> sync_queue;
+ std::deque<ManagedResource *> async_queue;
+ std::deque<ManagedResource *> sync_queue;
unsigned capacity;
unsigned size;
std::list<resource_load_error> error_queue;
Mutex data_size_mutex;
- UInt64 loaded_data_size;
+ std::uint64_t loaded_data_size;
volatile bool done;
public:
private:
virtual void main();
- ManagedResource *front(std::list<ManagedResource *> &);
+ ManagedResource *front(std::deque<ManagedResource *> &);
public:
void add_resource(ManagedResource &);
public:
bool sync();
bool needs_work() const { return size<capacity; }
- UInt64 get_and_reset_loaded_data_size();
+ std::uint64_t get_and_reset_loaded_data_size();
void terminate();
};
- LoadingPolicy policy;
- bool async_loads;
+ LoadingPolicy policy = LOAD_ON_DEMAND;
+ bool async_loads = true;
mutable Mutex map_mutex;
std::map<const Resource *, ManagedResource> resources;
- std::list<ManagedResource *> queue;
- UInt64 total_data_size;
- UInt64 size_limit;
- unsigned frame;
- unsigned min_retain_frames;
- unsigned max_retain_frames;
- unsigned next_unload;
+ std::deque<ManagedResource *> queue;
+ std::uint64_t total_data_size = 0;
+ std::uint64_t size_limit = 0;
+ unsigned frame = 0;
+ unsigned min_retain_frames = 30;
+ unsigned max_retain_frames = 0;
+ unsigned next_unload = 0;
LoadingThread thread;
public:
- ResourceManager();
~ResourceManager();
void set_loading_policy(LoadingPolicy);
void set_async_loads(bool);
- void set_size_limit(UInt64);
+ void set_size_limit(std::uint64_t);
void set_min_retain_frames(unsigned);
void set_max_retain_frames(unsigned);
void add_resource(Resource &);
+ void move_resource(Resource &, Resource &);
private:
const ManagedResource &get_managed_resource(const Resource &) const;
ManagedResource &get_managed_resource(const Resource &);
void unload_by_age();
void unload_by_size();
public:
- UInt64 get_total_data_size() const { return total_data_size; }
+ std::uint64_t get_total_data_size() const { return total_data_size; }
private:
static bool age_order(ManagedResource *, ManagedResource *);