/*============================================================================
  CMake - Cross Platform Makefile Generator
  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium

  Distributed under the OSI-approved BSD License (the "License");
  see accompanying file Copyright.txt for details.

  This software is distributed WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the License for more information.
============================================================================*/
#include "cmOrderDirectories.h"

#include "cmGlobalGenerator.h"
#include "cmSystemTools.h"
#include "cmake.h"

#include <assert.h>

#include <algorithm>

/*
Directory ordering computation.
  - Useful to compute a safe runtime library path order
  - Need runtime path for supporting INSTALL_RPATH_USE_LINK_PATH
  - Need runtime path at link time to pickup transitive link dependencies
    for shared libraries.
*/

//----------------------------------------------------------------------------
class cmOrderDirectoriesConstraint
{
public:
  cmOrderDirectoriesConstraint(cmOrderDirectories* od,
                               std::string const& file):
    OD(od), GlobalGenerator(od->GlobalGenerator)
    {
    this->FullPath = file;

    if(file.rfind(".framework") != std::string::npos)
      {
      cmsys::RegularExpression splitFramework;
      splitFramework.compile("^(.*)/(.*).framework/(.*)$");
      if(splitFramework.find(file) &&
        (std::string::npos !=
         splitFramework.match(3).find(splitFramework.match(2))))
        {
        this->Directory = splitFramework.match(1);
        this->FileName =
          std::string(file.begin() + this->Directory.size() + 1, file.end());
        }
      }

    if(this->FileName.empty())
      {
      this->Directory = cmSystemTools::GetFilenamePath(file);
      this->FileName = cmSystemTools::GetFilenameName(file);
      }
    }
  virtual ~cmOrderDirectoriesConstraint() {}

  void AddDirectory()
    {
    this->DirectoryIndex = this->OD->AddOriginalDirectory(this->Directory);
    }

  virtual void Report(std::ostream& e) = 0;

  void FindConflicts(unsigned int index)
    {
    for(unsigned int i=0; i < this->OD->OriginalDirectories.size(); ++i)
      {
      // Check if this directory conflicts with the entry.
      std::string const& dir = this->OD->OriginalDirectories[i];
      if(dir != this->Directory && this->FindConflict(dir))
        {
        // The library will be found in this directory but this is not
        // the directory named for it.  Add an entry to make sure the
        // desired directory comes before this one.
        cmOrderDirectories::ConflictPair p(this->DirectoryIndex, index);
        this->OD->ConflictGraph[i].push_back(p);
        }
      }
    }

  void FindImplicitConflicts(cmOStringStream& w)
    {
    bool first = true;
    for(unsigned int i=0; i < this->OD->OriginalDirectories.size(); ++i)
      {
      // Check if this directory conflicts with the entry.
      std::string const& dir = this->OD->OriginalDirectories[i];
      if(dir != this->Directory && this->FindConflict(dir))
        {
        // The library will be found in this directory but it is
        // supposed to be found in an implicit search directory.
        if(first)
          {
          first = false;
          w << "  ";
          this->Report(w);
          w << " in " << this->Directory << " may be hidden by files in:\n";
          }
        w << "    " << dir << "\n";
        }
      }
    }
protected:
  virtual bool FindConflict(std::string const& dir) = 0;

  bool FileMayConflict(std::string const& dir, std::string const& name);

  cmOrderDirectories* OD;
  cmGlobalGenerator* GlobalGenerator;

  // The location in which the item is supposed to be found.
  std::string FullPath;
  std::string Directory;
  std::string FileName;

  // The index assigned to the directory.
  int DirectoryIndex;
};

//----------------------------------------------------------------------------
bool cmOrderDirectoriesConstraint::FileMayConflict(std::string const& dir,
                                                   std::string const& name)
{
  // Check if the file exists on disk.
  std::string file = dir;
  file += "/";
  file += name;
  if(cmSystemTools::FileExists(file.c_str(), true))
    {
    // The file conflicts only if it is not the same as the original
    // file due to a symlink or hardlink.
    return !cmSystemTools::SameFile(this->FullPath.c_str(), file.c_str());
    }

  // Check if the file will be built by cmake.
  std::set<cmStdString> const& files =
    (this->GlobalGenerator->GetDirectoryContent(dir, false));
  std::set<cmStdString>::const_iterator fi = files.find(name);
  return fi != files.end();
}

//----------------------------------------------------------------------------
class cmOrderDirectoriesConstraintSOName: public cmOrderDirectoriesConstraint
{
public:
  cmOrderDirectoriesConstraintSOName(cmOrderDirectories* od,
                                     std::string const& file,
                                     const char* soname):
    cmOrderDirectoriesConstraint(od, file), SOName(soname? soname : "")
    {
    if(this->SOName.empty())
      {
      // Try to guess the soname.
      std::string soguess;
      if(cmSystemTools::GuessLibrarySOName(file, soguess))
        {
        this->SOName = soguess;
        }
      }
    }

  virtual void Report(std::ostream& e)
    {
    e << "runtime library [";
    if(this->SOName.empty())
      {
      e << this->FileName;
      }
    else
      {
      e << this->SOName;
      }
    e << "]";
    }

  virtual bool FindConflict(std::string const& dir);
private:
  // The soname of the shared library if it is known.
  std::string SOName;
};

//----------------------------------------------------------------------------
bool cmOrderDirectoriesConstraintSOName::FindConflict(std::string const& dir)
{
  // Determine which type of check to do.
  if(!this->SOName.empty())
    {
    // We have the library soname.  Check if it will be found.
    if(this->FileMayConflict(dir, this->SOName))
      {
      return true;
      }
    }
  else
    {
    // We do not have the soname.  Look for files in the directory
    // that may conflict.
    std::set<cmStdString> const& files =
      (this->GlobalGenerator
       ->GetDirectoryContent(dir, true));

    // Get the set of files that might conflict.  Since we do not
    // know the soname just look at all files that start with the
    // file name.  Usually the soname starts with the library name.
    std::string base = this->FileName;
    std::set<cmStdString>::const_iterator first = files.lower_bound(base);
    ++base[base.size()-1];
    std::set<cmStdString>::const_iterator last = files.upper_bound(base);
    if(first != last)
      {
      return true;
      }
    }
  return false;
}

//----------------------------------------------------------------------------
class cmOrderDirectoriesConstraintLibrary: public cmOrderDirectoriesConstraint
{
public:
  cmOrderDirectoriesConstraintLibrary(cmOrderDirectories* od,
                                      std::string const& file):
    cmOrderDirectoriesConstraint(od, file)
    {
    }

  virtual void Report(std::ostream& e)
    {
    e << "link library [" << this->FileName << "]";
    }

  virtual bool FindConflict(std::string const& dir);
};

//----------------------------------------------------------------------------
bool cmOrderDirectoriesConstraintLibrary::FindConflict(std::string const& dir)
{
  // We have the library file name.  Check if it will be found.
  if(this->FileMayConflict(dir, this->FileName))
    {
    return true;
    }

  // Now check if the file exists with other extensions the linker
  // might consider.
  if(!this->OD->LinkExtensions.empty() &&
     this->OD->RemoveLibraryExtension.find(this->FileName))
    {
    cmStdString lib = this->OD->RemoveLibraryExtension.match(1);
    cmStdString ext = this->OD->RemoveLibraryExtension.match(2);
    for(std::vector<std::string>::iterator
          i = this->OD->LinkExtensions.begin();
        i != this->OD->LinkExtensions.end(); ++i)
      {
      if(*i != ext)
        {
        std::string fname = lib;
        fname += *i;
        if(this->FileMayConflict(dir, fname.c_str()))
          {
          return true;
          }
        }
      }
    }
  return false;
}

//----------------------------------------------------------------------------
cmOrderDirectories::cmOrderDirectories(cmGlobalGenerator* gg,
                                       cmTarget const* target,
                                       const char* purpose)
{
  this->GlobalGenerator = gg;
  this->Target = target;
  this->Purpose = purpose;
  this->Computed = false;
}

//----------------------------------------------------------------------------
cmOrderDirectories::~cmOrderDirectories()
{
  for(std::vector<cmOrderDirectoriesConstraint*>::iterator
        i = this->ConstraintEntries.begin();
      i != this->ConstraintEntries.end(); ++i)
    {
    delete *i;
    }
  for(std::vector<cmOrderDirectoriesConstraint*>::iterator
        i = this->ImplicitDirEntries.begin();
      i != this->ImplicitDirEntries.end(); ++i)
    {
    delete *i;
    }
}

//----------------------------------------------------------------------------
std::vector<std::string> const& cmOrderDirectories::GetOrderedDirectories()
{
  if(!this->Computed)
    {
    this->Computed = true;
    this->CollectOriginalDirectories();
    this->FindConflicts();
    this->OrderDirectories();
    }
  return this->OrderedDirectories;
}

//----------------------------------------------------------------------------
void cmOrderDirectories::AddRuntimeLibrary(std::string const& fullPath,
                                           const char* soname)
{
  // Add the runtime library at most once.
  if(this->EmmittedConstraintSOName.insert(fullPath).second)
    {
    // Implicit link directories need special handling.
    if(!this->ImplicitDirectories.empty())
      {
      std::string dir = cmSystemTools::GetFilenamePath(fullPath);

      if(fullPath.rfind(".framework") != std::string::npos)
        {
        cmsys::RegularExpression splitFramework;
        splitFramework.compile("^(.*)/(.*).framework/(.*)$");
        if(splitFramework.find(fullPath) &&
          (std::string::npos !=
           splitFramework.match(3).find(splitFramework.match(2))))
          {
          dir = splitFramework.match(1);
          }
        }

      if(this->ImplicitDirectories.find(dir) !=
         this->ImplicitDirectories.end())
        {
        this->ImplicitDirEntries.push_back(
          new cmOrderDirectoriesConstraintSOName(this, fullPath, soname));
        return;
        }
      }

    // Construct the runtime information entry for this library.
    this->ConstraintEntries.push_back(
      new cmOrderDirectoriesConstraintSOName(this, fullPath, soname));
    }
  else
    {
    // This can happen if the same library is linked multiple times.
    // In that case the runtime information check need be done only
    // once anyway.  For shared libs we could add a check in AddItem
    // to not repeat them.
    }
}

//----------------------------------------------------------------------------
void cmOrderDirectories::AddLinkLibrary(std::string const& fullPath)
{
  // Link extension info is required for library constraints.
  assert(!this->LinkExtensions.empty());

  // Add the link library at most once.
  if(this->EmmittedConstraintLibrary.insert(fullPath).second)
    {
    // Implicit link directories need special handling.
    if(!this->ImplicitDirectories.empty())
      {
      std::string dir = cmSystemTools::GetFilenamePath(fullPath);
      if(this->ImplicitDirectories.find(dir) !=
         this->ImplicitDirectories.end())
        {
        this->ImplicitDirEntries.push_back(
          new cmOrderDirectoriesConstraintLibrary(this, fullPath));
        return;
        }
      }

    // Construct the link library entry.
    this->ConstraintEntries.push_back(
      new cmOrderDirectoriesConstraintLibrary(this, fullPath));
    }
}

//----------------------------------------------------------------------------
void
cmOrderDirectories
::AddUserDirectories(std::vector<std::string> const& extra)
{
  this->UserDirectories.insert(this->UserDirectories.end(),
                               extra.begin(), extra.end());
}

//----------------------------------------------------------------------------
void
cmOrderDirectories
::AddLanguageDirectories(std::vector<std::string> const& dirs)
{
  this->LanguageDirectories.insert(this->LanguageDirectories.end(),
                                   dirs.begin(), dirs.end());
}

//----------------------------------------------------------------------------
void
cmOrderDirectories
::SetImplicitDirectories(std::set<cmStdString> const& implicitDirs)
{
  this->ImplicitDirectories = implicitDirs;
}

//----------------------------------------------------------------------------
void
cmOrderDirectories
::SetLinkExtensionInfo(std::vector<std::string> const& linkExtensions,
                       std::string const& removeExtRegex)
{
  this->LinkExtensions = linkExtensions;
  this->RemoveLibraryExtension.compile(removeExtRegex.c_str());
}

//----------------------------------------------------------------------------
void cmOrderDirectories::CollectOriginalDirectories()
{
  // Add user directories specified for inclusion.  These should be
  // indexed first so their original order is preserved as much as
  // possible subject to the constraints.
  this->AddOriginalDirectories(this->UserDirectories);

  // Add directories containing constraints.
  for(unsigned int i=0; i < this->ConstraintEntries.size(); ++i)
    {
    this->ConstraintEntries[i]->AddDirectory();
    }

  // Add language runtime directories last.
  this->AddOriginalDirectories(this->LanguageDirectories);
}

//----------------------------------------------------------------------------
int cmOrderDirectories::AddOriginalDirectory(std::string const& dir)
{
  // Add the runtime directory with a unique index.
  std::map<cmStdString, int>::iterator i =
    this->DirectoryIndex.find(dir);
  if(i == this->DirectoryIndex.end())
    {
    std::map<cmStdString, int>::value_type
      entry(dir, static_cast<int>(this->OriginalDirectories.size()));
    i = this->DirectoryIndex.insert(entry).first;
    this->OriginalDirectories.push_back(dir);
    }

  return i->second;
}

//----------------------------------------------------------------------------
void
cmOrderDirectories
::AddOriginalDirectories(std::vector<std::string> const& dirs)
{
  for(std::vector<std::string>::const_iterator di = dirs.begin();
      di != dirs.end(); ++di)
    {
    // We never explicitly specify implicit link directories.
    if(this->ImplicitDirectories.find(*di) !=
       this->ImplicitDirectories.end())
      {
      continue;
      }

    // Skip the empty string.
    if(di->empty())
      {
      continue;
      }

    // Add this directory.
    this->AddOriginalDirectory(*di);
    }
}

//----------------------------------------------------------------------------
struct cmOrderDirectoriesCompare
{
  typedef std::pair<int, int> ConflictPair;

  // The conflict pair is unique based on just the directory
  // (first).  The second element is only used for displaying
  // information about why the entry is present.
  bool operator()(ConflictPair const& l,
                  ConflictPair const& r)
    {
    return l.first == r.first;
    }
};

//----------------------------------------------------------------------------
void cmOrderDirectories::FindConflicts()
{
  // Allocate the conflict graph.
  this->ConflictGraph.resize(this->OriginalDirectories.size());
  this->DirectoryVisited.resize(this->OriginalDirectories.size(), 0);

  // Find directories conflicting with each entry.
  for(unsigned int i=0; i < this->ConstraintEntries.size(); ++i)
    {
    this->ConstraintEntries[i]->FindConflicts(i);
    }

  // Clean up the conflict graph representation.
  for(std::vector<ConflictList>::iterator
        i = this->ConflictGraph.begin();
      i != this->ConflictGraph.end(); ++i)
    {
    // Sort the outgoing edges for each graph node so that the
    // original order will be preserved as much as possible.
    std::sort(i->begin(), i->end());

    // Make the edge list unique so cycle detection will be reliable.
    ConflictList::iterator last =
      std::unique(i->begin(), i->end(), cmOrderDirectoriesCompare());
    i->erase(last, i->end());
    }

  // Check items in implicit link directories.
  this->FindImplicitConflicts();
}

//----------------------------------------------------------------------------
void cmOrderDirectories::FindImplicitConflicts()
{
  // Check for items in implicit link directories that have conflicts
  // in the explicit directories.
  cmOStringStream conflicts;
  for(unsigned int i=0; i < this->ImplicitDirEntries.size(); ++i)
    {
    this->ImplicitDirEntries[i]->FindImplicitConflicts(conflicts);
    }

  // Skip warning if there were no conflicts.
  std::string text = conflicts.str();
  if(text.empty())
    {
    return;
    }

  // Warn about the conflicts.
  cmOStringStream w;
  w << "Cannot generate a safe " << this->Purpose
    << " for target " << this->Target->GetName()
    << " because files in some directories may conflict with "
    << " libraries in implicit directories:\n"
    << text
    << "Some of these libraries may not be found correctly.";
  this->GlobalGenerator->GetCMakeInstance()
    ->IssueMessage(cmake::WARNING, w.str(), this->Target->GetBacktrace());
}

//----------------------------------------------------------------------------
void cmOrderDirectories::OrderDirectories()
{
  // Allow a cycle to be diagnosed once.
  this->CycleDiagnosed = false;
  this->WalkId = 0;

  // Iterate through the directories in the original order.
  for(unsigned int i=0; i < this->OriginalDirectories.size(); ++i)
    {
    // Start a new DFS from this node.
    ++this->WalkId;
    this->VisitDirectory(i);
    }
}

//----------------------------------------------------------------------------
void cmOrderDirectories::VisitDirectory(unsigned int i)
{
  // Skip nodes already visited.
  if(this->DirectoryVisited[i])
    {
    if(this->DirectoryVisited[i] == this->WalkId)
      {
      // We have reached a node previously visited on this DFS.
      // There is a cycle.
      this->DiagnoseCycle();
      }
    return;
    }

  // We are now visiting this node so mark it.
  this->DirectoryVisited[i] = this->WalkId;

  // Visit the neighbors of the node first.
  ConflictList const& clist = this->ConflictGraph[i];
  for(ConflictList::const_iterator j = clist.begin();
      j != clist.end(); ++j)
    {
    this->VisitDirectory(j->first);
    }

  // Now that all directories required to come before this one have
  // been emmitted, emit this directory.
  this->OrderedDirectories.push_back(this->OriginalDirectories[i]);
}

//----------------------------------------------------------------------------
void cmOrderDirectories::DiagnoseCycle()
{
  // Report the cycle at most once.
  if(this->CycleDiagnosed)
    {
    return;
    }
  this->CycleDiagnosed = true;

  // Construct the message.
  cmOStringStream e;
  e << "Cannot generate a safe " << this->Purpose
    << " for target " << this->Target->GetName()
    << " because there is a cycle in the constraint graph:\n";

  // Display the conflict graph.
  for(unsigned int i=0; i < this->ConflictGraph.size(); ++i)
    {
    ConflictList const& clist = this->ConflictGraph[i];
    e << "  dir " << i << " is [" << this->OriginalDirectories[i] << "]\n";
    for(ConflictList::const_iterator j = clist.begin();
        j != clist.end(); ++j)
      {
      e << "    dir " << j->first << " must precede it due to ";
      this->ConstraintEntries[j->second]->Report(e);
      e << "\n";
      }
    }
  e << "Some of these libraries may not be found correctly.";
  this->GlobalGenerator->GetCMakeInstance()
    ->IssueMessage(cmake::WARNING, e.str(), this->Target->GetBacktrace());
}
'n356' href='#n356'>356</a>
<a id='n357' href='#n357'>357</a>
<a id='n358' href='#n358'>358</a>
<a id='n359' href='#n359'>359</a>
<a id='n360' href='#n360'>360</a>
<a id='n361' href='#n361'>361</a>
<a id='n362' href='#n362'>362</a>
<a id='n363' href='#n363'>363</a>
<a id='n364' href='#n364'>364</a>
<a id='n365' href='#n365'>365</a>
<a id='n366' href='#n366'>366</a>
<a id='n367' href='#n367'>367</a>
<a id='n368' href='#n368'>368</a>
<a id='n369' href='#n369'>369</a>
<a id='n370' href='#n370'>370</a>
<a id='n371' href='#n371'>371</a>
<a id='n372' href='#n372'>372</a>
<a id='n373' href='#n373'>373</a>
<a id='n374' href='#n374'>374</a>
<a id='n375' href='#n375'>375</a>
<a id='n376' href='#n376'>376</a>
<a id='n377' href='#n377'>377</a>
<a id='n378' href='#n378'>378</a>
<a id='n379' href='#n379'>379</a>
<a id='n380' href='#n380'>380</a>
<a id='n381' href='#n381'>381</a>
<a id='n382' href='#n382'>382</a>
<a id='n383' href='#n383'>383</a>
<a id='n384' href='#n384'>384</a>
<a id='n385' href='#n385'>385</a>
<a id='n386' href='#n386'>386</a>
<a id='n387' href='#n387'>387</a>
<a id='n388' href='#n388'>388</a>
<a id='n389' href='#n389'>389</a>
<a id='n390' href='#n390'>390</a>
<a id='n391' href='#n391'>391</a>
<a id='n392' href='#n392'>392</a>
<a id='n393' href='#n393'>393</a>
<a id='n394' href='#n394'>394</a>
<a id='n395' href='#n395'>395</a>
<a id='n396' href='#n396'>396</a>
<a id='n397' href='#n397'>397</a>
<a id='n398' href='#n398'>398</a>
<a id='n399' href='#n399'>399</a>
<a id='n400' href='#n400'>400</a>
<a id='n401' href='#n401'>401</a>
<a id='n402' href='#n402'>402</a>
<a id='n403' href='#n403'>403</a>
<a id='n404' href='#n404'>404</a>
<a id='n405' href='#n405'>405</a>
<a id='n406' href='#n406'>406</a>
<a id='n407' href='#n407'>407</a>
<a id='n408' href='#n408'>408</a>
<a id='n409' href='#n409'>409</a>
<a id='n410' href='#n410'>410</a>
<a id='n411' href='#n411'>411</a>
<a id='n412' href='#n412'>412</a>
<a id='n413' href='#n413'>413</a>
<a id='n414' href='#n414'>414</a>
<a id='n415' href='#n415'>415</a>
<a id='n416' href='#n416'>416</a>
<a id='n417' href='#n417'>417</a>
<a id='n418' href='#n418'>418</a>
<a id='n419' href='#n419'>419</a>
<a id='n420' href='#n420'>420</a>
<a id='n421' href='#n421'>421</a>
<a id='n422' href='#n422'>422</a>
<a id='n423' href='#n423'>423</a>
<a id='n424' href='#n424'>424</a>
<a id='n425' href='#n425'>425</a>
<a id='n426' href='#n426'>426</a>
<a id='n427' href='#n427'>427</a>
<a id='n428' href='#n428'>428</a>
<a id='n429' href='#n429'>429</a>
<a id='n430' href='#n430'>430</a>
<a id='n431' href='#n431'>431</a>
<a id='n432' href='#n432'>432</a>
<a id='n433' href='#n433'>433</a>
<a id='n434' href='#n434'>434</a>
<a id='n435' href='#n435'>435</a>
<a id='n436' href='#n436'>436</a>
<a id='n437' href='#n437'>437</a>
<a id='n438' href='#n438'>438</a>
<a id='n439' href='#n439'>439</a>
<a id='n440' href='#n440'>440</a>
<a id='n441' href='#n441'>441</a>
<a id='n442' href='#n442'>442</a>
<a id='n443' href='#n443'>443</a>
<a id='n444' href='#n444'>444</a>
<a id='n445' href='#n445'>445</a>
<a id='n446' href='#n446'>446</a>
<a id='n447' href='#n447'>447</a>
<a id='n448' href='#n448'>448</a>
<a id='n449' href='#n449'>449</a>
<a id='n450' href='#n450'>450</a>
<a id='n451' href='#n451'>451</a>
<a id='n452' href='#n452'>452</a>
<a id='n453' href='#n453'>453</a>
<a id='n454' href='#n454'>454</a>
<a id='n455' href='#n455'>455</a>
<a id='n456' href='#n456'>456</a>
<a id='n457' href='#n457'>457</a>
<a id='n458' href='#n458'>458</a>
<a id='n459' href='#n459'>459</a>
<a id='n460' href='#n460'>460</a>
<a id='n461' href='#n461'>461</a>
<a id='n462' href='#n462'>462</a>
<a id='n463' href='#n463'>463</a>
<a id='n464' href='#n464'>464</a>
<a id='n465' href='#n465'>465</a>
<a id='n466' href='#n466'>466</a>
<a id='n467' href='#n467'>467</a>
<a id='n468' href='#n468'>468</a>
<a id='n469' href='#n469'>469</a>
<a id='n470' href='#n470'>470</a>
<a id='n471' href='#n471'>471</a>
<a id='n472' href='#n472'>472</a>
<a id='n473' href='#n473'>473</a>
<a id='n474' href='#n474'>474</a>
<a id='n475' href='#n475'>475</a>
<a id='n476' href='#n476'>476</a>
<a id='n477' href='#n477'>477</a>
<a id='n478' href='#n478'>478</a>
<a id='n479' href='#n479'>479</a>
<a id='n480' href='#n480'>480</a>
<a id='n481' href='#n481'>481</a>
<a id='n482' href='#n482'>482</a>
<a id='n483' href='#n483'>483</a>
<a id='n484' href='#n484'>484</a>
<a id='n485' href='#n485'>485</a>
<a id='n486' href='#n486'>486</a>
<a id='n487' href='#n487'>487</a>
<a id='n488' href='#n488'>488</a>
<a id='n489' href='#n489'>489</a>
<a id='n490' href='#n490'>490</a>
<a id='n491' href='#n491'>491</a>
<a id='n492' href='#n492'>492</a>
<a id='n493' href='#n493'>493</a>
<a id='n494' href='#n494'>494</a>
<a id='n495' href='#n495'>495</a>
<a id='n496' href='#n496'>496</a>
<a id='n497' href='#n497'>497</a>
<a id='n498' href='#n498'>498</a>
<a id='n499' href='#n499'>499</a>
<a id='n500' href='#n500'>500</a>
<a id='n501' href='#n501'>501</a>
<a id='n502' href='#n502'>502</a>
<a id='n503' href='#n503'>503</a>
<a id='n504' href='#n504'>504</a>
<a id='n505' href='#n505'>505</a>
<a id='n506' href='#n506'>506</a>
<a id='n507' href='#n507'>507</a>
<a id='n508' href='#n508'>508</a>
<a id='n509' href='#n509'>509</a>
<a id='n510' href='#n510'>510</a>
<a id='n511' href='#n511'>511</a>
<a id='n512' href='#n512'>512</a>
<a id='n513' href='#n513'>513</a>
<a id='n514' href='#n514'>514</a>
<a id='n515' href='#n515'>515</a>
<a id='n516' href='#n516'>516</a>
<a id='n517' href='#n517'>517</a>
<a id='n518' href='#n518'>518</a>
<a id='n519' href='#n519'>519</a>
<a id='n520' href='#n520'>520</a>
<a id='n521' href='#n521'>521</a>
<a id='n522' href='#n522'>522</a>
<a id='n523' href='#n523'>523</a>
<a id='n524' href='#n524'>524</a>
<a id='n525' href='#n525'>525</a>
<a id='n526' href='#n526'>526</a>
<a id='n527' href='#n527'>527</a>
<a id='n528' href='#n528'>528</a>
<a id='n529' href='#n529'>529</a>
<a id='n530' href='#n530'>530</a>
<a id='n531' href='#n531'>531</a>
<a id='n532' href='#n532'>532</a>
<a id='n533' href='#n533'>533</a>
<a id='n534' href='#n534'>534</a>
<a id='n535' href='#n535'>535</a>
<a id='n536' href='#n536'>536</a>
<a id='n537' href='#n537'>537</a>
<a id='n538' href='#n538'>538</a>
<a id='n539' href='#n539'>539</a>
<a id='n540' href='#n540'>540</a>
<a id='n541' href='#n541'>541</a>
<a id='n542' href='#n542'>542</a>
<a id='n543' href='#n543'>543</a>
<a id='n544' href='#n544'>544</a>
<a id='n545' href='#n545'>545</a>
<a id='n546' href='#n546'>546</a>
<a id='n547' href='#n547'>547</a>
<a id='n548' href='#n548'>548</a>
<a id='n549' href='#n549'>549</a>
<a id='n550' href='#n550'>550</a>
<a id='n551' href='#n551'>551</a>
<a id='n552' href='#n552'>552</a>
<a id='n553' href='#n553'>553</a>
<a id='n554' href='#n554'>554</a>
<a id='n555' href='#n555'>555</a>
<a id='n556' href='#n556'>556</a>
<a id='n557' href='#n557'>557</a>
<a id='n558' href='#n558'>558</a>
<a id='n559' href='#n559'>559</a>
<a id='n560' href='#n560'>560</a>
<a id='n561' href='#n561'>561</a>
<a id='n562' href='#n562'>562</a>
<a id='n563' href='#n563'>563</a>
<a id='n564' href='#n564'>564</a>
<a id='n565' href='#n565'>565</a>
<a id='n566' href='#n566'>566</a>
<a id='n567' href='#n567'>567</a>
<a id='n568' href='#n568'>568</a>
<a id='n569' href='#n569'>569</a>
<a id='n570' href='#n570'>570</a>
<a id='n571' href='#n571'>571</a>
<a id='n572' href='#n572'>572</a>
<a id='n573' href='#n573'>573</a>
<a id='n574' href='#n574'>574</a>
<a id='n575' href='#n575'>575</a>
<a id='n576' href='#n576'>576</a>
<a id='n577' href='#n577'>577</a>
<a id='n578' href='#n578'>578</a>
<a id='n579' href='#n579'>579</a>
<a id='n580' href='#n580'>580</a>
<a id='n581' href='#n581'>581</a>
<a id='n582' href='#n582'>582</a>
<a id='n583' href='#n583'>583</a>
<a id='n584' href='#n584'>584</a>
<a id='n585' href='#n585'>585</a>
<a id='n586' href='#n586'>586</a>
<a id='n587' href='#n587'>587</a>
<a id='n588' href='#n588'>588</a>
<a id='n589' href='#n589'>589</a>
<a id='n590' href='#n590'>590</a>
<a id='n591' href='#n591'>591</a>
<a id='n592' href='#n592'>592</a>
<a id='n593' href='#n593'>593</a>
<a id='n594' href='#n594'>594</a>
<a id='n595' href='#n595'>595</a>
<a id='n596' href='#n596'>596</a>
<a id='n597' href='#n597'>597</a>
<a id='n598' href='#n598'>598</a>
<a id='n599' href='#n599'>599</a>
<a id='n600' href='#n600'>600</a>
<a id='n601' href='#n601'>601</a>
<a id='n602' href='#n602'>602</a>
<a id='n603' href='#n603'>603</a>
<a id='n604' href='#n604'>604</a>
<a id='n605' href='#n605'>605</a>
<a id='n606' href='#n606'>606</a>
<a id='n607' href='#n607'>607</a>
<a id='n608' href='#n608'>608</a>
<a id='n609' href='#n609'>609</a>
<a id='n610' href='#n610'>610</a>
<a id='n611' href='#n611'>611</a>
<a id='n612' href='#n612'>612</a>
<a id='n613' href='#n613'>613</a>
<a id='n614' href='#n614'>614</a>
<a id='n615' href='#n615'>615</a>
<a id='n616' href='#n616'>616</a>
<a id='n617' href='#n617'>617</a>
<a id='n618' href='#n618'>618</a>
<a id='n619' href='#n619'>619</a>
<a id='n620' href='#n620'>620</a>
<a id='n621' href='#n621'>621</a>
<a id='n622' href='#n622'>622</a>
<a id='n623' href='#n623'>623</a>
<a id='n624' href='#n624'>624</a>
<a id='n625' href='#n625'>625</a>
<a id='n626' href='#n626'>626</a>
<a id='n627' href='#n627'>627</a>
<a id='n628' href='#n628'>628</a>
<a id='n629' href='#n629'>629</a>
<a id='n630' href='#n630'>630</a>
<a id='n631' href='#n631'>631</a>
<a id='n632' href='#n632'>632</a>
<a id='n633' href='#n633'>633</a>
<a id='n634' href='#n634'>634</a>
<a id='n635' href='#n635'>635</a>
<a id='n636' href='#n636'>636</a>
<a id='n637' href='#n637'>637</a>
<a id='n638' href='#n638'>638</a>
<a id='n639' href='#n639'>639</a>
<a id='n640' href='#n640'>640</a>
<a id='n641' href='#n641'>641</a>
<a id='n642' href='#n642'>642</a>
<a id='n643' href='#n643'>643</a>
<a id='n644' href='#n644'>644</a>
<a id='n645' href='#n645'>645</a>
<a id='n646' href='#n646'>646</a>
<a id='n647' href='#n647'>647</a>
<a id='n648' href='#n648'>648</a>
<a id='n649' href='#n649'>649</a>
<a id='n650' href='#n650'>650</a>
<a id='n651' href='#n651'>651</a>
<a id='n652' href='#n652'>652</a>
<a id='n653' href='#n653'>653</a>
<a id='n654' href='#n654'>654</a>
<a id='n655' href='#n655'>655</a>
<a id='n656' href='#n656'>656</a>
<a id='n657' href='#n657'>657</a>
<a id='n658' href='#n658'>658</a>
<a id='n659' href='#n659'>659</a>
<a id='n660' href='#n660'>660</a>
<a id='n661' href='#n661'>661</a>
<a id='n662' href='#n662'>662</a>
<a id='n663' href='#n663'>663</a>
<a id='n664' href='#n664'>664</a>
<a id='n665' href='#n665'>665</a>
<a id='n666' href='#n666'>666</a>
<a id='n667' href='#n667'>667</a>
<a id='n668' href='#n668'>668</a>
<a id='n669' href='#n669'>669</a>
<a id='n670' href='#n670'>670</a>
<a id='n671' href='#n671'>671</a>
<a id='n672' href='#n672'>672</a>
<a id='n673' href='#n673'>673</a>
<a id='n674' href='#n674'>674</a>
<a id='n675' href='#n675'>675</a>
<a id='n676' href='#n676'>676</a>
<a id='n677' href='#n677'>677</a>
<a id='n678' href='#n678'>678</a>
<a id='n679' href='#n679'>679</a>
<a id='n680' href='#n680'>680</a>
<a id='n681' href='#n681'>681</a>
<a id='n682' href='#n682'>682</a>
<a id='n683' href='#n683'>683</a>
<a id='n684' href='#n684'>684</a>
<a id='n685' href='#n685'>685</a>
<a id='n686' href='#n686'>686</a>
<a id='n687' href='#n687'>687</a>
<a id='n688' href='#n688'>688</a>
<a id='n689' href='#n689'>689</a>
<a id='n690' href='#n690'>690</a>
<a id='n691' href='#n691'>691</a>
<a id='n692' href='#n692'>692</a>
<a id='n693' href='#n693'>693</a>
<a id='n694' href='#n694'>694</a>
<a id='n695' href='#n695'>695</a>
<a id='n696' href='#n696'>696</a>
<a id='n697' href='#n697'>697</a>
<a id='n698' href='#n698'>698</a>
<a id='n699' href='#n699'>699</a>
<a id='n700' href='#n700'>700</a>
<a id='n701' href='#n701'>701</a>
<a id='n702' href='#n702'>702</a>
<a id='n703' href='#n703'>703</a>
<a id='n704' href='#n704'>704</a>
<a id='n705' href='#n705'>705</a>
<a id='n706' href='#n706'>706</a>
<a id='n707' href='#n707'>707</a>
<a id='n708' href='#n708'>708</a>
<a id='n709' href='#n709'>709</a>
<a id='n710' href='#n710'>710</a>
<a id='n711' href='#n711'>711</a>
<a id='n712' href='#n712'>712</a>
<a id='n713' href='#n713'>713</a>
<a id='n714' href='#n714'>714</a>
<a id='n715' href='#n715'>715</a>
<a id='n716' href='#n716'>716</a>
<a id='n717' href='#n717'>717</a>
<a id='n718' href='#n718'>718</a>
<a id='n719' href='#n719'>719</a>
<a id='n720' href='#n720'>720</a>
<a id='n721' href='#n721'>721</a>
<a id='n722' href='#n722'>722</a>
<a id='n723' href='#n723'>723</a>
<a id='n724' href='#n724'>724</a>
<a id='n725' href='#n725'>725</a>
<a id='n726' href='#n726'>726</a>
<a id='n727' href='#n727'>727</a>
<a id='n728' href='#n728'>728</a>
<a id='n729' href='#n729'>729</a>
<a id='n730' href='#n730'>730</a>
<a id='n731' href='#n731'>731</a>
<a id='n732' href='#n732'>732</a>
<a id='n733' href='#n733'>733</a>
<a id='n734' href='#n734'>734</a>
<a id='n735' href='#n735'>735</a>
<a id='n736' href='#n736'>736</a>
<a id='n737' href='#n737'>737</a>
<a id='n738' href='#n738'>738</a>
<a id='n739' href='#n739'>739</a>
<a id='n740' href='#n740'>740</a>
<a id='n741' href='#n741'>741</a>
<a id='n742' href='#n742'>742</a>
<a id='n743' href='#n743'>743</a>
<a id='n744' href='#n744'>744</a>
<a id='n745' href='#n745'>745</a>
<a id='n746' href='#n746'>746</a>
<a id='n747' href='#n747'>747</a>
<a id='n748' href='#n748'>748</a>
<a id='n749' href='#n749'>749</a>
<a id='n750' href='#n750'>750</a>
<a id='n751' href='#n751'>751</a>
<a id='n752' href='#n752'>752</a>
<a id='n753' href='#n753'>753</a>
<a id='n754' href='#n754'>754</a>
<a id='n755' href='#n755'>755</a>
<a id='n756' href='#n756'>756</a>
<a id='n757' href='#n757'>757</a>
<a id='n758' href='#n758'>758</a>
<a id='n759' href='#n759'>759</a>
<a id='n760' href='#n760'>760</a>
<a id='n761' href='#n761'>761</a>
<a id='n762' href='#n762'>762</a>
<a id='n763' href='#n763'>763</a>
<a id='n764' href='#n764'>764</a>
<a id='n765' href='#n765'>765</a>
<a id='n766' href='#n766'>766</a>
<a id='n767' href='#n767'>767</a>
<a id='n768' href='#n768'>768</a>
<a id='n769' href='#n769'>769</a>
<a id='n770' href='#n770'>770</a>
<a id='n771' href='#n771'>771</a>
<a id='n772' href='#n772'>772</a>
<a id='n773' href='#n773'>773</a>
<a id='n774' href='#n774'>774</a>
<a id='n775' href='#n775'>775</a>
<a id='n776' href='#n776'>776</a>
<a id='n777' href='#n777'>777</a>
<a id='n778' href='#n778'>778</a>
<a id='n779' href='#n779'>779</a>
<a id='n780' href='#n780'>780</a>
<a id='n781' href='#n781'>781</a>
</pre></td>
<td class='lines'><pre><code><span class="hl com">/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *</span>
<span class="hl com"> * Copyright by The HDF Group.                                               *</span>
<span class="hl com"> * Copyright by the Board of Trustees of the University of Illinois.         *</span>
<span class="hl com"> * All rights reserved.                                                      *</span>
<span class="hl com"> *                                                                           *</span>
<span class="hl com"> * This file is part of HDF5.  The full HDF5 copyright notice, including     *</span>
<span class="hl com"> * terms governing use, modification, and redistribution, is contained in    *</span>
<span class="hl com"> * the files COPYING and Copyright.html.  COPYING can be found at the root   *</span>
<span class="hl com"> * of the source code distribution tree; Copyright.html can be found at the  *</span>
<span class="hl com"> * root level of an installed copy of the electronic HDF5 document set and   *</span>
<span class="hl com"> * is linked from the top-level documents page.  It can also be found at     *</span>
<span class="hl com"> * http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *</span>
<span class="hl com"> * access to either file, you may request a copy from help&#64;hdfgroup.org.     *</span>
<span class="hl com"> * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */</span>

<span class="hl com">/* Programmer:  John Mainzer</span>
<span class="hl com"> *              10/27/05</span>
<span class="hl com"> *</span>
<span class="hl com"> *		This file contains common #defines, type definitions, and</span>
<span class="hl com"> *		externs for tests of the cache implemented in H5C.c</span>
<span class="hl com"> */</span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;h5test.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5Iprivate.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5ACprivate.h&quot;</span><span class="hl ppc"></span>

<span class="hl ppc">#define H5C_PACKAGE</span>             <span class="hl com">/*suppress error about including H5Cpkg   */</span><span class="hl ppc"></span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5Cpkg.h&quot;</span><span class="hl ppc"></span>

<span class="hl ppc">#define H5F_PACKAGE</span>             <span class="hl com">/*suppress error about including H5Fpkg   */</span><span class="hl ppc"></span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5Fpkg.h&quot;</span><span class="hl ppc"></span>

<span class="hl ppc">#define NO_CHANGE       -1</span>

<span class="hl com">/* with apologies for the abuse of terminology... */</span>

<span class="hl ppc">#define PICO_ENTRY_TYPE		0</span>
<span class="hl ppc">#define NANO_ENTRY_TYPE		1</span>
<span class="hl ppc">#define MICRO_ENTRY_TYPE	2</span>
<span class="hl ppc">#define TINY_ENTRY_TYPE		3</span>
<span class="hl ppc">#define SMALL_ENTRY_TYPE	4</span>
<span class="hl ppc">#define MEDIUM_ENTRY_TYPE	5</span>
<span class="hl ppc">#define LARGE_ENTRY_TYPE	6</span>
<span class="hl ppc">#define HUGE_ENTRY_TYPE		7</span>
<span class="hl ppc">#define MONSTER_ENTRY_TYPE	8</span>
<span class="hl ppc">#define VARIABLE_ENTRY_TYPE	9</span>

<span class="hl ppc">#define NUMBER_OF_ENTRY_TYPES   10	</span>

<span class="hl ppc">#define PICO_ENTRY_SIZE		(size_t)1</span>
<span class="hl ppc">#define NANO_ENTRY_SIZE		(size_t)4</span>
<span class="hl ppc">#define MICRO_ENTRY_SIZE	(size_t)16</span>
<span class="hl ppc">#define TINY_ENTRY_SIZE		(size_t)64</span>
<span class="hl ppc">#define SMALL_ENTRY_SIZE	(size_t)256</span>
<span class="hl ppc">#define MEDIUM_ENTRY_SIZE	(size_t)1024</span>
<span class="hl ppc">#define LARGE_ENTRY_SIZE	(size_t)(4 * 1024)</span>
<span class="hl ppc">#define HUGE_ENTRY_SIZE		(size_t)(16 * 1024)</span>
<span class="hl ppc">#define MONSTER_ENTRY_SIZE	(size_t)(64 * 1024)</span>
<span class="hl ppc">#define VARIABLE_ENTRY_SIZE	(size_t)(10 * 1024)</span>

<span class="hl ppc">#define NUM_PICO_ENTRIES	(10 * 1024)</span>
<span class="hl ppc">#define NUM_NANO_ENTRIES	(10 * 1024)</span>
<span class="hl ppc">#define NUM_MICRO_ENTRIES	(10 * 1024)</span>
<span class="hl ppc">#define NUM_TINY_ENTRIES	(10 * 1024)</span>
<span class="hl ppc">#define NUM_SMALL_ENTRIES	(10 * 1024)</span>
<span class="hl ppc">#define NUM_MEDIUM_ENTRIES	(10 * 1024)</span>
<span class="hl ppc">#define NUM_LARGE_ENTRIES	(10 * 1024)</span>
<span class="hl ppc">#define NUM_HUGE_ENTRIES	(10 * 1024)</span>
<span class="hl ppc">#define NUM_MONSTER_ENTRIES	(10 * 1024)</span>
<span class="hl ppc">#define NUM_VARIABLE_ENTRIES	(10 * 1024)</span>

<span class="hl ppc">#define MAX_ENTRIES		(10 * 1024)</span>

<span class="hl ppc">#define PICO_BASE_ADDR		(haddr_t)0</span>
<span class="hl ppc">#define NANO_BASE_ADDR		(haddr_t)(PICO_BASE_ADDR + \</span>
<span class="hl ppc">                                      (PICO_ENTRY_SIZE * NUM_PICO_ENTRIES))</span>
<span class="hl ppc">#define MICRO_BASE_ADDR		(haddr_t)(NANO_BASE_ADDR + \</span>
<span class="hl ppc">                                      (NANO_ENTRY_SIZE * NUM_NANO_ENTRIES))</span>
<span class="hl ppc">#define TINY_BASE_ADDR		(haddr_t)(MICRO_BASE_ADDR + \</span>
<span class="hl ppc">			              (MICRO_ENTRY_SIZE * NUM_MICRO_ENTRIES))</span>
<span class="hl ppc">#define SMALL_BASE_ADDR		(haddr_t)(TINY_BASE_ADDR + \</span>
<span class="hl ppc">                                      (TINY_ENTRY_SIZE * NUM_TINY_ENTRIES))</span>
<span class="hl ppc">#define MEDIUM_BASE_ADDR	(haddr_t)(SMALL_BASE_ADDR + \</span>
<span class="hl ppc">                                      (SMALL_ENTRY_SIZE * NUM_SMALL_ENTRIES))</span>
<span class="hl ppc">#define LARGE_BASE_ADDR		(haddr_t)(MEDIUM_BASE_ADDR + \</span>
<span class="hl ppc">                                      (MEDIUM_ENTRY_SIZE * NUM_MEDIUM_ENTRIES))</span>
<span class="hl ppc">#define HUGE_BASE_ADDR		(haddr_t)(LARGE_BASE_ADDR + \</span>
<span class="hl ppc">                                      (LARGE_ENTRY_SIZE * NUM_LARGE_ENTRIES))</span>
<span class="hl ppc">#define MONSTER_BASE_ADDR	(haddr_t)(HUGE_BASE_ADDR + \</span>
<span class="hl ppc">                                      (HUGE_ENTRY_SIZE * NUM_HUGE_ENTRIES))</span>
<span class="hl ppc">#define VARIABLE_BASE_ADDR	(haddr_t)(MONSTER_BASE_ADDR + \</span>
<span class="hl ppc">				     (MONSTER_ENTRY_SIZE * NUM_MONSTER_ENTRIES))</span>

<span class="hl ppc">#define PICO_ALT_BASE_ADDR	(haddr_t)(VARIABLE_BASE_ADDR + \</span>
<span class="hl ppc">			           (VARIABLE_ENTRY_SIZE * NUM_VARIABLE_ENTRIES))</span>
<span class="hl ppc">#define NANO_ALT_BASE_ADDR	(haddr_t)(PICO_ALT_BASE_ADDR + \</span>
<span class="hl ppc">                                      (PICO_ENTRY_SIZE * NUM_PICO_ENTRIES))</span>
<span class="hl ppc">#define MICRO_ALT_BASE_ADDR	(haddr_t)(NANO_ALT_BASE_ADDR + \</span>
<span class="hl ppc">                                      (NANO_ENTRY_SIZE * NUM_NANO_ENTRIES))</span>
<span class="hl ppc">#define TINY_ALT_BASE_ADDR	(haddr_t)(MICRO_ALT_BASE_ADDR + \</span>
<span class="hl ppc">			              (MICRO_ENTRY_SIZE * NUM_MICRO_ENTRIES))</span>
<span class="hl ppc">#define SMALL_ALT_BASE_ADDR	(haddr_t)(TINY_ALT_BASE_ADDR + \</span>
<span class="hl ppc">                                      (TINY_ENTRY_SIZE * NUM_TINY_ENTRIES))</span>
<span class="hl ppc">#define MEDIUM_ALT_BASE_ADDR	(haddr_t)(SMALL_ALT_BASE_ADDR + \</span>
<span class="hl ppc">                                      (SMALL_ENTRY_SIZE * NUM_SMALL_ENTRIES))</span>
<span class="hl ppc">#define LARGE_ALT_BASE_ADDR	(haddr_t)(MEDIUM_ALT_BASE_ADDR + \</span>
<span class="hl ppc">                                      (MEDIUM_ENTRY_SIZE * NUM_MEDIUM_ENTRIES))</span>
<span class="hl ppc">#define HUGE_ALT_BASE_ADDR	(haddr_t)(LARGE_ALT_BASE_ADDR + \</span>
<span class="hl ppc">                                      (LARGE_ENTRY_SIZE * NUM_LARGE_ENTRIES))</span>
<span class="hl ppc">#define MONSTER_ALT_BASE_ADDR	(haddr_t)(HUGE_ALT_BASE_ADDR + \</span>
<span class="hl ppc">                                      (HUGE_ENTRY_SIZE * NUM_HUGE_ENTRIES))</span>
<span class="hl ppc">#define VARIABLE_ALT_BASE_ADDR	(haddr_t)(MONSTER_ALT_BASE_ADDR + \</span>
<span class="hl ppc">                                     (MONSTER_ENTRY_SIZE * NUM_MONSTER_ENTRIES))</span>

<span class="hl ppc">#define MAX_PINS	8</span>	<span class="hl com">/* Maximum number of entries that can be</span>
<span class="hl com">				 * directly pinned by a single entry.</span>
<span class="hl com">				 */</span><span class="hl ppc"></span>

<span class="hl ppc">#define FLUSH_OP__NO_OP		0</span>
<span class="hl ppc">#define FLUSH_OP__DIRTY		1</span>
<span class="hl ppc">#define FLUSH_OP__RESIZE	2</span>
<span class="hl ppc">#define FLUSH_OP__RENAME	3</span>
<span class="hl ppc">#define FLUSH_OP__MAX_OP	3</span>

<span class="hl ppc">#define MAX_FLUSH_OPS		10</span>	<span class="hl com">/* Maximum number of flush operations</span>
<span class="hl com">					 * that can be associated with a </span>
<span class="hl com">					 * cache entry.</span>
<span class="hl com">					 */</span><span class="hl ppc"></span>

<span class="hl kwc">typedef</span> <span class="hl kwb">struct</span> flush_op
<span class="hl opt">{</span>
    <span class="hl kwb">int</span>			op_code<span class="hl opt">;</span>	<span class="hl com">/* integer op code indicating the</span>
<span class="hl com">					 * operation to be performed.  At</span>
<span class="hl com">					 * present it must be one of:</span>
<span class="hl com">					 *</span>
<span class="hl com">					 *   FLUSH_OP__NO_OP</span>
<span class="hl com">					 *   FLUSH_OP__DIRTY</span>
<span class="hl com">					 *   FLUSH_OP__RESIZE</span>
<span class="hl com">					 *   FLUSH_OP__RENAME</span>
<span class="hl com">					 */</span>
    <span class="hl kwb">int</span>			type<span class="hl opt">;</span>		<span class="hl com">/* type code of the cache entry that</span>
<span class="hl com">					 * is the target of the operation.</span>
<span class="hl com">					 * This value is passed into the</span>
<span class="hl com">					 * function implementing the flush</span>
<span class="hl com">					 * operation.</span>
<span class="hl com">					 */</span>
    <span class="hl kwb">int</span>			idx<span class="hl opt">;</span>		<span class="hl com">/* index of the cache entry that</span>
<span class="hl com">					 * is the target of the operation.</span>
<span class="hl com">					 * This value is passed into the</span>
<span class="hl com">                                         * function implementing the flush</span>
<span class="hl com">                                         * operation.</span>
<span class="hl com">					 */</span>
    hbool_t		flag<span class="hl opt">;</span>		<span class="hl com">/* boolean flag passed into the </span>
<span class="hl com">					 * function implementing the flush</span>
<span class="hl com">					 * operation.  The meaning of the</span>
<span class="hl com">					 * flag is dependant upon the flush</span>
<span class="hl com">					 * operation:</span>
<span class="hl com">					 *</span>
<span class="hl com">					 * FLUSH_OP__DIRTY: TRUE iff the </span>
<span class="hl com">					 *   target is pinned, and is to </span>
<span class="hl com">					 *   be dirtied via the </span>
<span class="hl com">					 *   H5C_mark_pinned_entry_dirty()</span>
<span class="hl com">					 *   call.</span>
<span class="hl com">					 *</span>
<span class="hl com">					 * FLUSH_OP__RESIZE: TRUE iff the</span>
<span class="hl com">					 *   target is pinned, and is to </span>
<span class="hl com">					 *   be resized via the </span>
<span class="hl com">					 *   H5C_mark_pinned_entry_dirty()</span>
<span class="hl com">					 *   call.</span>
<span class="hl com">					 *</span>
<span class="hl com">					 * FLUSH_OP__RENAME: TRUE iff the</span>
<span class="hl com">					 *    target is to be renamed to </span>
<span class="hl com">					 *    its main address.</span>
<span class="hl com">					 */</span>
    <span class="hl kwb">size_t</span>		size<span class="hl opt">;</span>		<span class="hl com">/* New target size in the </span>
<span class="hl com">					 * FLUSH_OP__RENAME operation.</span>
<span class="hl com">					 * Unused elsewhere.</span>
<span class="hl com">					 */</span>
<span class="hl opt">}</span> flush_op<span class="hl opt">;</span>

<span class="hl kwc">typedef</span> <span class="hl kwb">struct</span> test_entry_t
<span class="hl opt">{</span>
    H5C_cache_entry_t	  header<span class="hl opt">;</span>	<span class="hl com">/* entry data used by the cache</span>
<span class="hl com">					 * -- must be first</span>
<span class="hl com">                               		 */</span>
    <span class="hl kwb">struct</span> test_entry_t <span class="hl opt">*</span> self<span class="hl opt">;</span> 	<span class="hl com">/* pointer to this entry -- used for</span>
<span class="hl com">					 * sanity checking.</span>
<span class="hl com">                                         */</span>
    H5C_t               <span class="hl opt">*</span> cache_ptr<span class="hl opt">;</span>	<span class="hl com">/* pointer to the cache in which</span>
<span class="hl com">					 * the entry resides, or NULL if the</span>
<span class="hl com">					 * entry is not in cache.</span>
<span class="hl com">					 */</span>
    haddr_t		  addr<span class="hl opt">;</span>         <span class="hl com">/* where the cache thinks this entry</span>
<span class="hl com">                                         * is located</span>
<span class="hl com">                                         */</span>
    hbool_t		  at_main_addr<span class="hl opt">;</span>	<span class="hl com">/* boolean flag indicating whether</span>
<span class="hl com">					 * the entry is supposed to be at</span>
<span class="hl com">					 * either its main or alternate</span>
<span class="hl com">					 * address.</span>
<span class="hl com">     					 */</span>
    haddr_t		  main_addr<span class="hl opt">;</span>    <span class="hl com">/* initial location of the entry</span>
<span class="hl com">                                         */</span>
    haddr_t		  alt_addr<span class="hl opt">;</span>	<span class="hl com">/* location to which the entry</span>
<span class="hl com">					 * can be relocated or &quot;renamed&quot;</span>
<span class="hl com">                                         */</span>
    <span class="hl kwb">size_t</span>		  size<span class="hl opt">;</span>         <span class="hl com">/* how big the cache thinks this</span>
<span class="hl com">                                         * entry is</span>
<span class="hl com">                                         */</span>
    <span class="hl kwb">int32_t</span>		  type<span class="hl opt">;</span>		<span class="hl com">/* indicates which entry array this</span>
<span class="hl com">					 * entry is in</span>
<span class="hl com">                                         */</span>
    <span class="hl kwb">int32_t</span>		  index<span class="hl opt">;</span>	<span class="hl com">/* index in its entry array</span>
<span class="hl com">                                         */</span>
    <span class="hl kwb">int32_t</span>		  reads<span class="hl opt">;</span>	<span class="hl com">/* number of times this entry has</span>
<span class="hl com">					 * been loaded.</span>
<span class="hl com">                                         */</span>
    <span class="hl kwb">int32_t</span>		  writes<span class="hl opt">;</span>	<span class="hl com">/* number of times this entry has</span>
<span class="hl com">                                         * been written</span>
<span class="hl com">                                         */</span>
    hbool_t		  is_dirty<span class="hl opt">;</span>	<span class="hl com">/* entry has been modified since</span>
<span class="hl com">                                         * last write</span>
<span class="hl com">                                         */</span>
    hbool_t		  is_protected<span class="hl opt">;</span>	<span class="hl com">/* entry should currently be on</span>
<span class="hl com">					 * the cache's protected list.</span>
<span class="hl com">                                         */</span>
    hbool_t		  is_read_only<span class="hl opt">;</span> <span class="hl com">/* TRUE iff the entry should be </span>
<span class="hl com">					 * protected read only.</span>
<span class="hl com">					 */</span>
    <span class="hl kwb">int</span>			  ro_ref_count<span class="hl opt">;</span> <span class="hl com">/* Number of outstanding read only</span>
<span class="hl com">					 * protects on the entry.</span>
<span class="hl com">					 */</span>
    hbool_t		  is_pinned<span class="hl opt">;</span>	<span class="hl com">/* entry is currently pinned in</span>
<span class="hl com">					 * the cache.</span>
<span class="hl com">                                         */</span>
    <span class="hl kwb">int</span>			  pinning_ref_count<span class="hl opt">;</span> <span class="hl com">/* Number of entries that</span>
<span class="hl com">					 * pin this entry in the cache.</span>
<span class="hl com">					 * When this count drops to zero,</span>
<span class="hl com">					 * this entry should be unpinned.</span>
<span class="hl com">					 */</span>
    <span class="hl kwb">int</span>			  num_pins<span class="hl opt">;</span>     <span class="hl com">/* Number of entries that this</span>
<span class="hl com">					 * entry pins in the cache.  This</span>
<span class="hl com">					 * value must be in the range</span>
<span class="hl com">					 * [0, MAX_PINS].</span>
<span class="hl com">					 */</span>
    <span class="hl kwb">int</span>			  pin_type<span class="hl opt">[</span>MAX_PINS<span class="hl opt">];</span> <span class="hl com">/* array of the types of entries</span>
<span class="hl com">					 * pinned by this entry.</span>
<span class="hl com">					 */</span>
    <span class="hl kwb">int</span>			  pin_idx<span class="hl opt">[</span>MAX_PINS<span class="hl opt">];</span> <span class="hl com">/* array of the indicies of</span>
<span class="hl com">					 * entries pinned by this entry.</span>
<span class="hl com">					 */</span>
    <span class="hl kwb">int</span>			  num_flush_ops<span class="hl opt">;</span> <span class="hl com">/* integer field containing the</span>
<span class="hl com">					 * number of flush operations to </span>
<span class="hl com">					 * be executed when the entry is </span>
<span class="hl com">					 * flushed.  This value must lie in</span>
<span class="hl com">					 * the closed interval </span>
<span class="hl com">					 * [0, MAX_FLUSH_OPS].</span>
<span class="hl com">					 */</span>
    <span class="hl kwb">struct</span> flush_op	  flush_ops<span class="hl opt">[</span>MAX_FLUSH_OPS<span class="hl opt">];</span> <span class="hl com">/* Array of instances</span>
<span class="hl com">					 * of struct flush_op detailing the </span>
<span class="hl com">					 * flush operations (if any) that</span>
<span class="hl com">					 * are to be executed when the entry</span>
<span class="hl com">					 * is flushed from the cache.</span>
<span class="hl com">					 *</span>
<span class="hl com">					 * num_flush_ops contains the number</span>
<span class="hl com">					 * of valid entries in this array.</span>
<span class="hl com">					 */</span>
    hbool_t		  flush_op_self_resize_in_progress<span class="hl opt">;</span> <span class="hl com">/* Boolean flag </span>
<span class="hl com">					 * that is set to TRUE iff this </span>
<span class="hl com">					 * entry is being flushed, it has</span>
<span class="hl com">					 * been resized by a resize flush</span>
<span class="hl com">					 * op, and the flush function has</span>
<span class="hl com">					 * not yet returned,  This field is</span>
<span class="hl com">					 * used to turn off overactive santity </span>
<span class="hl com">					 * checking code that would otherwise </span>
<span class="hl com">					 * cause a false test failure.</span>
<span class="hl com">					 */</span>
    hbool_t		  loaded<span class="hl opt">;</span>       <span class="hl com">/* entry has been loaded since the</span>
<span class="hl com">                                         * last time it was reset.</span>
<span class="hl com">                                         */</span>
    hbool_t		  cleared<span class="hl opt">;</span>      <span class="hl com">/* entry has been cleared since the</span>
<span class="hl com">                                         * last time it was reset.</span>
<span class="hl com">                                         */</span>
    hbool_t		  flushed<span class="hl opt">;</span>      <span class="hl com">/* entry has been flushed since the</span>
<span class="hl com">                                         * last time it was reset.</span>
<span class="hl com">                                         */</span>
    hbool_t               destroyed<span class="hl opt">;</span>    <span class="hl com">/* entry has been destroyed since the</span>
<span class="hl com">                                         * last time it was reset.</span>
<span class="hl com">                                         */</span>
<span class="hl opt">}</span> test_entry_t<span class="hl opt">;</span>

<span class="hl com">/* The following is a cut down copy of the hash table manipulation</span>
<span class="hl com"> * macros from H5C.c, which have been further modified to avoid references</span>
<span class="hl com"> * to the error reporting macros.  Needless to say, these macros must be</span>
<span class="hl com"> * updated as necessary.</span>
<span class="hl com"> */</span>

<span class="hl ppc">#define H5C__HASH_MASK          ((size_t)(H5C__HASH_TABLE_LEN - 1) &lt;&lt; 3)</span>
<span class="hl ppc">#define H5C__HASH_FCN(x)        (int)(((x) &amp; H5C__HASH_MASK) &gt;&gt; 3)</span>

<span class="hl ppc">#define H5C__PRE_HT_SEARCH_SC(cache_ptr, Addr)          \</span>
<span class="hl ppc">if ( ( (cache_ptr) == NULL ) ||                         \</span>
<span class="hl ppc">     ( (cache_ptr)-&gt;magic != H5C__H5C_T_MAGIC ) ||      \</span>
<span class="hl ppc">     ( ! H5F_addr_defined(Addr) ) ||                    \</span>
<span class="hl ppc">     ( H5C__HASH_FCN(Addr) &lt; 0 ) ||                     \</span>
<span class="hl ppc">     ( H5C__HASH_FCN(Addr) &gt;= H5C__HASH_TABLE_LEN ) ) { \</span>
<span class="hl ppc">    HDfprintf(stdout,</span> <span class="hl pps">&quot;Pre HT search SC failed.</span><span class="hl esc">\n</span><span class="hl pps">&quot;</span><span class="hl ppc">);    \</span>
<span class="hl ppc">}</span>

<span class="hl ppc">#define H5C__POST_SUC_HT_SEARCH_SC(cache_ptr, entry_ptr, Addr, k) \</span>
<span class="hl ppc">if ( ( (cache_ptr) == NULL ) ||                                   \</span>
<span class="hl ppc">     ( (cache_ptr)-&gt;magic != H5C__H5C_T_MAGIC ) ||                \</span>
<span class="hl ppc">     ( (cache_ptr)-&gt;index_len &lt; 1 ) ||                            \</span>
<span class="hl ppc">     ( (entry_ptr) == NULL ) ||                                   \</span>
<span class="hl ppc">     ( (cache_ptr)-&gt;index_size &lt; (entry_ptr)-&gt;size ) ||           \</span>
<span class="hl ppc">     ( H5F_addr_ne((entry_ptr)-&gt;addr, (Addr)) ) ||                \</span>
<span class="hl ppc">     ( (entry_ptr)-&gt;size &lt;= 0 ) ||                                \</span>
<span class="hl ppc">     ( ((cache_ptr)-&gt;index)[k] == NULL ) ||                       \</span>
<span class="hl ppc">     ( ( ((cache_ptr)-&gt;index)[k] != (entry_ptr) ) &amp;&amp;              \</span>
<span class="hl ppc">       ( (entry_ptr)-&gt;ht_prev == NULL ) ) ||                      \</span>
<span class="hl ppc">     ( ( ((cache_ptr)-&gt;index)[k] == (entry_ptr) ) &amp;&amp;              \</span>
<span class="hl ppc">       ( (entry_ptr)-&gt;ht_prev != NULL ) ) ||                      \</span>
<span class="hl ppc">     ( ( (entry_ptr)-&gt;ht_prev != NULL ) &amp;&amp;                        \</span>
<span class="hl ppc">       ( (entry_ptr)-&gt;ht_prev-&gt;ht_next != (entry_ptr) ) ) ||      \</span>
<span class="hl ppc">     ( ( (entry_ptr)-&gt;ht_next != NULL ) &amp;&amp;                        \</span>
<span class="hl ppc">       ( (entry_ptr)-&gt;ht_next-&gt;ht_prev != (entry_ptr) ) ) ) {     \</span>
<span class="hl ppc">    HDfprintf(stdout,</span> <span class="hl pps">&quot;Post successful HT search SC failed.</span><span class="hl esc">\n</span><span class="hl pps">&quot;</span><span class="hl ppc">);  \</span>
<span class="hl ppc">}</span>


<span class="hl ppc">#define H5C__SEARCH_INDEX(cache_ptr, Addr, entry_ptr)                   \</span>
<span class="hl ppc">{                                                                       \</span>
<span class="hl ppc">    int k;                                                              \</span>
<span class="hl ppc">    int depth = 0;                                                      \</span>
<span class="hl ppc">    H5C__PRE_HT_SEARCH_SC(cache_ptr, Addr)                              \</span>
<span class="hl ppc">    k = H5C__HASH_FCN(Addr);                                            \</span>
<span class="hl ppc">    entry_ptr = ((cache_ptr)-&gt;index)[k];                                \</span>
<span class="hl ppc">    while ( ( entry_ptr ) &amp;&amp; ( H5F_addr_ne(Addr, (entry_ptr)-&gt;addr) ) ) \</span>
<span class="hl ppc">    {                                                                   \</span>
<span class="hl ppc">        (entry_ptr) = (entry_ptr)-&gt;ht_next;                             \</span>
<span class="hl ppc">        (depth)++;                                                      \</span>
<span class="hl ppc">    }                                                                   \</span>
<span class="hl ppc">    if ( entry_ptr )                                                    \</span>
<span class="hl ppc">    {                                                                   \</span>
<span class="hl ppc">        H5C__POST_SUC_HT_SEARCH_SC(cache_ptr, entry_ptr, Addr, k)       \</span>
<span class="hl ppc">        if ( entry_ptr != ((cache_ptr)-&gt;index)[k] )                     \</span>
<span class="hl ppc">        {                                                               \</span>
<span class="hl ppc">            if ( (entry_ptr)-&gt;ht_next )                                 \</span>
<span class="hl ppc">            {                                                           \</span>
<span class="hl ppc">                (entry_ptr)-&gt;ht_next-&gt;ht_prev = (entry_ptr)-&gt;ht_prev;   \</span>
<span class="hl ppc">            }                                                           \</span>
<span class="hl ppc">            HDassert( (entry_ptr)-&gt;ht_prev != NULL );                   \</span>
<span class="hl ppc">            (entry_ptr)-&gt;ht_prev-&gt;ht_next = (entry_ptr)-&gt;ht_next;       \</span>
<span class="hl ppc">            ((cache_ptr)-&gt;index)[k]-&gt;ht_prev = (entry_ptr);             \</span>
<span class="hl ppc">            (entry_ptr)-&gt;ht_next = ((cache_ptr)-&gt;index)[k];             \</span>
<span class="hl ppc">            (entry_ptr)-&gt;ht_prev = NULL;                                \</span>
<span class="hl ppc">            ((cache_ptr)-&gt;index)[k] = (entry_ptr);                      \</span>
<span class="hl ppc">        }                                                               \</span>
<span class="hl ppc">    }                                                                   \</span>
<span class="hl ppc">}</span>


<span class="hl com">/* misc type definitions */</span>

<span class="hl kwb">struct</span> flush_cache_test_spec
<span class="hl opt">{</span>
    <span class="hl kwb">int</span>			entry_num<span class="hl opt">;</span>
    <span class="hl kwb">int</span>			entry_type<span class="hl opt">;</span>
    <span class="hl kwb">int</span>			entry_index<span class="hl opt">;</span>
    hbool_t		insert_flag<span class="hl opt">;</span>
    hbool_t		dirty_flag<span class="hl opt">;</span>
    <span class="hl kwb">unsigned int</span>	flags<span class="hl opt">;</span>
    hbool_t		expected_loaded<span class="hl opt">;</span>
    hbool_t		expected_cleared<span class="hl opt">;</span>
    hbool_t		expected_flushed<span class="hl opt">;</span>
    hbool_t		expected_destroyed<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl kwb">struct</span> pe_flush_cache_test_spec
<span class="hl opt">{</span>
    <span class="hl kwb">int</span>			entry_num<span class="hl opt">;</span>
    <span class="hl kwb">int</span>			entry_type<span class="hl opt">;</span>
    <span class="hl kwb">int</span>			entry_index<span class="hl opt">;</span>
    hbool_t		insert_flag<span class="hl opt">;</span>
    hbool_t		dirty_flag<span class="hl opt">;</span>
    <span class="hl kwb">unsigned int</span>	flags<span class="hl opt">;</span>
    <span class="hl kwb">int</span>			num_pins<span class="hl opt">;</span>
    <span class="hl kwb">int</span>			pin_type<span class="hl opt">[</span>MAX_PINS<span class="hl opt">];</span>
    <span class="hl kwb">int</span>			pin_idx<span class="hl opt">[</span>MAX_PINS<span class="hl opt">];</span>
    hbool_t		expected_loaded<span class="hl opt">;</span>
    hbool_t		expected_cleared<span class="hl opt">;</span>
    hbool_t		expected_flushed<span class="hl opt">;</span>
    hbool_t		expected_destroyed<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl kwb">struct</span> fo_flush_entry_check
<span class="hl opt">{</span>
    <span class="hl kwb">int</span>			entry_num<span class="hl opt">;</span>
    <span class="hl kwb">int</span>			entry_type<span class="hl opt">;</span>
    <span class="hl kwb">int</span>			entry_index<span class="hl opt">;</span>
    <span class="hl kwb">size_t</span>		expected_size<span class="hl opt">;</span>
    hbool_t		in_cache<span class="hl opt">;</span>
    hbool_t		at_main_addr<span class="hl opt">;</span>
    hbool_t		is_dirty<span class="hl opt">;</span>
    hbool_t		is_protected<span class="hl opt">;</span>
    hbool_t		is_pinned<span class="hl opt">;</span>
    hbool_t		expected_loaded<span class="hl opt">;</span>
    hbool_t		expected_cleared<span class="hl opt">;</span>
    hbool_t		expected_flushed<span class="hl opt">;</span>
    hbool_t		expected_destroyed<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl kwb">struct</span> fo_flush_cache_test_spec
<span class="hl opt">{</span>
    <span class="hl kwb">int</span>				entry_num<span class="hl opt">;</span>
    <span class="hl kwb">int</span>				entry_type<span class="hl opt">;</span>
    <span class="hl kwb">int</span>				entry_index<span class="hl opt">;</span>
    hbool_t			insert_flag<span class="hl opt">;</span>
    <span class="hl kwb">unsigned int</span>		flags<span class="hl opt">;</span>
    <span class="hl kwb">size_t</span>			new_size<span class="hl opt">;</span>
    <span class="hl kwb">int</span>				num_pins<span class="hl opt">;</span>
    <span class="hl kwb">int</span>				pin_type<span class="hl opt">[</span>MAX_PINS<span class="hl opt">];</span>
    <span class="hl kwb">int</span>				pin_idx<span class="hl opt">[</span>MAX_PINS<span class="hl opt">];</span>
    <span class="hl kwb">int</span>				num_flush_ops<span class="hl opt">;</span>
    <span class="hl kwb">struct</span> flush_op		flush_ops<span class="hl opt">[</span>MAX_FLUSH_OPS<span class="hl opt">];</span>
    hbool_t			expected_loaded<span class="hl opt">;</span>
    hbool_t			expected_cleared<span class="hl opt">;</span>
    hbool_t			expected_flushed<span class="hl opt">;</span>
    hbool_t			expected_destroyed<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl kwb">struct</span> rename_entry_test_spec
<span class="hl opt">{</span>
    <span class="hl kwb">int</span>			entry_type<span class="hl opt">;</span>
    <span class="hl kwb">int</span>			entry_index<span class="hl opt">;</span>
    hbool_t		is_dirty<span class="hl opt">;</span>
    hbool_t		is_pinned<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl kwb">struct</span> expected_entry_status
<span class="hl opt">{</span>
    <span class="hl kwb">int</span>			entry_type<span class="hl opt">;</span>
    <span class="hl kwb">int</span>                 entry_index<span class="hl opt">;</span>
    <span class="hl kwb">size_t</span>              size<span class="hl opt">;</span>
    hbool_t		in_cache<span class="hl opt">;</span>
    hbool_t             at_main_addr<span class="hl opt">;</span>
    hbool_t		is_dirty<span class="hl opt">;</span>
    hbool_t		is_protected<span class="hl opt">;</span>
    hbool_t		is_pinned<span class="hl opt">;</span>
    hbool_t		loaded<span class="hl opt">;</span>
    hbool_t		cleared<span class="hl opt">;</span>
    hbool_t		flushed<span class="hl opt">;</span>
    hbool_t		destroyed<span class="hl opt">;</span>
<span class="hl opt">};</span>




<span class="hl com">/* global variable externs: */</span>

<span class="hl kwc">extern</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>FILENAME<span class="hl opt">[];</span>

<span class="hl kwc">extern</span> hbool_t write_permitted<span class="hl opt">;</span>
<span class="hl kwc">extern</span> hbool_t pass<span class="hl opt">;</span> <span class="hl com">/* set to false on error */</span>
<span class="hl kwc">extern</span> hbool_t skip_long_tests<span class="hl opt">;</span>
<span class="hl kwc">extern</span> hbool_t run_full_test<span class="hl opt">;</span>
<span class="hl kwc">extern</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>failure_mssg<span class="hl opt">;</span>

<span class="hl kwc">extern</span> test_entry_t pico_entries<span class="hl opt">[</span>NUM_PICO_ENTRIES<span class="hl opt">];</span>
<span class="hl kwc">extern</span> test_entry_t nano_entries<span class="hl opt">[</span>NUM_NANO_ENTRIES<span class="hl opt">];</span>
<span class="hl kwc">extern</span> test_entry_t micro_entries<span class="hl opt">[</span>NUM_MICRO_ENTRIES<span class="hl opt">];</span>
<span class="hl kwc">extern</span> test_entry_t tiny_entries<span class="hl opt">[</span>NUM_TINY_ENTRIES<span class="hl opt">];</span>
<span class="hl kwc">extern</span> test_entry_t small_entries<span class="hl opt">[</span>NUM_SMALL_ENTRIES<span class="hl opt">];</span>
<span class="hl kwc">extern</span> test_entry_t medium_entries<span class="hl opt">[</span>NUM_MEDIUM_ENTRIES<span class="hl opt">];</span>
<span class="hl kwc">extern</span> test_entry_t large_entries<span class="hl opt">[</span>NUM_LARGE_ENTRIES<span class="hl opt">];</span>
<span class="hl kwc">extern</span> test_entry_t huge_entries<span class="hl opt">[</span>NUM_HUGE_ENTRIES<span class="hl opt">];</span>
<span class="hl kwc">extern</span> test_entry_t monster_entries<span class="hl opt">[</span>NUM_MONSTER_ENTRIES<span class="hl opt">];</span>

<span class="hl kwc">extern</span> test_entry_t <span class="hl opt">*</span> entries<span class="hl opt">[</span>NUMBER_OF_ENTRY_TYPES<span class="hl opt">];</span>
<span class="hl kwc">extern</span> <span class="hl kwb">const int32_t</span> max_indices<span class="hl opt">[</span>NUMBER_OF_ENTRY_TYPES<span class="hl opt">];</span>
<span class="hl kwc">extern</span> <span class="hl kwb">const size_t</span> entry_sizes<span class="hl opt">[</span>NUMBER_OF_ENTRY_TYPES<span class="hl opt">];</span>
<span class="hl kwc">extern</span> <span class="hl kwb">const</span> haddr_t base_addrs<span class="hl opt">[</span>NUMBER_OF_ENTRY_TYPES<span class="hl opt">];</span>
<span class="hl kwc">extern</span> <span class="hl kwb">const</span> haddr_t alt_base_addrs<span class="hl opt">[</span>NUMBER_OF_ENTRY_TYPES<span class="hl opt">];</span>
<span class="hl kwc">extern</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span> entry_type_names<span class="hl opt">[</span>NUMBER_OF_ENTRY_TYPES<span class="hl opt">];</span>


<span class="hl com">/* call back function declarations: */</span>

herr_t <span class="hl kwd">check_write_permitted</span><span class="hl opt">(</span><span class="hl kwb">const</span> H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span>
                             hid_t dxpl_id<span class="hl opt">,</span>
                             hbool_t <span class="hl opt">*</span> write_permitted_ptr<span class="hl opt">);</span>

herr_t <span class="hl kwd">pico_clear</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>  thing<span class="hl opt">,</span> hbool_t dest<span class="hl opt">);</span>
herr_t <span class="hl kwd">nano_clear</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>  thing<span class="hl opt">,</span> hbool_t dest<span class="hl opt">);</span>
herr_t <span class="hl kwd">micro_clear</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>  thing<span class="hl opt">,</span> hbool_t dest<span class="hl opt">);</span>
herr_t <span class="hl kwd">tiny_clear</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>  thing<span class="hl opt">,</span> hbool_t dest<span class="hl opt">);</span>
herr_t <span class="hl kwd">small_clear</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>  thing<span class="hl opt">,</span> hbool_t dest<span class="hl opt">);</span>
herr_t <span class="hl kwd">medium_clear</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>  thing<span class="hl opt">,</span> hbool_t dest<span class="hl opt">);</span>
herr_t <span class="hl kwd">large_clear</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>  thing<span class="hl opt">,</span> hbool_t dest<span class="hl opt">);</span>
herr_t <span class="hl kwd">huge_clear</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>  thing<span class="hl opt">,</span> hbool_t dest<span class="hl opt">);</span>
herr_t <span class="hl kwd">monster_clear</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>  thing<span class="hl opt">,</span> hbool_t dest<span class="hl opt">);</span>
herr_t <span class="hl kwd">variable_clear</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>  thing<span class="hl opt">,</span> hbool_t dest<span class="hl opt">);</span>


herr_t <span class="hl kwd">pico_dest</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">);</span>
herr_t <span class="hl kwd">nano_dest</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">);</span>
herr_t <span class="hl kwd">micro_dest</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">);</span>
herr_t <span class="hl kwd">tiny_dest</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">);</span>
herr_t <span class="hl kwd">small_dest</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">);</span>
herr_t <span class="hl kwd">medium_dest</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">);</span>
herr_t <span class="hl kwd">large_dest</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">);</span>
herr_t <span class="hl kwd">huge_dest</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>  thing<span class="hl opt">);</span>
herr_t <span class="hl kwd">monster_dest</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>  thing<span class="hl opt">);</span>
herr_t <span class="hl kwd">variable_dest</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>  thing<span class="hl opt">);</span>


herr_t <span class="hl kwd">pico_flush</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> hbool_t dest<span class="hl opt">,</span>
                  haddr_t addr<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>thing<span class="hl opt">,</span> <span class="hl kwb">unsigned</span> <span class="hl opt">*</span> flags_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">nano_flush</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> hbool_t dest<span class="hl opt">,</span>
                  haddr_t addr<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>thing<span class="hl opt">,</span> <span class="hl kwb">unsigned</span> <span class="hl opt">*</span> flags_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">micro_flush</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> hbool_t dest<span class="hl opt">,</span>
                   haddr_t addr<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>thing<span class="hl opt">,</span> <span class="hl kwb">unsigned</span> <span class="hl opt">*</span> flags_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">tiny_flush</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> hbool_t dest<span class="hl opt">,</span>
                  haddr_t addr<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>thing<span class="hl opt">,</span> <span class="hl kwb">unsigned</span> <span class="hl opt">*</span> flags_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">small_flush</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> hbool_t dest<span class="hl opt">,</span>
                   haddr_t addr<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>thing<span class="hl opt">,</span> <span class="hl kwb">unsigned</span> <span class="hl opt">*</span> flags_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">medium_flush</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> hbool_t dest<span class="hl opt">,</span>
                    haddr_t addr<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>thing<span class="hl opt">,</span> <span class="hl kwb">unsigned</span> <span class="hl opt">*</span> flags_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">large_flush</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> hbool_t dest<span class="hl opt">,</span>
                   haddr_t addr<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>thing<span class="hl opt">,</span> <span class="hl kwb">unsigned</span> <span class="hl opt">*</span> flags_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">huge_flush</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> hbool_t dest<span class="hl opt">,</span>
                  haddr_t addr<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>thing<span class="hl opt">,</span> <span class="hl kwb">unsigned</span> <span class="hl opt">*</span> flags_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">monster_flush</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> hbool_t dest<span class="hl opt">,</span>
                     haddr_t addr<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>thing<span class="hl opt">,</span> <span class="hl kwb">unsigned</span> <span class="hl opt">*</span> flags_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">variable_flush</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> hbool_t dest<span class="hl opt">,</span>
                      haddr_t addr<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>thing<span class="hl opt">,</span> <span class="hl kwb">unsigned</span> <span class="hl opt">*</span> flags_ptr<span class="hl opt">);</span>


<span class="hl kwb">void</span> <span class="hl opt">*</span> <span class="hl kwd">pico_load</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> haddr_t addr<span class="hl opt">,</span>
                 <span class="hl kwb">const void</span> <span class="hl opt">*</span>udata1<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>udata2<span class="hl opt">);</span>
<span class="hl kwb">void</span> <span class="hl opt">*</span> <span class="hl kwd">nano_load</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> haddr_t addr<span class="hl opt">,</span>
                 <span class="hl kwb">const void</span> <span class="hl opt">*</span>udata1<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>udata2<span class="hl opt">);</span>
<span class="hl kwb">void</span> <span class="hl opt">*</span> <span class="hl kwd">micro_load</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> haddr_t addr<span class="hl opt">,</span>
                  <span class="hl kwb">const void</span> <span class="hl opt">*</span>udata1<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>udata2<span class="hl opt">);</span>
<span class="hl kwb">void</span> <span class="hl opt">*</span> <span class="hl kwd">tiny_load</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> haddr_t addr<span class="hl opt">,</span>
                 <span class="hl kwb">const void</span> <span class="hl opt">*</span>udata1<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>udata2<span class="hl opt">);</span>
<span class="hl kwb">void</span> <span class="hl opt">*</span> <span class="hl kwd">small_load</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> haddr_t addr<span class="hl opt">,</span>
                  <span class="hl kwb">const void</span> <span class="hl opt">*</span>udata1<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>udata2<span class="hl opt">);</span>
<span class="hl kwb">void</span> <span class="hl opt">*</span> <span class="hl kwd">medium_load</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> haddr_t addr<span class="hl opt">,</span>
                   <span class="hl kwb">const void</span> <span class="hl opt">*</span>udata1<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>udata2<span class="hl opt">);</span>
<span class="hl kwb">void</span> <span class="hl opt">*</span> <span class="hl kwd">large_load</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> haddr_t addr<span class="hl opt">,</span>
                  <span class="hl kwb">const void</span> <span class="hl opt">*</span>udata1<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>udata2<span class="hl opt">);</span>
<span class="hl kwb">void</span> <span class="hl opt">*</span> <span class="hl kwd">huge_load</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> haddr_t addr<span class="hl opt">,</span>
                 <span class="hl kwb">const void</span> <span class="hl opt">*</span>udata1<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>udata2<span class="hl opt">);</span>
<span class="hl kwb">void</span> <span class="hl opt">*</span> <span class="hl kwd">monster_load</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> haddr_t addr<span class="hl opt">,</span>
                    <span class="hl kwb">const void</span> <span class="hl opt">*</span>udata1<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>udata2<span class="hl opt">);</span>
<span class="hl kwb">void</span> <span class="hl opt">*</span> <span class="hl kwd">variable_load</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> haddr_t addr<span class="hl opt">,</span>
                     <span class="hl kwb">const void</span> <span class="hl opt">*</span>udata1<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>udata2<span class="hl opt">);</span>


herr_t <span class="hl kwd">pico_size</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span> size_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">nano_size</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span> size_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">micro_size</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span> size_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">tiny_size</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span> size_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">small_size</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span> size_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">medium_size</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span> size_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">large_size</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span> size_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">huge_size</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span> size_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">monster_size</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span> size_ptr<span class="hl opt">);</span>
herr_t <span class="hl kwd">variable_size</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span> f<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span> thing<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span> size_ptr<span class="hl opt">);</span>

<span class="hl com">/* callback table extern */</span>

<span class="hl kwc">extern</span> <span class="hl kwb">const</span> H5C_class_t types<span class="hl opt">[</span>NUMBER_OF_ENTRY_TYPES<span class="hl opt">];</span>


<span class="hl com">/* function declarations: */</span>

<span class="hl kwb">void</span> <span class="hl kwd">add_flush_op</span><span class="hl opt">(</span><span class="hl kwb">int</span> target_type<span class="hl opt">,</span>
                  <span class="hl kwb">int</span> target_idx<span class="hl opt">,</span>
                  <span class="hl kwb">int</span> op_code<span class="hl opt">,</span>
                  <span class="hl kwb">int</span> type<span class="hl opt">,</span>
                  <span class="hl kwb">int</span> idx<span class="hl opt">,</span>
                  hbool_t flag<span class="hl opt">,</span>
                  <span class="hl kwb">size_t</span> size<span class="hl opt">);</span>


<span class="hl kwb">void</span> <span class="hl kwd">addr_to_type_and_index</span><span class="hl opt">(</span>haddr_t addr<span class="hl opt">,</span>
                            <span class="hl kwb">int32_t</span> <span class="hl opt">*</span> type_ptr<span class="hl opt">,</span>
                            <span class="hl kwb">int32_t</span> <span class="hl opt">*</span> index_ptr<span class="hl opt">);</span>

<span class="hl ppc">#if 0</span> <span class="hl com">/* keep this for a while -- it may be useful */</span><span class="hl ppc"></span>
haddr_t <span class="hl kwd">type_and_index_to_addr</span><span class="hl opt">(</span><span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
                               <span class="hl kwb">int32_t</span> idx<span class="hl opt">);</span>
<span class="hl ppc">#endif</span>

<span class="hl kwb">void</span> <span class="hl kwd">dirty_entry</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                 <span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
                 <span class="hl kwb">int32_t</span> idx<span class="hl opt">,</span>
                 hbool_t dirty_pin<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">expunge_entry</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                   <span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
                   <span class="hl kwb">int32_t</span> idx<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">insert_entry</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                  <span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
                  <span class="hl kwb">int32_t</span> idx<span class="hl opt">,</span>
                  hbool_t dirty<span class="hl opt">,</span>
                  <span class="hl kwb">unsigned int</span> flags<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">mark_pinned_entry_dirty</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
	                     <span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
		             <span class="hl kwb">int32_t</span> idx<span class="hl opt">,</span>
		             hbool_t size_changed<span class="hl opt">,</span>
		             <span class="hl kwb">size_t</span>  new_size<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">mark_pinned_or_protected_entry_dirty</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                                          <span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
                                          <span class="hl kwb">int32_t</span> idx<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">rename_entry</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                  <span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
                  <span class="hl kwb">int32_t</span> idx<span class="hl opt">,</span>
                  hbool_t main_addr<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">protect_entry</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                   <span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
                   <span class="hl kwb">int32_t</span> idx<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">protect_entry_ro</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                      <span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
                      <span class="hl kwb">int32_t</span> idx<span class="hl opt">);</span>

hbool_t <span class="hl kwd">entry_in_cache</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                       <span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
                       <span class="hl kwb">int32_t</span> idx<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">create_pinned_entry_dependency</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
		                    <span class="hl kwb">int</span> pinning_type<span class="hl opt">,</span>
		                    <span class="hl kwb">int</span> pinning_idx<span class="hl opt">,</span>
		                    <span class="hl kwb">int</span> pinned_type<span class="hl opt">,</span>
		                    <span class="hl kwb">int</span> pinned_idx<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">execute_flush_op</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
		      <span class="hl kwb">struct</span> test_entry_t <span class="hl opt">*</span> entry_ptr<span class="hl opt">,</span>
                      <span class="hl kwb">struct</span> flush_op <span class="hl opt">*</span> op_ptr<span class="hl opt">,</span>
		      <span class="hl kwb">unsigned</span> <span class="hl opt">*</span> flags_ptr<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">reset_entries</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">resize_entry</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                   <span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
                   <span class="hl kwb">int32_t</span> idx<span class="hl opt">,</span>
                   <span class="hl kwb">size_t</span> new_size<span class="hl opt">,</span>
                   hbool_t resize_pin<span class="hl opt">);</span>

H5C_t <span class="hl opt">*</span> <span class="hl kwd">setup_cache</span><span class="hl opt">(</span><span class="hl kwb">size_t</span> max_cache_size<span class="hl opt">,</span> <span class="hl kwb">size_t</span> min_clean_size<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">row_major_scan_forward</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                            <span class="hl kwb">int32_t</span> lag<span class="hl opt">,</span>
                            hbool_t verbose<span class="hl opt">,</span>
                            hbool_t reset_stats<span class="hl opt">,</span>
                            hbool_t display_stats<span class="hl opt">,</span>
                            hbool_t display_detailed_stats<span class="hl opt">,</span>
                            hbool_t do_inserts<span class="hl opt">,</span>
                            hbool_t dirty_inserts<span class="hl opt">,</span>
                            hbool_t do_renames<span class="hl opt">,</span>
                            hbool_t rename_to_main_addr<span class="hl opt">,</span>
                            hbool_t do_destroys<span class="hl opt">,</span>
                            hbool_t do_mult_ro_protects<span class="hl opt">,</span>
                            <span class="hl kwb">int</span> dirty_destroys<span class="hl opt">,</span>
                            <span class="hl kwb">int</span> dirty_unprotects<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">hl_row_major_scan_forward</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                               <span class="hl kwb">int32_t</span> max_index<span class="hl opt">,</span>
                               hbool_t verbose<span class="hl opt">,</span>
                               hbool_t reset_stats<span class="hl opt">,</span>
                               hbool_t display_stats<span class="hl opt">,</span>
                               hbool_t display_detailed_stats<span class="hl opt">,</span>
                               hbool_t do_inserts<span class="hl opt">,</span>
                               hbool_t dirty_inserts<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">row_major_scan_backward</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                             <span class="hl kwb">int32_t</span> lag<span class="hl opt">,</span>
                             hbool_t verbose<span class="hl opt">,</span>
                             hbool_t reset_stats<span class="hl opt">,</span>
                             hbool_t display_stats<span class="hl opt">,</span>
                             hbool_t display_detailed_stats<span class="hl opt">,</span>
                             hbool_t do_inserts<span class="hl opt">,</span>
                             hbool_t dirty_inserts<span class="hl opt">,</span>
                             hbool_t do_renames<span class="hl opt">,</span>
                             hbool_t rename_to_main_addr<span class="hl opt">,</span>
                             hbool_t do_destroys<span class="hl opt">,</span>
                             hbool_t do_mult_ro_protects<span class="hl opt">,</span>
                             <span class="hl kwb">int</span> dirty_destroys<span class="hl opt">,</span>
                             <span class="hl kwb">int</span> dirty_unprotects<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">hl_row_major_scan_backward</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                                <span class="hl kwb">int32_t</span> max_index<span class="hl opt">,</span>
                                hbool_t verbose<span class="hl opt">,</span>
                                hbool_t reset_stats<span class="hl opt">,</span>
                                hbool_t display_stats<span class="hl opt">,</span>
                                hbool_t display_detailed_stats<span class="hl opt">,</span>
                                hbool_t do_inserts<span class="hl opt">,</span>
                                hbool_t dirty_inserts<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">col_major_scan_forward</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                            <span class="hl kwb">int32_t</span> lag<span class="hl opt">,</span>
                            hbool_t verbose<span class="hl opt">,</span>
                            hbool_t reset_stats<span class="hl opt">,</span>
                            hbool_t display_stats<span class="hl opt">,</span>
                            hbool_t display_detailed_stats<span class="hl opt">,</span>
                            hbool_t do_inserts<span class="hl opt">,</span>
                            hbool_t dirty_inserts<span class="hl opt">,</span>
                            <span class="hl kwb">int</span> dirty_unprotects<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">hl_col_major_scan_forward</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                               <span class="hl kwb">int32_t</span> max_index<span class="hl opt">,</span>
                               hbool_t verbose<span class="hl opt">,</span>
                               hbool_t reset_stats<span class="hl opt">,</span>
                               hbool_t display_stats<span class="hl opt">,</span>
                               hbool_t display_detailed_stats<span class="hl opt">,</span>
                               hbool_t do_inserts<span class="hl opt">,</span>
                               hbool_t dirty_inserts<span class="hl opt">,</span>
                               <span class="hl kwb">int</span> dirty_unprotects<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">col_major_scan_backward</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                             <span class="hl kwb">int32_t</span> lag<span class="hl opt">,</span>
                             hbool_t verbose<span class="hl opt">,</span>
                             hbool_t reset_stats<span class="hl opt">,</span>
                             hbool_t display_stats<span class="hl opt">,</span>
                             hbool_t display_detailed_stats<span class="hl opt">,</span>
                             hbool_t do_inserts<span class="hl opt">,</span>
                             hbool_t dirty_inserts<span class="hl opt">,</span>
                             <span class="hl kwb">int</span> dirty_unprotects<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">hl_col_major_scan_backward</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                                <span class="hl kwb">int32_t</span> max_index<span class="hl opt">,</span>
                                hbool_t verbose<span class="hl opt">,</span>
                                hbool_t reset_stats<span class="hl opt">,</span>
                                hbool_t display_stats<span class="hl opt">,</span>
                                hbool_t display_detailed_stats<span class="hl opt">,</span>
                                hbool_t do_inserts<span class="hl opt">,</span>
                                hbool_t dirty_inserts<span class="hl opt">,</span>
                                <span class="hl kwb">int</span> dirty_unprotects<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">takedown_cache</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                    hbool_t dump_stats<span class="hl opt">,</span>
                    hbool_t dump_detailed_stats<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">flush_cache</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                 hbool_t destroy_entries<span class="hl opt">,</span>
                 hbool_t dump_stats<span class="hl opt">,</span>
                 hbool_t dump_detailed_stats<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">unpin_entry</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                 <span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
                 <span class="hl kwb">int32_t</span> idx<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">unprotect_entry</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                     <span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
                     <span class="hl kwb">int32_t</span> idx<span class="hl opt">,</span>
                     <span class="hl kwb">int</span> dirty<span class="hl opt">,</span>
                     <span class="hl kwb">unsigned int</span> flags<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">unprotect_entry_with_size_change</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
                                      <span class="hl kwb">int32_t</span> type<span class="hl opt">,</span>
                                      <span class="hl kwb">int32_t</span> idx<span class="hl opt">,</span>
                                      <span class="hl kwb">unsigned int</span> flags<span class="hl opt">,</span>
                                      <span class="hl kwb">size_t</span> new_size<span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">verify_clean</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">);</span>

<span class="hl kwb">void</span> <span class="hl kwd">verify_entry_status</span><span class="hl opt">(</span>H5C_t <span class="hl opt">*</span> cache_ptr<span class="hl opt">,</span>
		         <span class="hl kwb">int</span> tag<span class="hl opt">,</span>
                         <span class="hl kwb">int</span> num_entries<span class="hl opt">,</span>
                         <span class="hl kwb">struct</span> expected_entry_status expected<span class="hl opt">[]);</span>

<span class="hl kwb">void</span> <span class="hl kwd">verify_unprotected</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">);</span>

</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='http://git.zx2c4.com/cgit/about/'>cgit v0.12</a> at 2024-09-19 20:13:27 (GMT)</div>
</div> <!-- id=cgit -->
</body>
</html>