298 lines
10 KiB
C++
298 lines
10 KiB
C++
#ifndef GCACHE_CACHE_H
|
|
#define GCACHE_CACHE_H
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
typedef __int16 int16_t;
|
|
typedef unsigned __int16 uint16_t;
|
|
typedef __int32 int32_t;
|
|
typedef unsigned __int32 uint32_t;
|
|
typedef __int64 int64_t;
|
|
typedef unsigned __int64 uint64_t;
|
|
|
|
#else
|
|
#include <stdint.h>
|
|
#endif
|
|
|
|
#include <iostream>
|
|
#include <limits.h>
|
|
#include <vector>
|
|
#include <list>
|
|
|
|
#include "token.h"
|
|
|
|
#include <wrap/system/multithreading/mt.h>
|
|
#include <wrap/system/multithreading/atomic_int.h>
|
|
|
|
#include "provider.h"
|
|
|
|
using namespace std;
|
|
/* this cache system enforce the rule that the items in a cache are always in all the cache below */
|
|
/* two mechanism to remove tokens from the cache:
|
|
1) set token count to something low
|
|
2) set maximum number of tokens in the provider
|
|
*/
|
|
|
|
/** Cache virtual base class. You are required to implement the pure virtual functions get, drop and size.
|
|
*/
|
|
|
|
namespace vcg {
|
|
|
|
template <typename Token> class Transfer;
|
|
|
|
template <typename Token>
|
|
class Cache: public Provider<Token> {
|
|
|
|
public:
|
|
///true if this is the last cache (the one we use the data from)
|
|
bool final;
|
|
//if true the cache will exit at the first opportunity
|
|
bool quit;
|
|
///keeps track of changes (if 1 then something was loaded or dropped
|
|
mt::atomicInt new_data;
|
|
///callback for new_data
|
|
void (*callback)(void *data);
|
|
|
|
///data is fetched from here
|
|
Provider<Token> *input;
|
|
|
|
///threads running over cache...
|
|
std::vector<Transfer<Token> *> transfers;
|
|
|
|
protected:
|
|
///max space available
|
|
uint64_t s_max;
|
|
///current space used
|
|
uint64_t s_curr;
|
|
|
|
public:
|
|
Cache(uint64_t _capacity = INT_MAX):
|
|
final(false), quit(false), new_data(false), input(NULL), s_max(_capacity), s_curr(0) {}
|
|
virtual ~Cache() {}
|
|
|
|
void setInputCache(Provider<Token> *p) { input = p; }
|
|
uint64_t capacity() { return s_max; }
|
|
uint64_t size() { return s_curr; }
|
|
void setCapacity(uint64_t c) { s_max = c; }
|
|
|
|
///return true if the cache is waiting for priority to change
|
|
bool newData() {
|
|
bool r = new_data.testAndSetOrdered(1, 0); //if changed is 1, r is true
|
|
return r;
|
|
}
|
|
|
|
///empty the cache. Make sure no resource is locked before calling this.
|
|
/// Require pause or stop before. Ensure there no locked item
|
|
void flush() {
|
|
//std::vector<Token *> tokens;
|
|
{
|
|
for(int i = 0; i < this->heap.size(); i++) {
|
|
Token *token = &(this->heap[i]);
|
|
//tokens.push_back(token);
|
|
s_curr -= drop(token);
|
|
//assert(!(token->count.load() >= Token::LOCKED));
|
|
if(final)
|
|
token->count.testAndSetOrdered(Token::READY, Token::CACHE);
|
|
input->heap.push(token);
|
|
}
|
|
this->heap.clear();
|
|
}
|
|
if(!s_curr == 0) {
|
|
std::cerr << "Cache size after flush is not ZERO!\n";
|
|
s_curr = 0;
|
|
}
|
|
}
|
|
|
|
///empty the cache. Make sure no resource is locked before calling this.
|
|
/// Require pause or stop before. Ensure there no locked item
|
|
template <class FUNCTOR> void flush(FUNCTOR functor) {
|
|
std::vector<Token *> tokens;
|
|
{
|
|
int count = 0;
|
|
mt::mutexlocker locker(&(this->heap_lock));
|
|
for(int k = 0; k < this->heap.size(); k++) {
|
|
Token *token = &this->heap[k];
|
|
if(functor(token)) { //drop it
|
|
tokens.push_back(token);
|
|
s_curr -= drop(token);
|
|
//assert(token->count.load() < Token::LOCKED);
|
|
if(final)
|
|
token->count.testAndSetOrdered(Token::READY, Token::CACHE);
|
|
} else
|
|
this->heap.at(count++) = token;
|
|
}
|
|
this->heap.resize(count);
|
|
this->heap_dirty = true;
|
|
}
|
|
{
|
|
mt::mutexlocker locker(&(input->heap_lock));
|
|
for(unsigned int i = 0; i < tokens.size(); i++) {
|
|
input->heap.push(tokens[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void abort() {}
|
|
|
|
protected:
|
|
///return the space used in the cache by the loaded resource
|
|
virtual int size(Token *token) = 0;
|
|
///returns amount of space used in cache -1 for failed transfer
|
|
virtual int get(Token *token) = 0;
|
|
///return amount removed
|
|
virtual int drop(Token *token) = 0;
|
|
///make sure the get function do not access token after abort is returned.
|
|
|
|
|
|
|
|
|
|
///called in as first thing in run()
|
|
virtual void begin() {}
|
|
virtual void middle() {}
|
|
///called in as last thing in run()
|
|
virtual void end() {}
|
|
|
|
///[should be protected]
|
|
void run() {
|
|
assert(input);
|
|
/* basic operation of the cache:
|
|
1) make room until eliminating an element would leave empty space.
|
|
2) transfer first element of input_cache if
|
|
cache has room OR first element in input has higher priority of last element */
|
|
begin();
|
|
while(!this->quit) {
|
|
input->check_queue.enter(); //wait for cache below to load something or priorities to change
|
|
if(this->quit) break;
|
|
|
|
middle();
|
|
|
|
if(unload() || load()) {
|
|
new_data.testAndSetOrdered(0, 1); //if not changed, set as changed
|
|
input->check_queue.open(); //we signal ourselves to check again
|
|
cout << "loaded or unloaded\n";
|
|
}
|
|
input->check_queue.leave();
|
|
}
|
|
this->quit = false; //in case someone wants to restart;
|
|
end();
|
|
}
|
|
|
|
|
|
|
|
/** Checks wether we need to make room in the cache because of:
|
|
size() - sizeof(lowest priority item) > capacity()
|
|
**/
|
|
bool unload() {
|
|
Token *remove = NULL;
|
|
//make room int the cache checking that:
|
|
//1 we need to make room (capacity < current)
|
|
if(size() > capacity()) {
|
|
mt::mutexlocker locker(&(this->heap_lock));
|
|
|
|
//2 we have some element not in the upper caches (heap.size() > 0
|
|
if(this->heap.size()) {
|
|
Token &last = this->heap.min();
|
|
int itemsize = size(&last);
|
|
|
|
//3 after removing the item, we are still full (avoids bouncing items)
|
|
if(size() - itemsize > capacity()) {
|
|
|
|
//4 item to remove is not locked. (only in last cache. you can't lock object otherwise)
|
|
if(!final) { //not final we can drop when we want
|
|
remove = this->heap.popMin();
|
|
} else {
|
|
last.count.testAndSetOrdered(Token::READY, Token::CACHE);
|
|
#if(QT_VERSION < 0x050000)
|
|
int last_count = last.count;
|
|
#else
|
|
int last_count = last.count.load();
|
|
#endif
|
|
if(last_count <= Token::CACHE) { //was not locked and now can't be locked, remove it.
|
|
remove = this->heap.popMin();
|
|
} else { //last item is locked need to reorder stack
|
|
remove = this->heap.popMin();
|
|
this->heap.push(remove);
|
|
cout << "Reordering stack something (what?)\n";
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(remove) {
|
|
{
|
|
mt::mutexlocker input_locker(&(input->heap_lock));
|
|
int size = drop(remove);
|
|
assert(size >= 0);
|
|
s_curr -= size;
|
|
input->heap.push(remove);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
///should be protected
|
|
bool load() {
|
|
Token *insert = NULL;
|
|
Token *last = NULL; //we want to lock only one heap at once to avoid deadlocks.
|
|
|
|
/* check wether we have room (curr < capacity) or heap is empty.
|
|
empty heap is bad: we cannot drop anything to make room, and cache above has nothing to get.
|
|
this should not happen if we set correct cache sizes, but if it happens.... */
|
|
{
|
|
mt::mutexlocker locker(&(this->heap_lock));
|
|
this->rebuild();
|
|
if(size() > capacity() && this->heap.size() > 0) {
|
|
last = &(this->heap.min()); //no room, set last so we might check for a swap.
|
|
}
|
|
}
|
|
|
|
{
|
|
mt::mutexlocker input_locker(&(input->heap_lock));
|
|
input->rebuild(); //if dirty rebuild
|
|
if(input->heap.size()) { //we need something in input to tranfer.
|
|
Token &first = input->heap.max();
|
|
#if(QT_VERSION < 0x050000)
|
|
int first_count = first.count;
|
|
#else
|
|
int first_count = first.count.load();
|
|
#endif
|
|
if(first_count > Token::REMOVE &&
|
|
(!last || first.priority > last->priority)) { //if !last we already decided we want a transfer., otherwise check for a swap
|
|
insert = input->heap.popMax(); //remove item from heap, while we transfer it.
|
|
}
|
|
}
|
|
}
|
|
|
|
if(insert) { //we want to fetch something
|
|
|
|
int size = get(insert);
|
|
|
|
if(size >= 0) { //success
|
|
s_curr += size;
|
|
{
|
|
mt::mutexlocker locker(&(this->heap_lock));
|
|
if(final)
|
|
insert->count.ref(); //now lock is 0 and can be locked
|
|
|
|
this->heap.push(insert);
|
|
}
|
|
this->check_queue.open(); //we should signal the parent cache that we have a new item
|
|
return true;
|
|
|
|
} else { //failed transfer put it back, we will keep trying to transfer it...
|
|
mt::mutexlocker input_locker(&(input->heap_lock));
|
|
input->heap.push(insert);
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
} //namespace
|
|
|
|
#endif // GCACHE_H
|