Cache.cpp

#include "Foundation/Logging/Logger.h"
 
#include "Context.h"
#include "Resources/TextureManager.h"
 
#include "Image360System.h"
 
namespace {
  using namespace Cogs::Core;
  using namespace Cogs::Core::Image360;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Image360");
 
  size_t cacheMapOffset(size_t level)
  {
    // 0:                           = 0
    // 1: 6                         = 6 * (4^0)
    // 2: 6 + 6*4                   = 6 * (4^0 + 4^1)
    // 3: 6 + 6*4 + 6*4*4           = 6 * (4^0 + 4^1 + 4^2)
    // 4: 6 + 6*4 + 6*4*4 + 6*4*4*4 = 6 * (4^0 + 4^1 + 4^2 + 4^3) = 6 * (4^0 + 4^1 + 4^2 + 4^3)
    //
    // sum_{i=0}^n 4^i  =  1/3 ( 4^(n+1)  - 1 )
    //                  =  1/3 ( 2^(2n+2) - 1 )
 
    if (level == 0) return 0;
 
    size_t n = level - 1;
    size_t t = (size_t(1) << (2 * n + 2)) - 1;
    size_t sum = t / 3;
    assert(3 * sum == t);
    return 6 * sum;
  }
 
  SlotIx tryEvictACacheSlot(Cache& cache, const uint32_t currentFrame)
  {
 
    if (cache.lruPointer) {
      SlotIx slotIx = cache.lru[--cache.lruPointer];
      Cache::Item& cacheItem = cache.items[slotIx];
 
      // Note: Since we evict while updating the tree, we must avoid
      // evicting a tree item that has been visible, is still visible,
      // but haven't been visited yet due to changes further down in
      // the tree. Hence 
      if (1 < currentFrame - cacheItem.lastTouched) {
        LOG_TRACE(logger, "Map=%zu slot=%d rev=%u evicting cache slot, age=%u", cacheItem.mapIx, slotIx, cache.items[slotIx].revision, currentFrame - cacheItem.lastTouched);
        assert(cache.map[cacheItem.mapIx] == slotIx);
 
        cache.map[cacheItem.mapIx] = -1;
        cacheItem.value.state = Cache::Item::State::None;
        cacheItem.depth.state = Cache::Item::State::None;
        cacheItem.mapIx = ~0u;
        return slotIx;
      }
    }
    return -1;
  }
 
  SlotIx tryAllocNewCacheSlot(Cache& cache)
  {
    size_t o = cache.items.size();
    if (o < cache.maxItemCount) {
 
      SlotIx slotIx = SlotIx(o);
 
      cache.lru.emplace_back(slotIx);
 
      Cache::Item& cacheItem = cache.items.emplace_back();
      cacheItem.value.state = Cache::Item::State::None;
      cacheItem.depth.state = Cache::Item::State::None;
      cacheItem.mapIx = ~0u;
      cacheItem.lastTouched = 3;
      return slotIx;
    }
    return -1;
  }
 
}
 
void  Cogs::Core::Image360::Cache::init(const Config& config)
{
  assert(map.empty());
  map.resize(cacheMapOffset(config.treeDepth), -1);
}
 
SlotIx Cogs::Core::Image360::Cache::isQuadInCache(Context* context,
                                                  Fetcher& fetcher,
                                                  const Image360Component& im360Comp,
                                                  const Config& config,
                                                  const uint32_t currentFrame,
                                                  const size_t cacheLevel,
                                                  const size_t cacheLevelIndex)
{
  MapIx mapIx = cacheMapOffset(cacheLevel) + cacheLevelIndex;
 
  SlotIx slotIx = map[mapIx];
  if (0 <= slotIx) {
    Item& cacheItem = items[slotIx];
    cacheItem.lastTouched = currentFrame;
    if (cacheItem.value.state == Item::State::Resident && cacheItem.depth.state == Item::State::Resident) {
      return slotIx;
    }
 
    // If state is None, but has a slot in cache, it has been cancelled.
    if (cacheItem.value.state == Item::State::None) {
      cacheItem.value.state = Item::State::Loading;
      fetcher.issueChannelFetch(context,
                                im360Comp,
                                config,
                                mapIx,
                                slotIx,
                                config.valueChannel,
                                cacheItem.revision,
                                cacheLevel,
                                cacheLevelIndex);
      if (config.valueChannel == config.depthChannel) {
        cacheItem.depth.state = Item::State::Loading;
      }
    }
    if (config.hasDepth && cacheItem.depth.state == Item::State::None) {
      cacheItem.depth.state = Item::State::Loading;
      fetcher.issueChannelFetch(context,
                                im360Comp,
                                config,
                                mapIx,
                                slotIx,
                                config.depthChannel,
                                cacheItem.revision,
                                cacheLevel,
                                cacheLevelIndex);
    }
    return -1;
  }
 
  // Limit amount of concurrent fetches, check before we try to evict
  if (!fetcher.canLoadAnyItems(config)) {
    return -1;
  }
 
  // Try issue a fetch
  slotIx = tryEvictACacheSlot(*this, currentFrame);
  if (slotIx < 0) {
    slotIx = tryAllocNewCacheSlot(*this);
  }
 
  if (0 <= slotIx) {
    Item& cacheItem = items[slotIx];
    cacheItem.lastTouched = currentFrame;
    cacheItem.revision++;
    cacheItem.mapIx = mapIx;
    map[mapIx] = slotIx;
 
    cacheItem.value.state = Item::State::Loading;
    fetcher.issueChannelFetch(context,
                              im360Comp,
                              config,
                              mapIx,
                              slotIx,
                              config.valueChannel,
                              cacheItem.revision,
                              cacheLevel,
                              cacheLevelIndex);
    if (config.hasDepth) {
      cacheItem.depth.state = Item::State::Loading;
      if (config.valueChannel != config.depthChannel) {
        fetcher.issueChannelFetch(context,
                                  im360Comp,
                                  config,
                                  mapIx,
                                  slotIx,
                                  config.depthChannel,
                                  cacheItem.revision,
                                  cacheLevel,
                                  cacheLevelIndex);
      }
    }
    else {
      cacheItem.depth.state = Item::State::Resident;
    }
    return -1;
  }
 
  return -1;
}
 
void Cogs::Core::Image360::Cache::updateLeastRecentlyUsedList(const uint32_t currentFrame)
{
  assert(items.size() == lru.size());
 
  std::sort(lru.begin(),
            lru.end(),
            [currentFrame, cache=this](const SlotIx a, const SlotIx b) -> bool
            {
              return (currentFrame - cache->items[a].lastTouched) < (currentFrame - cache->items[b].lastTouched);
            });
  lruPointer = lru.size();
 
  for (size_t i = 0; i + 1 < lruPointer; i++) {
    assert(lru[i] != lru[i + 1]);
  }
 
#if 0
  size_t evictable = 0;
  while (lruPointer) {
    SlotIx slotIx = lru[--lruPointer];
    if (0 < currentFrame - items[slotIx].lastTouched) {
      evictable++;
    }
  }
  if (evictable) {
    LOG_DEBUG(logger, "Evictable %zu", evictable);
  }
  lruPointer = lru.size();
#endif
}