#include <string></string>

#include "trenderer.h"

#include "tcacheresourcepool.h"

#include "tfxcachemanager.h"

// Debug

//#define DIAGNOSTICS

#ifdef DIAGNOSTICS

#include "diagnostics.h"

//#define WRITESTACK

//#define WRITESUBRECTS

//#define WRITEGENERAL

namespace {

QString traduce(const TRectD &rect) {

  return "[" + QString::number(rect.x0) + " " + QString::number(rect.y0) + " " +

         QString::number(rect.x1) + " " + QString::number(rect.y1) + "]";

}

QString traduce(const TTile &tile) {

  TDimension dim(tile.getRaster()->getSize());

  TRectD tileRect(tile.m_pos, TDimensionD(dim.lx, dim.ly));

  return traduce(tileRect);

}

QString prefixInfo("#info.txt | ");

QString prefixWarn("#warning.txt | ");

QString prefixErr("#error.txt | ");

QString prefixTest("#TestRun.txt | ");

QString prefixComp("#Computing.txt | ");

QString prefixSubTiles("#SubTiles.txt | ");

}

#endif  // DIAGNOSTICS

//****************************************************************************************************

//    Explanation

//****************************************************************************************************

/*

This file contains most of the code that deals with smart caching during a Toonz

render process.

The paradigms on which the 'smart caching' takes place are:

  - Only calculations resulting in an image positioned in a plane are dealt.

These results are

    called 'tiles' - and are modeled by a TTile instance.

    These images MUST BE wrapped to INTEGER POSITIONS on the reference, and are

intended so that

    a PIXEL corresponds to a UNIT SQUARE.

  - Given one such calculation procedure, it MUST BE SIMULABLE, so that children

calculations

    are invoked 'faithfully' with respect to the actual calculation.

    This is necessary to predict results in advance in force of which we can

efficiently store

    results in the cache, releasing them when they will no longer be required.

Now, the principal classes dealing with this job are:

 - One TFxCacheManager per render instance, used to store predictive

informations.

 - A set of TFxCacheManagerDelegate per render instance, used to store

references to cache resources

   and providing reasons for caching results.

 - The ResourceBuilder interface class, used by users to access the smart

caching ensemble. This class

   implements the actual resources build and simulation code.

*/

//****************************************************************************************************

//    Preliminaries

//****************************************************************************************************

namespace {

// Global variables

//-----------------------------------------------------------------------------------------

// Utility functions

inline QRect toQRect(const TRect &r) {

  return QRect(r.x0, r.y0, r.getLx(), r.getLy());

}

inline TRect toTRect(const QRect &r) {

  return TRect(r.left(), r.top(), r.right(), r.bottom());

}

inline QPoint toQPoint(const TPoint &p) { return QPoint(p.x, p.y); }

inline bool isEmpty(const TRectD &rect) {

  return rect.x0 >= rect.x1 || rect.y0 >= rect.y1;

}

inline void enlargeToI(TRectD &r) {

  TRectD temp(tfloor(r.x0), tfloor(r.y0), tceil(r.x1), tceil(r.y1));

  if (!isEmpty(temp))

    r = temp;  // Since r could have TConsts::infiniteRectD-like coordinates...

}

// Qt's contains actually returns QRegion::intersected... I wonder why...

inline bool contains(const QRegion ®ion, const TRect &rect) {

  return QRegion(toQRect(rect)).subtracted(region).isEmpty();

}

bool getTilesToBuild(

    const ResourceData &data, const TRectD &rect,

    std::vector<resourcedeclaration::tiledata *=""> &rectsToCalculate);</resourcedeclaration::tiledata>

}

//****************************************************************************************************

//    TFxCacheManager Generator

//****************************************************************************************************

class TFxCacheManagerGenerator : public TRenderResourceManagerGenerator {

public:

  TFxCacheManagerGenerator() : TRenderResourceManagerGenerator(true) {}

  TRenderResourceManager *operator()() override { return new TFxCacheManager; }

};

MANAGER_FILESCOPE_DECLARATION(TFxCacheManager, TFxCacheManagerGenerator);

//****************************************************************************************************

//    TFxCacheManager implementation

//****************************************************************************************************

class TFxCacheManager::Imp {

public:

  typedef std::map<std::string, resourcedeclaration=""> ResourceInstanceDataMap;</std::string,>

  ResourceInstanceDataMap m_resourcesData;

  std::map<resourcedeclaration *,="" resourcedeclaration::rawdata=""> m_rawData;</resourcedeclaration>

  int m_renderStatus;

  QMutex m_mutex;

public:

  void prepareTilesToCalculate(ResourceDeclaration &data);

  inline void subdivideIntoSmallerTiles(const TRectD &rect,

                                        std::vector<trectd> &tileSet);</trectd>

  void recursiveRectSubdivide(

      std::vector<resourcedeclaration::tiledata> &results, TRasterFx *fx,</resourcedeclaration::tiledata>

      const TRectD &rect, double frame, const TRenderSettings &info,

      int dropTol = (std::numeric_limits<int>::max)());</int>

};

//****************************************************************************************************

//    Methods implementation

//****************************************************************************************************

//========================

//    TFxCacheManager

//------------------------

TFxCacheManager::TFxCacheManager() : m_imp(new Imp) {}

//-----------------------------------------------------------------------------------

TFxCacheManager::~TFxCacheManager() {

  // Release all the static-cached images

  std::set<std::string>::iterator it;</std::string>

  for (it = m_staticCacheIds.begin(); it != m_staticCacheIds.end(); ++it)

    TImageCache::instance()->remove(*it);

}

//-----------------------------------------------------------------------------------

TFxCacheManager *TFxCacheManager::instance() {

  return static_cast<tfxcachemanager *="">(</tfxcachemanager>

      TFxCacheManager::gen()->getManager(TRenderer::renderId()));

}

//-----------------------------------------------------------------------------------

void TFxCacheManager::add(const std::string &cacheId, TImageP img) {

  TImageCache::instance()->add(cacheId, img);

  QMutexLocker locker(&m_imp->m_mutex);

  m_staticCacheIds.insert(cacheId);

}

//-----------------------------------------------------------------------------------

void TFxCacheManager::remove(const std::string &cacheId) {

  TImageCache::instance()->remove(cacheId);

  QMutexLocker locker(&m_imp->m_mutex);

  m_staticCacheIds.erase(cacheId);

}

//-----------------------------------------------------------------------------------

void TFxCacheManager::install(TFxCacheManagerDelegate *managerDelegate) {

  m_delegates.insert(managerDelegate);

}

//-----------------------------------------------------------------------------------

/*void TFxCacheManager::install(TFxCacheManagerListener* listener)

{

  m_listeners.insert(listener);

}

//-----------------------------------------------------------------------------------

void TFxCacheManager::notifyResourceUpload(const TCacheResourceP& resource,

const TRect& rect)

{

  std::set<tfxcachemanagerlistener*>::iterator it;</tfxcachemanagerlistener*>

  for(it = m_listeners.begin(); it != m_listeners.end(); ++it)

    (*it)->onResourceUpload(resource, rect);

}

//-----------------------------------------------------------------------------------

void TFxCacheManager::notifyResourceDownload(const TCacheResourceP& resource,

const TRect& rect)

{

  std::set<tfxcachemanagerlistener*>::iterator it;</tfxcachemanagerlistener*>

  for(it = m_listeners.begin(); it != m_listeners.end(); ++it)

    (*it)->onResourceDownload(resource, rect);

}

//-----------------------------------------------------------------------------------

void TFxCacheManager::notifyPredictedRelease(const TCacheResourceP& resource)

{

  std::set<tfxcachemanagerlistener*>::iterator it;</tfxcachemanagerlistener*>

  for(it = m_listeners.begin(); it != m_listeners.end(); ++it)

    (*it)->onPredictedRelease(resource);

}*/

//****************************************************************************************************

//    Resources dealing

//****************************************************************************************************

void TFxCacheManager::declareResource(const std::string &alias, const TFxP &fx,

                                      const TRectD &rect, double frame,

                                      const TRenderSettings &rs,

                                      bool subtileable) {

  Imp::ResourceInstanceDataMap::iterator it;

  it = m_imp->m_resourcesData

           .insert(std::make_pair(alias, ResourceDeclaration()))

           .first;

  it->second.m_rawData =

      &m_imp->m_rawData

           .insert(std::make_pair(&it->second, ResourceDeclaration::RawData()))

           .first->second;

  ResourceDeclaration::RawData &rawData = *it->second.m_rawData;

  // Assign the sim data

  rawData.m_fx = fx;

  rawData.m_tiles.push_back(rect);

  rawData.m_rs    = rs;

  rawData.m_frame = frame;

  // rawData.m_bbox = bbox;

  rawData.m_subtileable = subtileable;

}

//-----------------------------------------------------------------------------------

ResourceData TFxCacheManager::getResource(const std::string &alias,

                                          const TFxP &fx, double frame,

                                          const TRenderSettings &rs) {

  TCacheResourceP result, temp;

  // Seek the associated infos

  Imp::ResourceInstanceDataMap::iterator jt =

      m_imp->m_resourcesData.find(alias);

  ResourceDeclaration *decl =

      (jt == m_imp->m_resourcesData.end()) ? 0 : &jt->second;

  // Search the resource in cached mode.

  // TCacheResourcePool* pool = TCacheResourcePool::instance();

  // pool->beginCachedSearch();

  // Ask every installed delegate if it's managing - or want to manage

  // the passed resource specs.

  std::set<tfxcachemanagerdelegate *="">::iterator it;</tfxcachemanagerdelegate>

  for (it = m_delegates.begin(); it != m_delegates.end(); ++it) {

    (*it)->getResource(temp, alias, fx, frame, rs, decl);

    if (!result && temp) result = temp;

  }

  // pool->endCachedSearch();

  return ResourceData(decl, result);

}

//-----------------------------------------------------------------------------------

void TFxCacheManager::onRenderStatusStart(int renderStatus) {

  // Store current render status

  m_imp->m_renderStatus = renderStatus;

#ifdef WRITESTACK

  if (renderStatus == TRenderer::TESTRUN) {

    DIAGNOSTICS_GLOSTRSET("status", "test");

    DIAGNOSTICS_GLOSET("testInst", DIAGNOSTICS_GLOGET("compInst") + 1);

    DIAGNOSTICS_GLOSTRSET("instVar",

                          QString::number(DIAGNOSTICS_GLOGET("testInst")));

    DIAGNOSTICS_GLOSTRSET(

        "testRenderStr",

        "Render #" + QString::number(DIAGNOSTICS_GLOGET("testInst")) + " | ");

  } else if (renderStatus == TRenderer::COMPUTING) {

    DIAGNOSTICS_GLOSTRSET("status", "comp");

    DIAGNOSTICS_GLOSTRSET("instVar",

                          QString::number(DIAGNOSTICS_GLOGET("compInst")));

    DIAGNOSTICS_GLOSTRSET(

        "compRenderStr",

        "Render #" + QString::number(DIAGNOSTICS_GLOGET("compInst")) + " | ");

    DIAGNOSTICS_GLOSET(DIAGNOSTICS_THRSTRGET("stackVar"), 0);

  }

#endif

}

//-----------------------------------------------------------------------------------

void TFxCacheManager::onRenderStatusEnd(int renderStatus) {

  if (renderStatus == TRenderer::FIRSTRUN) {

    Imp::ResourceInstanceDataMap &resMap = m_imp->m_resourcesData;

    Imp::ResourceInstanceDataMap::iterator it;

    for (it = resMap.begin(); it != resMap.end();) {

      m_imp->prepareTilesToCalculate(it->second);

      // Cannot be done. The resource could still be feasible to caching,

      // due to external requests.

      // Erase all resource datas which have been declared and prepared only

      // once

      /*if(it->second.m_tiles.size() == 1 &&

it->second.m_simData->m_tiles.size() == 1)

{

it = resMap.erase(it);

continue;

}*/

      ++it;

    }

  } else if (renderStatus == TRenderer::TESTRUN) {

    Imp::ResourceInstanceDataMap &resMap = m_imp->m_resourcesData;

    Imp::ResourceInstanceDataMap::iterator it;

    for (it = resMap.begin(); it != resMap.end();) {

      // Release all resource declarations which are declared to be used only

      // once.

      if (it->second.m_tiles.size() == 1 &&

          it->second.m_tiles[0].m_refCount == 1) {

        Imp::ResourceInstanceDataMap::iterator jt = it++;

        resMap.erase(jt);

        continue;

      }

      // In any case, release all simulation datas - they are no longer useful.

      // An associated cache resource avoids deletion only in case some manager

      // retained it.

      it->second.m_rawData = 0;

      ++it;

    }

#ifdef WRITEGENERAL

    DIAGNOSTICS_SET("Declarations used more than once", resMap.size());

#endif

    m_imp->m_rawData.clear();

  }

#ifdef WRITEGENERAL

  else {

    // Print the number of not depleted declarations

    Imp::ResourceInstanceDataMap &resMap = m_imp->m_resourcesData;

    Imp::ResourceInstanceDataMap::iterator it;

    DIAGNOSTICS_ADD(

        prefixErr + "Computing | Declarations survived after Test Run",

        resMap.size());

    if (resMap.size() > 0) {

      for (it = resMap.begin(); it != resMap.end(); ++it) {

        DIAGNOSTICS_STR(prefixErr + "Survived Declarations | " +

                        QString::fromStdString(it->first).left(40));

      }

    }

  }

#endif

}

//****************************************************************************************************

//    Tiles to calculate - methods

//****************************************************************************************************

void TFxCacheManager::Imp::prepareTilesToCalculate(ResourceDeclaration &data) {

  // First, build the total sum of declared tiles

  TRectD sum;

  int tilesCount = data.m_rawData->m_tiles.size();

  for (int i = 0; i < tilesCount; ++i) sum += data.m_rawData->m_tiles[i];

  // Intersect the sum with bbox and ensure integer geometry

  // sum *= data.m_rawData->m_bbox;

  enlargeToI(sum);

  if (!data.m_rawData->m_subtileable) {

    data.m_tiles.push_back(sum);

    return;

  }

  TRasterFx *fx = dynamic_cast<trasterfx *="">(data.m_rawData->m_fx.getPointer());</trasterfx>

  // Now, subdivide the sum

  recursiveRectSubdivide(data.m_tiles, fx, sum, data.m_rawData->m_frame,

                         data.m_rawData->m_rs);

}

//---------------------------------------------------------------------------

//! Calculates at max 4 smaller subrects of passed one. Returns true or false

//! whether the subdivision was

//! successfully applied.

inline void TFxCacheManager::Imp::subdivideIntoSmallerTiles(

    const TRectD &rect, std::vector<trectd> &tileSet) {</trectd>

  // Find the greater rect edge

  TRectD subTile1, subTile2;

  if (rect.getLx() > rect.getLy()) {

    int sep  = rect.x0 + tceil(0.5 * rect.getLx());

    subTile1 = TRectD(rect.x0, rect.y0, sep, rect.y1);

    subTile2 = TRectD(sep, rect.y0, rect.x1, rect.y1);

  } else {

    int sep  = rect.y0 + tceil(0.5 * rect.getLy());

    subTile1 = TRectD(rect.x0, rect.y0, rect.x1, sep);

    subTile2 = TRectD(rect.x0, sep, rect.x1, rect.y1);

  }

  tileSet.push_back(subTile1);

  tileSet.push_back(subTile2);

}

//---------------------------------------------------------------------------

void TFxCacheManager::Imp::recursiveRectSubdivide(

    std::vector<resourcedeclaration::tiledata> &results, TRasterFx *fx,</resourcedeclaration::tiledata>

    const TRectD &rect, double frame, const TRenderSettings &info,

    int dropTol) {

  // Here is the subdivision strategy:

  //  - First, since cache tiles are newly ALLOCATED, we impose the raster

  //    size restriction on them directly

  //  - Then, we check that the memory requirement for the fx (max raster size

  //    that it will allocate) is little.

  //  - As an exception to previous point, if the memory requirement stagnates

  //    near the same memory size, quit

  // NOTE: Level images pass here, but haven't any fx. So they are currently not

  // subdivided.

  // Retrieve the memory requirement for this input.

  int memReq = fx ? fx->getMemoryRequirement(rect, frame, info) : 0;

  // In case memReq < 0, we assume a strong subdivision denial, just as if the

  // usage was

  // explicitly set as unsubdividable.

  if (memReq < 0) {

    results.push_back(rect);

    return;

  }

  if ((memReq > info.m_maxTileSize && memReq < dropTol) ||

      TRasterFx::memorySize(rect, info.m_bpp) > info.m_maxTileSize) {

    std::vector<trectd> subTileRects;</trectd>

    subdivideIntoSmallerTiles(rect, subTileRects);

    while (!subTileRects.empty()) {

      TRectD subTileRect(subTileRects.back());

      subTileRects.pop_back();

      // Pass subdivision below, with updated drop-tolerance

      recursiveRectSubdivide(results, fx, subTileRect, frame, info,

                             memReq - (memReq >> 2));

      // The newly required memory must be under 3/4 of the previous.

      // This is required in order to make it worth subdividing.

    }

    return;

  }

  results.push_back(ResourceDeclaration::TileData(rect));

}

//****************************************************************************************************

//    ResourceBuilder

//****************************************************************************************************

ResourceBuilder::ResourceBuilder(const std::string &resourceName,

                                 const TFxP &fx, double frame,

                                 const TRenderSettings &rs)

    : m_cacheManager(TFxCacheManager::instance())

    , m_data(m_cacheManager->getResource(resourceName, fx, frame, rs)) {

#ifdef WRITESTACK

  DIAGNOSTICS_THRSET("frame", frame);

  DIAGNOSTICS_THRSTRSET(

      "frameStr",

      "Frame " + QString::number(frame).rightJustified(4, ' ') + " | ");

  DIAGNOSTICS_THRSTRSET("stackVar", DIAGNOSTICS_GLOSTRGET("status") + "sv" +

                                        DIAGNOSTICS_GLOSTRGET("instVar") +

                                        "fr" + QString::number(frame));

  DIAGNOSTICS_THRSTRSET("ResourceName",

                        QString::fromStdString(resourceName).left(35));

#endif

}

//-----------------------------------------------------------------------------------

void ResourceBuilder::declareResource(const std::string &alias, const TFxP &fx,

                                      const TRectD &rect, double frame,

                                      const TRenderSettings &rs,

                                      bool subtileable) {

  TFxCacheManager::instance()->declareResource(alias, fx, rect, frame, rs,

                                               subtileable);

}

//-----------------------------------------------------------------------------------

namespace {

// Retrieves all interesting tiles with respect to the build procedure.

// Explicitly, this refers to tiles intersecting the required rect, that are

// either

// not in the resource, or supposed to be not.

// Returns true if the required tile is contained in the sum of the predicted

// ones

// (which should definitely happen if the predictive step is coherent with the

// computation one).

bool getTilesToBuild(

    const ResourceData &data, const TRectD &rect,

    std::vector<resourcedeclaration::tiledata *=""> &rectsToCalculate) {</resourcedeclaration::tiledata>

  assert(data.first);   // The declaration must DEFINITELY be present

  assert(data.second);  // The resource should be present here

  // Now, fill in with all prepared rects which intersect input rect and are not

  // already in the resource

  std::vector<resourcedeclaration::tiledata> &preparedRects =</resourcedeclaration::tiledata>

      data.first->m_tiles;

  std::vector<resourcedeclaration::tiledata>::iterator jt;</resourcedeclaration::tiledata>

  TRectD sum;

  for (jt = preparedRects.begin(); jt != preparedRects.end(); ++jt) {

    sum += jt->m_rect;

    if (!(isEmpty(rect * jt->m_rect) || jt->m_calculated))

      rectsToCalculate.push_back(&(*jt));

  }

  return sum.contains(rect);

}

}  // namespace

//-----------------------------------------------------------------------------------

void ResourceBuilder::simBuild(const TRectD &rect) {

  // Retrieve the render status

  int renderStatus = m_cacheManager->m_imp->m_renderStatus;

  // In the initial precomputing stage, just retrieve all the declarations

  // without efforts.

  if (renderStatus == TRenderer::FIRSTRUN) {

    simCompute(rect);

    return;

  }

  // Perform the test run

  if (renderStatus == TRenderer::TESTRUN) {

    if (!(m_data.first && m_data.second)) return;

#ifdef WRITESTACK

    QString resName(DIAGNOSTICS_THRSTRGET("ResourceName"));

    QString renderStr(DIAGNOSTICS_GLOSTRGET("testRenderStr"));

    QString frameStr(DIAGNOSTICS_THRSTRGET("frameStr"));

    DIAGNOSTICS_NUMBEREDSTRSET(

        prefixTest + renderStr + frameStr, DIAGNOSTICS_THRSTRGET("stackVar"),

        DIAGNOSTICS_STACKGET("parentResource") + " " + resName, ::traduce(rect),

        4);

    DIAGNOSTICS_PUSHAUTO(

        "parentResource",

        QString::number(DIAGNOSTICS_GLOGET(DIAGNOSTICS_THRSTRGET("stackVar"))),

        bla);

#endif

    // Retrieve the tiles to build

    std::vector<resourcedeclaration::tiledata> &tiles = m_data.first->m_tiles;</resourcedeclaration::tiledata>

    // For every tile intersecting rect

    std::vector<resourcedeclaration::tiledata>::iterator it;</resourcedeclaration::tiledata>

    for (it = tiles.begin(); it != tiles.end(); ++it) {

      ResourceDeclaration::TileData &tileData = *it;

      if (!isEmpty(tileData.m_rect * rect)) {

        // If the tile ref count == 0, assume that this tile has not yet been

        // simComputed.

        // Do so, then; further, add 1 to the number of predicted actively

        // accessed tiles.

        if (tileData.m_refCount == 0) {

#ifdef WRITESUBRECTS

          DIAGNOSTICS_NUMBEREDSTRSET(

              prefixTest + renderStr + frameStr,

              DIAGNOSTICS_THRSTRGET("stackVar"),

              DIAGNOSTICS_STACKGET("parentResource") + "   " + resName,

              ::traduce(tileData.m_rect), 4);

          DIAGNOSTICS_PUSHAUTO("parentResource",

                               QString::number(DIAGNOSTICS_GLOGET(

                                   DIAGNOSTICS_THRSTRGET("stackVar"))),

                               bla2);

#endif

          simCompute(tileData.m_rect);

          ++m_data.first->m_tilesCount;

        }

        // Add a reference to this tile

        ++tileData.m_refCount;

        if (m_data.second) {

          QMutexLocker locker(m_data.second->getMutex());

          TRect tileRectI(tileData.m_rect.x0, tileData.m_rect.y0,

                          tileData.m_rect.x1 - 1, tileData.m_rect.y1 - 1);

          m_data.second->addRef2(tileRectI);

        }

      }

    }

    return;

  }

  // In this case, the simulation is used to declare that this rect will NOT be

  // calculated.

  // So, this is the behaviour: 1 refCount is depleted by all cells intersecting

  // the rect

  // - if the refCount is still >0, then another request will occur that will

  // make the

  // tile calculated. If it is == 0, and the tile has not yet been calculated,

  // then the tile

  // will supposedly be NO MORE calculated, so the simCompute has to be launched

  // on that tile, too.

  if (renderStatus == TRenderer::COMPUTING) {

    if (!(m_data.first && m_data.second)) return;

    QMutexLocker locker(m_data.second->getMutex());

    // Retrieve the tiles to build

    std::vector<resourcedeclaration::tiledata> &tiles = m_data.first->m_tiles;</resourcedeclaration::tiledata>

    // Please note that the request should definitely be fitting the predicted

    // results,

    // since the original rect which generated these simCompute calls must have

    // been fitting.

    // For every tile to build

    std::vector<resourcedeclaration::tiledata>::iterator it;</resourcedeclaration::tiledata>

    for (it = tiles.begin(); it != tiles.end(); ++it) {

      ResourceDeclaration::TileData &tileData = *it;

      if (!isEmpty(tileData.m_rect * rect)) {

        if (tileData.m_refCount <= 0) continue;

        if (--tileData.m_refCount == 0 && !tileData.m_calculated) {

          --m_data.first->m_tilesCount;

          simCompute(tileData.m_rect);

        }

        if (m_data.second) {

          TRect tileRectI(tileData.m_rect.x0, tileData.m_rect.y0,

                          tileData.m_rect.x1 - 1, tileData.m_rect.y1 - 1);

          m_data.second->release2(tileRectI);

        }

      }

    }

  }

}

//-----------------------------------------------------------------------------------

void ResourceBuilder::build(const TRectD &tileRect) {

#ifdef WRITESTACK

  QString resName(DIAGNOSTICS_THRSTRGET("ResourceName"));

  QString renderStr(DIAGNOSTICS_GLOSTRGET("compRenderStr"));

  QString frameStr(DIAGNOSTICS_THRSTRGET("frameStr"));

  DIAGNOSTICS_NUMBEREDSTRSET(

      prefixComp + renderStr + frameStr, DIAGNOSTICS_THRSTRGET("stackVar"),

      DIAGNOSTICS_STACKGET("parentResource") + " " + resName,

      ::traduce(tileRect), 4);

  DIAGNOSTICS_PUSHAUTO(

      "parentResource",

      QString::number(DIAGNOSTICS_GLOGET(DIAGNOSTICS_THRSTRGET("stackVar"))),

      bla);

#endif

  // If there is no resource, just compute the tile directly.

  if (!m_data.second) {

#ifdef WRITEGENERAL

    if (m_data.first)

      if (m_data.first->m_tilesCount > 0)

        DIAGNOSTICS_ADD(

            prefixErr +

                "Computing | No-resource build, active decl, tilesCount > 0",

            1);

      else

        DIAGNOSTICS_ADD(

            prefixErr +

                "Computing | No-resource build, active decl, tilesCount <= 0",

            1);

#endif

    // assert(!m_data.first);  //Should have been erased before the COMPUTING

    // run.

    compute(tileRect);

    return;

  }

  // Since this function must be thread-safe, use the appropriate

  // synchronization tool.

  QMutexLocker locker(m_data.second->getMutex());

  // Without declaration, you can just deal with the required tile.

  if (!(m_data.first && m_data.first->m_tilesCount > 0)) {

#ifdef WRITEGENERAL

    if (!m_data.first)

      DIAGNOSTICS_ADD("#error.txt | Resources without declaration", 1);

    else

      DIAGNOSTICS_ADD("#error.txt | Resources with declaration, tilesCount <=0",

                      1);

#endif

    if (download(m_data.second)) return;

    compute(tileRect);

    // Since there is an associated resource, the calculated content is

    // supposedly

    // an interesting one. Upload it.

    upload(m_data.second);

    return;

  }

  // Now, both the declaration and the resource exist.

  // Retrieve the predicted tile that must be built in place of tile.

  TDimension dim(tileRect.getLx(), tileRect.getLy());

  std::vector<resourcedeclaration::tiledata *=""> tiles;</resourcedeclaration::tiledata>

  bool fittingPrediction = getTilesToBuild(m_data, tileRect, tiles);

  if (!fittingPrediction) {

#ifdef WRITEGENERAL

    DIAGNOSTICS_ADD(prefixErr + "Computing | Not fitting tiles", 1);

#endif

    // If the required tile is not fitting the prediction, we assume it is a

    // full un-predicted one - so no reference count will be updated (this would

    // comply

    // with the simCompute() method, in case we assume that mis-predicted

    // computes are always prudently built IN EXCESS).

    // For now, just calculate it and stop.

    locker.unlock();

    compute(tileRect);

    return;

  }

  // If necessary, calculate something

  if (tiles.size() > 0) {

    // For every tile to build

    std::vector<resourcedeclaration::tiledata *="">::iterator it;</resourcedeclaration::tiledata>

    for (it = tiles.begin(); it != tiles.end(); ++it) {

      ResourceDeclaration::TileData &tileData = **it;

      // If the tile can be downloaded from the resource, it's because it has

      // actually

      // been calculated by another render process - either a concurrent one, or

      // any

      // which has written this resource part on disk storage.

      // Since reference counts built in the simCompute assume that tiles

      // downloaded

      // from the resource have been calculated in THIS very render process,

      // therefore having tileData.m_calculated == true, in this case

      // heir refCounts must be updated since no computing will happen on them

      // due to the predicted node builds of this resource.

      TRect tileRectI(tileData.m_rect.x0, tileData.m_rect.y0,

                      tileData.m_rect.x1 - 1, tileData.m_rect.y1 - 1);

      if (m_data.second->canDownloadAll(tileRectI)) {

        if (!tileData.m_calculated && tileData.m_refCount > 0) {

          /*#ifdef WRITESTACK

QString renderStr(DIAGNOSTICS_GLOSTRGET("compRenderStr"));

QString frameStr(DIAGNOSTICS_THRSTRGET("frameStr"));

DIAGNOSTICS_NUMBEREDSTRSET(prefixComp + renderStr + frameStr,

DIAGNOSTICS_THRSTRGET("stackVar"), "$ > " + resName,

::traduce(tileData.m_rect), 4);

#endif*/

          // Deplete children refsCount - rely on the simulated procedure

          simCompute(tileData.m_rect);

        }

      } else {

#ifdef WRITESUBRECTS

        DIAGNOSTICS_NUMBEREDSTRSET(

            prefixComp + renderStr + frameStr,

            DIAGNOSTICS_THRSTRGET("stackVar"),

            DIAGNOSTICS_STACKGET("parentResource") + "   " + resName,

            ::traduce(tileData.m_rect), 4);

        DIAGNOSTICS_PUSHAUTO("parentResource",

                             QString::number(DIAGNOSTICS_GLOGET(

                                 DIAGNOSTICS_THRSTRGET("stackVar"))),

                             bla2);

#endif

        // Compute the tile to be calculated

        compute(tileData.m_rect);

        if (tileData.m_refCount > 0) tileData.m_calculated = true;

        // Upload the tile into the resource - do so even if the tile

        // was unpredicted. In this case, we rely on the resource refCount to

        // provide the deallocations... Should be so?

        upload(m_data.second);

      }

    }

  }

  // Finally, download the built resource in the required tile

  bool ret = download(m_data.second);

  assert(ret);

#ifdef WRITESTACK

  if (!ret)

    DIAGNOSTICS_STRSET(

        prefixErr + "Download falliti | " +

            DIAGNOSTICS_GLOSTRGET("compRenderStr") +

            DIAGNOSTICS_THRSTRGET("frameStr") +

            QString::number(

                DIAGNOSTICS_GLOGET(DIAGNOSTICS_THRSTRGET("stackVar"))),

        "CROP #" + QString::number(DIAGNOSTICS_GLOGET("crStack")));

#endif

  // Deplete a usage for all tiles intersecting the downloaded one. Fully

  // depleted

  // tiles become unpredicted from now on.

  std::vector<resourcedeclaration::tiledata> &resTiles = m_data.first->m_tiles;</resourcedeclaration::tiledata>

  std::vector<resourcedeclaration::tiledata>::iterator it;</resourcedeclaration::tiledata>

  for (it = resTiles.begin(); it != resTiles.end(); ++it) {

    ResourceDeclaration::TileData &tileData = *it;

    if (!isEmpty(tileData.m_rect * tileRect)) {

      if (tileData.m_refCount <= 0) {

#ifdef WRITEGENERAL

        DIAGNOSTICS_ADD(prefixErr + "Computing | Over-used subtiles", 1);

#endif

        continue;

      }

      if (--tileData.m_refCount == 0) {

        tileData.m_calculated = false;

        --m_data.first->m_tilesCount;

      }

      TRect tileRectI(tileData.m_rect.x0, tileData.m_rect.y0,