TexAtlasCache.cpp

#include "Foundation/Logging/Logger.h"
#include "TexAtlasSystem.h"
 
#include <cassert>
 
namespace {
  using namespace Cogs::Core;
  using namespace Cogs::Core::TexAtlas;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TexAtlas");
 
  TreeIx getTreePosition(const glm::uvec3& tileId)
  {
    uint64_t a = tileId.x & 0x1FFFFFFFu; // 29 bits
    uint64_t b = tileId.y & 0x1FFFFFFFu; // 29 bits
    uint64_t c = tileId.z & 0x0000003Fu; // 6 bits
    return static_cast<TreeIx>((c << (29 + 29)) | (b << 29) | a);
  }
 
  SlotIx tryEvictACacheSlot(Cache& cache)
  {
    if (cache.lruPointer) {
      SlotIx slotIx = cache.lru[--cache.lruPointer];
      Cache::Slot& slot = cache.slots[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.
      if (1 < cache.currentFrame - slot.lastTouched) {
 
        assert(slot.treePos != NoTreeIx);
        cache.tree.erase(slot.treePos);
        // We should cancel if there is an active fetch
        cache.setStateNone(slot);
        slot.treePos = NoTreeIx;
 
        LOG_TRACE(logger, "Evicted slotIx=%zu", size_t(slotIx));
        return slotIx;
      }
      else {
        // The rest of the slots will be younger, so we can just clear
        // the LRU pointer to make next check slightly faster.
        cache.lruPointer = 0;
      }
    }
    return NoSlotIx;
  }
 
  SlotIx tryAllocNewCacheSlot(Cache& cache)
  {
    size_t o = cache.slots.size();
    if (cache.maxItemCount <= o) {
      return NoSlotIx;
    }
    SlotIx slotIx = static_cast<SlotIx>(o);
 
    Cache::Slot& slot = cache.slots.emplace_back();
    (void)slot;
 
    cache.lru.emplace_back(slotIx);
    return slotIx;
  }
 
}
 
void Cogs::Core::TexAtlas::Cache::update(uint32_t currentFrame_, uint32_t currentTime_, uint32_t minRetryDelay_, uint32_t maxItemCount_)
{
  currentFrame = currentFrame_;
  currentTime = currentTime_;
  maxItemCount = maxItemCount_;
  minRetryDelay = std::min(0xFFFFu, minRetryDelay_);
 
 
  // If maxItemCount has been reduced, just remove them
  if (maxItemCount < slots.size()) {
    for (size_t i = maxItemCount; i < slots.size(); i++) {
      tree.erase(slots[i].treePos);
    }
    slots.resize(maxItemCount);
  }
 
  // Try to remove all slots more than 100 frames old
  while (!slots.empty() && (100 < (currentFrame - slots.back().lastTouched))) {
    tree.erase(slots.back().treePos);
    slots.pop_back();
  }
 
  // If we removed slots, scan through lru and remove them
  if (slots.size() != lru.size()) {
 
    size_t m = slots.size();
    size_t n = lru.size();
    for (size_t i = 0; i < n; ) {
      if (m <= lru[i]) {
        std::swap(lru[i], lru.back());
        lru.pop_back();
        n--;
      }
      else {
        i++;
      }
    }
 
    assert(slots.size() == lru.size());
  }
 
  // Sort LRU such that the oldest slots are in the end
  assert(slots.size() == lru.size());
  std::sort(lru.begin(), lru.end(),
            [this](const SlotIx& a, const SlotIx& b) -> bool
            {
              uint32_t age_a = currentFrame - slots[a].lastTouched;
              uint32_t age_b = currentFrame - slots[b].lastTouched;
              return age_a < age_b;
            });
 
 
 
  // Decrement towards zero when choosing slots to evict between sort rounds.
  lruPointer = static_cast<uint32_t>(slots.size());
 
  // Sanity check to make sure slots in LRU are unique
  for (size_t i = 1; i < lruPointer; i++) {
    assert(lru[i - 1] != lru[i]);
  }
}
 
Cogs::Core::TexAtlas::SlotIx Cogs::Core::TexAtlas::Cache::getOrAllocCacheSlot(Context* context, Fetcher& fetcher, const glm::uvec3& tileId)
{
  TreeIx treeIx = getTreePosition(tileId);
 
  if (auto it = tree.find(treeIx); it != tree.end()) {
    SlotIx slotIx = it->second;
    Cache::Slot& slot = slots[slotIx];
    slot.lastTouched = currentFrame;
 
 
    // Check if we should retry fetching it.
    if (slot.state == Cache::Slot::State::Failed && minRetryDelay && fetcher.canFetch()) {
      uint32_t elapsed = currentTime - slot.stateChangeTime;
      uint32_t delay = minRetryDelay << slot.retries;
      if (delay <= elapsed) {
        if (slot.retries < 15) {
          slot.retries++;
        }
        LOG_DEBUG(logger, "Retrying failed tile [%u %u %u] (elapsed=%u delay=%u slot=%u, retry=%u)",
                  tileId.x, tileId.y, tileId.z, elapsed, delay, slotIx, slot.retries);
        fetcher.issueFetch(context, tileId, treeIx, slotIx);
        setStateLoading(slot);
      }
    }
 
    // If tile was cancelled we just refetch it
    else if (slot.state == Cache::Slot::State::Cancelled && fetcher.canFetch()) {
      LOG_DEBUG(logger, "Retrying cancelled tile [%u %u %u] (slot=%u)",
                tileId.x, tileId.y, tileId.z, slotIx);
      fetcher.issueFetch(context, tileId, treeIx, slotIx);
      setStateLoading(slot);
    }
 
    // Only return slot when data is ready.
    return slot.state == Cache::Slot::State::Loaded ? slotIx : NoSlotIx;
  }
 
  // No point in allocating slots if we cannot fetch
  if (fetcher.canFetch()) {
 
    // First we try to recycle an old slot
    SlotIx slotIx = tryEvictACacheSlot(*this);
 
    // If no slots can be recycled, ws try to allocate a new slot
    if (slotIx == NoSlotIx) {
      slotIx = tryAllocNewCacheSlot(*this);
    }
 
    // If we managed to get hold of a slot to use, isse a fetch to populate slot
    if (slotIx != NoSlotIx) {
      Cache::Slot& slot = slots[slotIx];
      slot.treePos = treeIx;
      slot.lastTouched = currentFrame;
 
      assert(tree.find(treeIx) == tree.end());
      tree[treeIx] = slotIx;
 
      fetcher.issueFetch(context, tileId, treeIx, slotIx);
      setStateLoading(slot);
      //LOG_DEBUG(logger, "using slot %u: %u %u %u -> %u", slotIx, tileId.z, tileId.x, tileId.y, treeIx);
    }
  }
 
  return NoSlotIx;
}