IO/Exodus/vtkExodusIICache.cxx

#include "vtkExodusIICache.h"

#include "vtkDataArray.h"
#include "vtkObjectFactory.h"

// Define VTK_EXO_DBG_CACHE to print cache adds, drops, and replacements.
//#undef VTK_EXO_DBG_CACHE

#define VTK_EXO_PRT_KEY(ckey)                                                                      \
  "(" << (ckey).Time << ", " << (ckey).ObjectType << ", " << (ckey).ObjectId << ", "               \
      << (ckey).ArrayId << ")"
#define VTK_EXO_PRT_ARR(cval)                                                                      \
  " [" << (cval) << "," << ((cval) ? (cval)->GetActualMemorySize() / 1024. : 0.) << "/"            \
       << this->Size << "/" << this->Capacity << "]"
#define VTK_EXO_PRT_ARR2(cval)                                                                     \
  " [" << (cval) << ", " << ((cval) ? (cval)->GetActualMemorySize() / 1024. : 0.) << "]"

#if 0
static void printCache( vtkExodusIICacheSet& cache, vtkExodusIICacheLRU& lru )
{
  cout << "Cache\n";
  vtkExodusIICacheRef cit;
  for ( cit = cache.begin(); cit != cache.end(); ++cit )
  {
    cout << VTK_EXO_PRT_KEY( cit->first ) << VTK_EXO_PRT_ARR2( cit->second->GetValue() ) << "\n";
  }
  cout << "LRU\n";
  vtkExodusIICacheLRURef lit;
  for ( lit = lru.begin(); lit != lru.end(); ++lit )
  {
    cout << VTK_EXO_PRT_KEY( (*lit)->first ) << "\n";
  }
}
#endif // 0

// ============================================================================
vtkExodusIICacheEntry::vtkExodusIICacheEntry()
{
  this->Value = nullptr;
}

vtkExodusIICacheEntry::vtkExodusIICacheEntry(vtkDataArray* arr)
{
  this->Value = arr;
  if (arr)
    this->Value->Register(nullptr);
}
vtkExodusIICacheEntry::~vtkExodusIICacheEntry()
{
  if (this->Value)
    this->Value->Delete();
}

vtkExodusIICacheEntry::vtkExodusIICacheEntry(const vtkExodusIICacheEntry& other)
{
  this->Value = other.Value;
  if (this->Value)
    this->Value->Register(nullptr);
}

#if 0
void printLRUBack( vtkExodusIICacheRef& cit )
{
  cout << "Key is " << VTK_EXO_PRT_KEY( cit->first ) << "\n";
}
#endif // 0

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

vtkStandardNewMacro(vtkExodusIICache);

vtkExodusIICache::vtkExodusIICache()
{
  this->Size = 0.;
  this->Capacity = 2.;
}

vtkExodusIICache::~vtkExodusIICache()
{
  this->ReduceToSize(0.);
}

void vtkExodusIICache::PrintSelf(ostream& os, vtkIndent indent)
{
  this->Superclass::PrintSelf(os, indent);
  os << indent << "Capacity: " << this->Capacity << " MiB\n";
  os << indent << "Size: " << this->Size << " MiB\n";
  os << indent << "Cache: " << &this->Cache << " (" << this->Cache.size() << ")\n";
  os << indent << "LRU: " << &this->LRU << "\n";
}

void vtkExodusIICache::Clear()
{
  // printCache( this->Cache, this->LRU );
  this->ReduceToSize(0.);
}

void vtkExodusIICache::SetCacheCapacity(double sizeInMiB)
{
  if (sizeInMiB == this->Capacity)
    return;

  if (this->Size > sizeInMiB)
  {
    this->ReduceToSize(sizeInMiB);
  }

  this->Capacity = sizeInMiB < 0 ? 0 : sizeInMiB;
}

int vtkExodusIICache::ReduceToSize(double newSize)
{
  int deletedSomething = 0;
  while (this->Size > newSize && !this->LRU.empty())
  {
    vtkExodusIICacheRef cit(this->LRU.back());
    vtkDataArray* arr = cit->second->Value;
    if (arr)
    {
      deletedSomething = 1;
      double arrSz = (double)arr->GetActualMemorySize() / 1024.;
      this->Size -= arrSz;
#ifdef VTK_EXO_DBG_CACHE
      cout << "Dropping " << VTK_EXO_PRT_KEY(cit->first) << VTK_EXO_PRT_ARR(arr) << "\n";
#endif // VTK_EXO_DBG_CACHE
      if (this->Size <= 0)
      {
        if (this->Cache.empty())
          this->Size = 0.;
        else
          this->RecomputeSize(); // oops, FP roundoff
      }
    }
    else
    {
#ifdef VTK_EXO_DBG_CACHE
      cout << "Dropping " << VTK_EXO_PRT_KEY(cit->first) << VTK_EXO_PRT_ARR(arr) << "\n";
#endif // VTK_EXO_DBG_CACHE
    }

    delete cit->second;
    this->Cache.erase(cit);
    this->LRU.pop_back();
  }

  if (this->Cache.empty())
  {
    this->Size = 0;
  }

  return deletedSomething;
}

void vtkExodusIICache::Insert(vtkExodusIICacheKey& key, vtkDataArray* value)
{
  double vsize = value ? value->GetActualMemorySize() / 1024. : 0.;

  vtkExodusIICacheRef it = this->Cache.find(key);
  if (it != this->Cache.end())
  {
    if (it->second->Value == value)
      return;

    // Remove existing array and put in our new one.
    this->Size -= vsize;
    if (this->Size <= 0)
    {
      this->RecomputeSize();
    }
    this->ReduceToSize(this->Capacity - vsize);
    it->second->Value->Delete();
    it->second->Value = value;
    it->second->Value->Register(
      nullptr); // Since we re-use the cache entry, the constructor's Register won't get called.
    this->Size += vsize;
#ifdef VTK_EXO_DBG_CACHE
    cout << "Replacing " << VTK_EXO_PRT_KEY(it->first) << VTK_EXO_PRT_ARR(value) << "\n";
#endif // VTK_EXO_DBG_CACHE
    this->LRU.erase(it->second->LRUEntry);
    it->second->LRUEntry = this->LRU.insert(this->LRU.begin(), it);
  }
  else
  {
    this->ReduceToSize(this->Capacity - vsize);
    std::pair<const vtkExodusIICacheKey, vtkExodusIICacheEntry*> entry(
      key, new vtkExodusIICacheEntry(value));
    std::pair<vtkExodusIICacheSet::iterator, bool> iret = this->Cache.insert(entry);
    this->Size += vsize;
#ifdef VTK_EXO_DBG_CACHE
    cout << "Adding " << VTK_EXO_PRT_KEY(key) << VTK_EXO_PRT_ARR(value) << "\n";
#endif // VTK_EXO_DBG_CACHE
    iret.first->second->LRUEntry = this->LRU.insert(this->LRU.begin(), iret.first);
  }
  // printCache( this->Cache, this->LRU );
}

vtkDataArray*& vtkExodusIICache::Find(const vtkExodusIICacheKey& key)
{
  static vtkDataArray* dummy = nullptr;

  vtkExodusIICacheRef it = this->Cache.find(key);
  if (it != this->Cache.end())
  {
    this->LRU.erase(it->second->LRUEntry);
    it->second->LRUEntry = this->LRU.insert(this->LRU.begin(), it);
    return it->second->Value;
  }

  dummy = nullptr;
  return dummy;
}

int vtkExodusIICache::Invalidate(const vtkExodusIICacheKey& key)
{
  vtkExodusIICacheRef it = this->Cache.find(key);
  if (it != this->Cache.end())
  {
#ifdef VTK_EXO_DBG_CACHE
    cout << "Dropping " << VTK_EXO_PRT_KEY(it->first) << VTK_EXO_PRT_ARR(it->second->Value) << "\n";
#endif // VTK_EXO_DBG_CACHE
    this->LRU.erase(it->second->LRUEntry);
    if (it->second->Value)
    {
      this->Size -= it->second->Value->GetActualMemorySize() / 1024.;
    }
    delete it->second;
    this->Cache.erase(it);

    if (this->Size <= 0)
    {
      if (this->Cache.empty())
        this->Size = 0.;
      else
        this->RecomputeSize(); // oops, FP roundoff
    }

    return 1;
  }
  return 0;
}

int vtkExodusIICache::Invalidate(const vtkExodusIICacheKey& key, const vtkExodusIICacheKey& pattern)
{
  vtkExodusIICacheRef it;
  int nDropped = 0;
  it = this->Cache.begin();
  while (it != this->Cache.end())
  {
    if (!it->first.match(key, pattern))
    {
      ++it;
      continue;
    }

#ifdef VTK_EXO_DBG_CACHE
    cout << "Dropping " << VTK_EXO_PRT_KEY(it->first) << VTK_EXO_PRT_ARR(it->second->Value) << "\n";
#endif // VTK_EXO_DBG_CACHE
    this->LRU.erase(it->second->LRUEntry);
    if (it->second->Value)
    {
      this->Size -= it->second->Value->GetActualMemorySize() / 1024.;
    }
    vtkExodusIICacheRef tmpIt = it++;
    delete tmpIt->second;
    this->Cache.erase(tmpIt);

    if (this->Size <= 0)
    {
      if (this->Cache.empty())
        this->Size = 0.;
      else
        this->RecomputeSize(); // oops, FP roundoff
    }

    ++nDropped;
  }
  return nDropped;
}

void vtkExodusIICache::RecomputeSize()
{
  this->Size = 0.;
  vtkExodusIICacheRef it;
  for (it = this->Cache.begin(); it != this->Cache.end(); ++it)
  {
    if (it->second->Value)
    {
      this->Size += (double)it->second->Value->GetActualMemorySize() / 1024.;
    }
  }
}