295 lines
8.1 KiB
C++
295 lines
8.1 KiB
C++
|
|
|
|
//Qt includes
|
|
#include <QMap>
|
|
#include <QSettings>
|
|
#include <QDate>
|
|
#include <QDir>
|
|
#include <QFileInfo>
|
|
#include <QFileInfoList>
|
|
|
|
//#define USE_SQLITE_HDPOOL
|
|
|
|
#ifdef USE_SQLITE_HDPOOL
|
|
//SQLite include
|
|
#include "sqlite/sqlite3.h"
|
|
#endif
|
|
|
|
#include "tcacheresourcepool.h"
|
|
|
|
//Debug
|
|
//#define DIAGNOSTICS
|
|
//#include "diagnostics.h"
|
|
|
|
//******************************************************************************************
|
|
// Cache Resource Pool BACKED ON DISK
|
|
//******************************************************************************************
|
|
|
|
//STILL UNDER DEVELOPMENT...
|
|
class THDCacheResourcePool
|
|
{
|
|
public:
|
|
THDCacheResourcePool() {}
|
|
~THDCacheResourcePool() {}
|
|
};
|
|
|
|
//*************************************************************************************
|
|
// Cache resource pool methods involved with HD Pool management
|
|
//*************************************************************************************
|
|
|
|
inline bool TCacheResourcePool::isHDActive()
|
|
{
|
|
#ifdef USE_SQLITE_HDPOOL
|
|
return m_hdPool && m_hdPool->isActive();
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
void TCacheResourcePool::reset()
|
|
{
|
|
setPath("", "", "");
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Prevents the resources in memory from backing to disk. Observe that
|
|
// the actual content of the resource is NOT invalidated - since resources
|
|
// are intended as 'reference-protected' material which is expected to last
|
|
// as long as references are held.
|
|
void TCacheResourcePool::invalidateAll()
|
|
{
|
|
QMutexLocker locker(&m_memMutex);
|
|
|
|
MemResources::iterator it;
|
|
for (it = m_memResources.begin(); it != m_memResources.end(); ++it)
|
|
it->second->invalidate();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
inline QString TCacheResourcePool::getPoolRoot(QString cacheRoot, QString projectName, QString sceneName)
|
|
{
|
|
return QString(cacheRoot + "/render/" + projectName + "/" + sceneName + "/");
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
//! Connects to the pool associated to the given project/scene pair.
|
|
//! \warning As this closes the current connection before opening a new one,
|
|
//! make sure that no pool access happens at this point. You should also
|
|
//! verify that no resource from the old pair still exists.
|
|
void TCacheResourcePool::setPath(QString cacheRoot, QString projectName, QString sceneName)
|
|
{
|
|
//There should be no resource in memory.
|
|
assert(m_memResources.empty());
|
|
|
|
//However, just in case, invalidate all resources so that no more resource backing
|
|
//operation take place for current resources, from now on.
|
|
//No care is paid as to whether active transactions currently exist. You
|
|
//have been warned by the way....
|
|
invalidateAll();
|
|
|
|
delete m_hdPool;
|
|
m_hdPool = 0;
|
|
m_path = TFilePath();
|
|
|
|
#ifdef USE_SQLITE_HDPOOL
|
|
|
|
if (!(cacheRoot.isEmpty() || projectName.isEmpty() || sceneName.isEmpty())) {
|
|
QString hdPoolRoot(getPoolRoot(cacheRoot, projectName, sceneName));
|
|
m_hdPool = new THDCacheResourcePool(hdPoolRoot);
|
|
m_path = m_hdPool->getResourcesFilePath();
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
void TCacheResourcePool::startBacking(TCacheResource *resource)
|
|
{
|
|
assert(isHDActive());
|
|
if (!isHDActive())
|
|
return;
|
|
|
|
#ifdef USE_SQLITE_HDPOOL
|
|
|
|
resource->m_backEnabled = true;
|
|
|
|
m_hdPool->buildBackingPath(resource);
|
|
|
|
#endif
|
|
}
|
|
|
|
//******************************************************************************************
|
|
// Cache resource pool implementation
|
|
//******************************************************************************************
|
|
|
|
TCacheResourcePool *TCacheResourcePool::instance()
|
|
{
|
|
static TCacheResourcePool theInstance;
|
|
return &theInstance;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
TCacheResourcePool::TCacheResourcePool()
|
|
: m_memMutex(QMutex::Recursive), m_searchCount(0), m_foundIterator(false), m_searchIterator(m_memResources.end()), m_hdPool(0), m_path()
|
|
{
|
|
//Open the settings for cache retrieval
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
TCacheResourcePool::~TCacheResourcePool()
|
|
{
|
|
//Temporary
|
|
//performAutomaticCleanup();
|
|
|
|
delete m_hdPool;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
const TFilePath &TCacheResourcePool::getPath() const
|
|
{
|
|
return m_path;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
//! Initializes an optimized search on the pool for a specific resource, caching successive
|
|
//! results.
|
|
//! \note Pool searches are serialized, and calls to this method lock the pool's mutex until a
|
|
//! corresponding number of endCachedSearch() methods are invoked.
|
|
void TCacheResourcePool::beginCachedSearch()
|
|
{
|
|
m_memMutex.lock();
|
|
m_searchCount++;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
//! The inverse to beginCachedSearch(). This method \b MUST be called in correspondence to
|
|
//! beginCachedSearch() calls.
|
|
void TCacheResourcePool::endCachedSearch()
|
|
{
|
|
if (--m_searchCount <= 0) {
|
|
m_foundIterator = false;
|
|
m_searchIterator = m_memResources.end();
|
|
}
|
|
m_memMutex.unlock();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
//! Attempts retrieval of the resource with specified name, and eventually creates it if
|
|
//! the createIfNone parameter is set.
|
|
TCacheResource *TCacheResourcePool::getResource(const std::string &name, bool createIfNone)
|
|
{
|
|
//DIAGNOSTICS_TIMER("#times.txt | getResource Overall time");
|
|
//DIAGNOSTICS_MEANTIMER("#times.txt | getResource Mean time");
|
|
|
|
TCacheResource *result = 0;
|
|
|
|
//NOTA: Passa ad un oggetto lockatore. Quello e' in grado di gestire i casi di eccezioni ecc..
|
|
beginCachedSearch();
|
|
|
|
//Search for an already allocated resource
|
|
if (m_searchIterator == m_memResources.end()) {
|
|
m_searchIterator = m_memResources.lower_bound(name);
|
|
if (m_searchIterator != m_memResources.end())
|
|
if (!(name < m_searchIterator->first))
|
|
m_foundIterator = true;
|
|
else if (m_searchIterator != m_memResources.begin())
|
|
m_searchIterator--;
|
|
}
|
|
|
|
if (m_foundIterator) {
|
|
result = m_searchIterator->second;
|
|
|
|
endCachedSearch();
|
|
return result;
|
|
}
|
|
|
|
{
|
|
QString resourcePath;
|
|
QString resourceFlags;
|
|
|
|
if (isHDActive()) {
|
|
#ifdef USE_SQLITE_HDPOOL
|
|
|
|
//DIAGNOSTICS_TIMER("#times.txt | HDPOOL getResource Overall time");
|
|
//DIAGNOSTICS_MEANTIMER("#times.txt | HDPOOL getResource Mean time");
|
|
|
|
//Search in the HD pool
|
|
ReadQuery query(m_hdPool);
|
|
|
|
bool ret = query.prepare(
|
|
"SELECT Path, Flags FROM Resources WHERE Name = '" + QString::fromStdString(name) + "';");
|
|
|
|
//If an error occurred, assume the resource does not exist. Doing nothing works fine.
|
|
assert(ret);
|
|
|
|
if (query.step()) {
|
|
resourcePath = query.value(0);
|
|
resourceFlags = query.value(1);
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
if (!resourcePath.isEmpty() || createIfNone) {
|
|
TCacheResource *result = new TCacheResource;
|
|
result->m_pos = m_searchIterator =
|
|
m_memResources.insert(m_searchIterator, std::make_pair(name, result));
|
|
|
|
//DIAGNOSTICS_STRSET("#resources.txt | RISORSE | " + QString::number((UINT) result) + " | Name",
|
|
//QString::fromStdString(name).left(70));
|
|
|
|
#ifdef USE_SQLITE_HDPOOL
|
|
if (isHDActive())
|
|
m_hdPool->loadResourceInfos(result, resourcePath);
|
|
#endif
|
|
|
|
m_foundIterator = true;
|
|
endCachedSearch();
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
endCachedSearch();
|
|
return 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
void TCacheResourcePool::releaseResource(TCacheResource *resource)
|
|
{
|
|
QMutexLocker locker(&m_memMutex);
|
|
|
|
//Re-check the resource's reference count. This is necessary since a concurrent
|
|
//thread may have locked the memMutex for resource retrieval BEFORE this one.
|
|
//If that is the case, the resource's refCount has increased back above 0.
|
|
if (resource->m_refCount > 0)
|
|
return;
|
|
|
|
#ifdef USE_SQLITE_HDPOOL
|
|
QMutexLocker flushLocker(isHDActive() ? &m_hdPool->m_flushMutex : 0);
|
|
|
|
if (isHDActive()) {
|
|
//Flush all resource updates as this resource is being destroyed
|
|
m_hdPool->flushResources();
|
|
|
|
//Save the resource infos
|
|
m_hdPool->saveResourceInfos(resource);
|
|
}
|
|
#endif
|
|
|
|
m_memResources.erase(resource->m_pos);
|
|
delete resource;
|
|
}
|