244 lines
7 KiB
C++
244 lines
7 KiB
C++
|
|
|
|
#include "trenderer.h"
|
|
#include "trasterfx.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include "tpredictivecachemanager.h"
|
|
|
|
//************************************************************************************************
|
|
// Preliminaries
|
|
//************************************************************************************************
|
|
|
|
class TPredictiveCacheManagerGenerator : public TRenderResourceManagerGenerator
|
|
{
|
|
public:
|
|
TPredictiveCacheManagerGenerator() : TRenderResourceManagerGenerator(true) {}
|
|
|
|
TRenderResourceManager *operator()(void)
|
|
{
|
|
return new TPredictiveCacheManager;
|
|
}
|
|
};
|
|
|
|
MANAGER_FILESCOPE_DECLARATION_DEP(
|
|
TPredictiveCacheManager,
|
|
TPredictiveCacheManagerGenerator,
|
|
TFxCacheManager::deps())
|
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
TPredictiveCacheManager *TPredictiveCacheManager::instance()
|
|
{
|
|
return static_cast<TPredictiveCacheManager *>(
|
|
//TPredictiveCacheManager::gen()->getManager(TRenderer::instance())
|
|
TPredictiveCacheManager::gen()->getManager(TRenderer::renderId()));
|
|
}
|
|
|
|
//************************************************************************************************
|
|
// TPredictiveCacheManager::Imp definition
|
|
//************************************************************************************************
|
|
|
|
//=======================
|
|
// PredictionData
|
|
//-----------------------
|
|
|
|
struct PredictionData {
|
|
const ResourceDeclaration *m_decl;
|
|
int m_usageCount;
|
|
|
|
PredictionData(const ResourceDeclaration *declaration)
|
|
: m_decl(declaration), m_usageCount(1) {}
|
|
};
|
|
|
|
//============================================================================================
|
|
|
|
//=====================================
|
|
// TPredictiveCacheManager::Imp
|
|
//-------------------------------------
|
|
|
|
class TPredictiveCacheManager::Imp
|
|
{
|
|
public:
|
|
int m_renderStatus;
|
|
bool m_enabled;
|
|
|
|
std::map<TCacheResourceP, PredictionData> m_resources;
|
|
QMutex m_mutex;
|
|
|
|
public:
|
|
Imp()
|
|
: m_renderStatus(TRenderer::IDLE)
|
|
, m_enabled(TRenderer::instance().isPrecomputingEnabled())
|
|
{
|
|
}
|
|
|
|
void run(
|
|
TCacheResourceP &resource, const string &alias,
|
|
const TFxP &fx, double frame, const TRenderSettings &rs,
|
|
ResourceDeclaration *resData)
|
|
{
|
|
switch (m_renderStatus) {
|
|
case TRenderer::IDLE:
|
|
case TRenderer::COMPUTING:
|
|
getResourceComputing(resource, alias, fx, frame, rs, resData);
|
|
break;
|
|
case TRenderer::TESTRUN:
|
|
getResourceTestRun(resource, alias, fx, frame, rs, resData);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private:
|
|
void getResourceTestRun(
|
|
TCacheResourceP &resource, const string &alias,
|
|
const TFxP &fx, double frame, const TRenderSettings &rs,
|
|
ResourceDeclaration *resData);
|
|
|
|
void getResourceComputing(
|
|
TCacheResourceP &resource, const string &alias,
|
|
const TFxP &fx, double frame, const TRenderSettings &rs,
|
|
ResourceDeclaration *resData);
|
|
};
|
|
|
|
//************************************************************************************************
|
|
// TPredictiveCacheManager methods
|
|
//************************************************************************************************
|
|
|
|
TPredictiveCacheManager::TPredictiveCacheManager()
|
|
: m_imp(new TPredictiveCacheManager::Imp())
|
|
{
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
TPredictiveCacheManager::~TPredictiveCacheManager()
|
|
{
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void TPredictiveCacheManager::setMaxTileSize(int maxTileSize)
|
|
{
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void TPredictiveCacheManager::setBPP(int bpp)
|
|
{
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void TPredictiveCacheManager::getResource(
|
|
TCacheResourceP &resource, const string &alias,
|
|
const TFxP &fx, double frame, const TRenderSettings &rs,
|
|
ResourceDeclaration *resData)
|
|
{
|
|
if (!m_imp->m_enabled)
|
|
return;
|
|
|
|
m_imp->run(resource, alias, fx, frame, rs, resData);
|
|
}
|
|
|
|
//************************************************************************************************
|
|
// Notification-related functions
|
|
//************************************************************************************************
|
|
|
|
void TPredictiveCacheManager::Imp::getResourceTestRun(
|
|
TCacheResourceP &resource, const string &alias,
|
|
const TFxP &fx, double frame, const TRenderSettings &rs,
|
|
ResourceDeclaration *resData)
|
|
{
|
|
assert(resData && resData->m_rawData);
|
|
if (!(resData && resData->m_rawData))
|
|
//This is a very rare case. I've seen it happen once in a 'pathologic' case
|
|
//which involved affines truncation while building aliases.
|
|
//The rendering system didn't expect the truncated part 'resurface' in a
|
|
//downstream fx with a slightly different affine alias.
|
|
|
|
//TODO: Affines should be coded completely in the aliases... in a compact way though.
|
|
return;
|
|
|
|
if (!resource)
|
|
resource = TCacheResourceP(alias, true);
|
|
|
|
//Lock against concurrent threads
|
|
//QMutexLocker locker(&m_mutex); //preComputing is currently single-threaded
|
|
|
|
std::map<TCacheResourceP, PredictionData>::iterator it =
|
|
m_resources.find(resource);
|
|
|
|
if (it != m_resources.end())
|
|
it->second.m_usageCount++;
|
|
else {
|
|
//Already initializes usageCount at 1
|
|
m_resources.insert(std::make_pair(resource, PredictionData(resData))).first;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void TPredictiveCacheManager::Imp::getResourceComputing(
|
|
TCacheResourceP &resource, const string &alias,
|
|
const TFxP &fx, double frame, const TRenderSettings &rs,
|
|
ResourceDeclaration *resData)
|
|
{
|
|
//If there is no declaration data, either the request can be resolved in one
|
|
//computation code (therefore it is uninteresting for us), or it was never declared.
|
|
//Anyway, return.
|
|
if (!resData)
|
|
return;
|
|
|
|
//NO! The refCount is dynamically depleted - could become 0 from n...
|
|
//assert(!(resData->m_tiles.size() == 1 && resData->m_tiles[0].m_refCount == 1));
|
|
|
|
if (!resource)
|
|
resource = TCacheResourceP(alias);
|
|
|
|
if (!resource)
|
|
return;
|
|
|
|
//Lock against concurrent threads
|
|
QMutexLocker locker(&m_mutex);
|
|
|
|
std::map<TCacheResourceP, PredictionData>::iterator it =
|
|
m_resources.find(resource);
|
|
|
|
if (it == m_resources.end())
|
|
return;
|
|
|
|
if (--it->second.m_usageCount <= 0)
|
|
m_resources.erase(it);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void TPredictiveCacheManager::onRenderStatusStart(int renderStatus)
|
|
{
|
|
m_imp->m_renderStatus = renderStatus;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void TPredictiveCacheManager::onRenderStatusEnd(int renderStatus)
|
|
{
|
|
switch (renderStatus) {
|
|
case TRenderer::TESTRUN:
|
|
|
|
//All resources which have just 1 computation tile, which is also referenced
|
|
//only once, are released.
|
|
|
|
std::map<TCacheResourceP, PredictionData>::iterator it;
|
|
for (it = m_imp->m_resources.begin(); it != m_imp->m_resources.end();) {
|
|
const ResourceDeclaration *decl = it->second.m_decl;
|
|
|
|
if (decl->m_tiles.size() == 1 && decl->m_tiles[0].m_refCount == 1) {
|
|
std::map<TCacheResourceP, PredictionData>::iterator jt = it++;
|
|
m_imp->m_resources.erase(jt);
|
|
} else
|
|
it++;
|
|
}
|
|
}
|
|
}
|