ExpCache.C

Go to the documentation of this file.

// Copyright (C) 2001, Compaq Computer Corporation
// 
// This file is part of Vesta.
// 
// Vesta is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// Vesta is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with Vesta; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

// Last modified on Fri Apr 29 19:31:19 EDT 2005 by ken@xorian.net
//      modified on Thu Feb 10 11:29:27 PST 2000 by heydon

// vesta/basics
#include <Basics.H>

#include <sstream>

// vesta/srpc
#include <SRPC.H>
#include <LimService.H>

// vesta/fp
#include <FP.H>

// vesta/cache-common
#include <PKPrefix.H>
#include <BitVector.H>
#include <CacheConfig.H>
#include <CacheIntf.H>
#include <Debug.H>
#include <CacheState.H>
#include <Model.H>
#include <CacheIndex.H>
#include <FV.H>
#include <VestaVal.H>

// local includes
#include "CacheS.H"
#include "ExpCache.H"

using std::ostringstream;
using std::cout;
using std::cerr;
using std::endl;

void ExpCache_NewCall(SRPC *srpc, int procId, void *arg) throw (SRPC::failure)
/* This is the callback procedure passed to the LimService constructor. */
{
    ExpCache *csExp = ((ExpCache::CallArg *)arg)->expCache;

    switch (procId) {
      // evaluator client procs
      case CacheIntf::AddEntryProc:      csExp->AddEntry(srpc);         break;
      case CacheIntf::FreeVarsProc:      csExp->FreeVars(srpc);         break;
      case CacheIntf::LookupProc:        csExp->Lookup(srpc);           break;
      case CacheIntf::CheckpointProc:    csExp->Checkpoint(srpc);       break;
      case CacheIntf::RenewLeasesProc:   csExp->RenewLeases(srpc);      break;
      case CacheIntf::GetCacheInstanceProc:
                                         csExp->GetCacheInstance(srpc); break;

      // weeder client procs
      case CacheIntf::WeedRecoverProc:   csExp->WeederRecovering(srpc); break;
      case CacheIntf::StartMarkProc:     csExp->StartMark(srpc);        break;
      case CacheIntf::SetHitFilterProc:  csExp->SetHitFilter(srpc);     break;
      case CacheIntf::GetLeasesProc:     csExp->GetLeases(srpc);        break;
      case CacheIntf::ResumeLeasesProc:  csExp->ResumeLeaseExp(srpc);   break;
      case CacheIntf::EndMarkProc:       csExp->EndMark(srpc);          break;
      case CacheIntf::CommitChkptProc:   csExp->CommitChkpt(srpc);      break;

      // debugging client procs
      case CacheIntf::FlushAllProc:      csExp->FlushAll(srpc);         break;
      case CacheIntf::GetCacheIdProc:    csExp->GetCacheId(srpc);       break;
      case CacheIntf::GetCacheStateProc: csExp->GetCacheState(srpc);    break;

      // programmer error
      default:
        cerr << "Fatal ExpCache error: ";
        cerr << "Unknown method code " << procId << endl;
        assert(false);
    }
}

ExpCache::ExpCache(CacheS *cs, int maxRunning, int maxBlocked,
  LimService_FailureCallback failureCallback, const Text& hostName)
  throw ()
: debug(cs->DebugLevel())
{
  // initialize call argument
  CallArg *arg = NEW_CONSTR(ExpCache::CallArg, (this, cs));

  // initialize ExpCache
  this->cs = cs;
  this->ls = NEW_CONSTR(LimService,
                        (Config_Port, this->cs->Version(),
                         maxRunning, maxBlocked,
                         ExpCache_NewCall, failureCallback,
                         (void *)arg, /*stacksize=*/ -1, hostName));
}

void ExpCache::Run() throw (SRPC::failure)
{
    this->ls->Run();
}

bool ExpCache::check_server_instance(SRPC *srpc,
                                     const FP::Tag &server_instance,
                                     const char *func_name)
     const
     throw(SRPC::failure)
{
  // If we are not the cache server they are expecting...
  if(server_instance != cs->GetCacheInstance())
    {
      // Indicate to the client that we aren't and end the call.
      srpc->send_int(0);
      srpc->send_end();

      // Log this for debugging
      if (this->debug >= CacheIntf::OtherOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- " << func_name << endl;
        cout << "  server instance mismatch, call aborted" << endl
             << "  client = " << server_instance << endl
             << "  server = " << cs->GetCacheInstance() << endl;
        cout << endl;
        Debug::Unlock();
      }

      // Tell the caller that they should just return, as we've
      // already terminated the call.
      return false;
    }

  // Tell the caller to proceed as normal.
  return true;
}

void ExpCache::FreeVars(SRPC *srpc) throw (SRPC::failure)
{
    // Get the server instance fingerprint.
    FP::Tag server_instance(*srpc);

    // get arguments
    FP::Tag pk(*srpc);
    srpc->recv_end();

    // If we have a server instance mismatch...
    if(!check_server_instance(srpc, server_instance, "FreeVariables"))
      {
        // Don't do anything else.
        return;
      }

    // pre debugging
    if (this->debug >= CacheIntf::OtherOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- FreeVariables" << endl;
        cout << "  pk = " << pk << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    VPKFile *vf;
    cs->FreeVariables(pk, /*OUT*/ vf);

    // Indicate that this is the correct server instance
    srpc->send_int(1);

    try
      {
        // send results
        vf->SendAllNames(srpc, (bool)(this->debug >= CacheIntf::OtherOps));
        srpc->send_end();
      }
    // VPKFile::SendAllNames converts the FreeVariables to a CompactFV
    // which uses a PrefixTbl.  This can throw PrefixTbl::Overflow
    // indicating that we've exceeded the internal limits of the
    // PrefixTbl class (by trying to add the 2^16th entry).  If that
    // happens we convert it to an SRPC failure.
    catch (PrefixTbl::Overflow)
      {
        ostringstream l_msg;
        l_msg << "PrefixTbl overflow in sending result of FreeVariables"
              << endl
              << "  pk = " << pk << endl
              << "(This means you've exceeded internal limits of the" << endl
              << "cache server, and you may have to erase your cache.)";
        srpc->send_failure(SRPC::internal_trouble, Text(l_msg.str()));
      }
}

void ExpCache::Lookup(SRPC *srpc) throw (SRPC::failure)
{
    // Get the server instance fingerprint.
    FP::Tag server_instance(*srpc);

    // get arguments
    FP::Tag pk(*srpc);
    FV::Epoch id = srpc->recv_int();
    FP::List fps(*srpc);
    srpc->recv_end();

    // If we have a server instance mismatch...
    if(!check_server_instance(srpc, server_instance, "Lookup"))
      {
        // Don't do anything else.
        return;
      }

    // pre debugging
    if (this->debug >= CacheIntf::OtherOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- Lookup" << endl;
        cout << "  pk = " << pk << endl;
        cout << "  epoch = " << id << endl;
        cout << "  fps =" << endl; fps.Print(cout, /*indent=*/ 4);
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    CacheEntry::Index ci = 0;
    const VestaVal::T *value = (VestaVal::T *)NULL;
    CacheIntf::LookupRes res =
      cs->Lookup(pk, id, fps, /*OUT*/ ci, /*OUT*/ value);

    // post debugging
    if (this->debug >= CacheIntf::OtherOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- Lookup" << endl;
        cout << "  result = " << CacheIntf::LookupResName(res) << endl;
        if (res == CacheIntf::Hit) {
            cout << "  index = " << ci << endl;
            cout << "  value =" << endl; value->Print(cout, /*indent=*/ 4);
        }
        cout << endl;
        Debug::Unlock();
    }

    // Indicate that this is the correct server instance
    srpc->send_int(1);

    // send results
    srpc->send_int((int)res);
    if (res == CacheIntf::Hit) {
        srpc->send_int(ci);
        value->Send(*srpc);
    }
    srpc->send_end();
}

void ExpCache::AddEntry(SRPC *srpc) throw (SRPC::failure)
{
    // Get the server instance fingerprint.
    FP::Tag server_instance(*srpc);

    // get arguments
    FP::Tag* pk = NEW_PTRFREE_CONSTR(FP::Tag, (*srpc));
    FV::List *names = NEW_CONSTR(FV::List, (*srpc));
    FP::List *fps = NEW_CONSTR(FP::List, (*srpc));
    VestaVal::T *value = NEW_CONSTR(VestaVal::T, (*srpc));
    Model::T model = Model::Recv(*srpc);
    CacheEntry::Indices *kids = NEW_CONSTR(CacheEntry::Indices, (*srpc));
    Text sourceFunc;
    srpc->recv_Text(/*OUT*/ sourceFunc);
    srpc->recv_end();

    // If we have a server instance mismatch...
    if(!check_server_instance(srpc, server_instance, "AddEntry"))
      {
        // Don't do anything else.
        return;
      }

    // pre debugging
    if (this->debug >= CacheIntf::AddEntryOp) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- AddEntry" << endl;
        cout << "  pk = " << *pk << endl;
        cout << "  names =" << endl; names->Print(cout, /*indent=*/ 4);
        cout << "  fps =" << endl; fps->Print(cout, /*indent=*/ 4);
        cout << "  value =" << endl; value->Print(cout, /*indent=*/ 4);
        cout << "  model = " << model << endl;
        cout << "  kids = " << *kids << endl;
        cout << "  sourceFunc = " << sourceFunc << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    CacheEntry::Index ci;
    CacheIntf::AddEntryRes res = cs->AddEntry(pk, names, fps,
      value, model, kids, sourceFunc, /*OUT*/ ci);

    // post debugging
    if (this->debug >= CacheIntf::AddEntryOp) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- AddEntry" << endl;
        cout << "  result = " << CacheIntf::AddEntryResName(res) << endl;
        if (res == CacheIntf::EntryAdded) {
            cout << "  ci = " << ci << endl;
        }
        cout << endl;
        Debug::Unlock();
    }

    // Indicate that this is the correct server instance
    srpc->send_int(1);

    // send results
    srpc->send_int(ci);
    srpc->send_int((int)res);
    srpc->send_end();
}

void ExpCache::Checkpoint(SRPC *srpc) throw (SRPC::failure)
{
    // Get the server instance fingerprint.
    FP::Tag server_instance(*srpc);

    // get arguments
    FP::Tag pkgVersion(*srpc);
    Model::T model = Model::Recv(*srpc);
    CacheEntry::Indices *cis = NEW_CONSTR(CacheEntry::Indices,(*srpc));
    bool done = (bool)srpc->recv_int();
    srpc->recv_end();

    // If we have a server instance mismatch...
    if(!check_server_instance(srpc, server_instance, "Checkpoint"))
      {
        // Don't do anything else.
        return;
      }

    // pre debugging
    if (this->debug >= CacheIntf::LogFlush) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- Checkpoint" << endl;
        cout << "  pkgVersion = " << pkgVersion << endl;
        cout << "  model = " << model << endl;
        cout << "  cis   = "; cis->Print(cout, /*indent=*/ 4);
        cout << "  done  = " << BoolName[done] << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    cs->Checkpoint(pkgVersion, model, cis, done);

    // post debugging
    if (this->debug >= CacheIntf::LogFlush) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- Checkpoint" << endl;
        cout << endl;
        Debug::Unlock();
    }

    // Indicate that this is the correct server instance
    srpc->send_int(1);

    // send results
    srpc->send_end();
}

void ExpCache::RenewLeases(SRPC *srpc) throw (SRPC::failure)
{
    // Get the server instance fingerprint.
    FP::Tag server_instance(*srpc);

    // get arguments
    CacheEntry::Indices *cis = NEW_CONSTR(CacheEntry::Indices, (*srpc));
    srpc->recv_end();

    // If we have a server instance mismatch...
    if(!check_server_instance(srpc, server_instance, "RenewLeases"))
      {
        // Don't do anything else.
        return;
      }

    // pre debugging
    if (this->debug >= CacheIntf::LeaseExp) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- RenewLeases" << endl;
        cout << "  cis = " << *cis << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    bool res = cs->RenewLeases(cis);

    // post debugging
    if (this->debug >= CacheIntf::LeaseExp) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- RenewLeases" << endl;
        cout << "  result = " << BoolName[res] << endl;
        cout << endl;
        Debug::Unlock();
    }

    // Indicate that this is the correct server instance
    srpc->send_int(1);

    // send results
    srpc->send_int((int)res);
    srpc->send_end();
}

void ExpCache::WeederRecovering(SRPC *srpc) throw (SRPC::failure)
{
    // Get the server instance fingerprint.
    FP::Tag server_instance(*srpc);

    // get arguments
    bool doneMarking = srpc->recv_int();
    srpc->recv_end();

    // If we have a server instance mismatch...
    if(!check_server_instance(srpc, server_instance, "WeederRecovering"))
      {
        // Don't do anything else.
        return;
      }

    // pre debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- WeederRecovering" << endl;
        cout << "  doneMarking = " << BoolName[doneMarking] << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    bool err = cs->WeederRecovering(srpc, doneMarking);

    // post debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- WeederRecovering" << endl;
        cout << "  err = " << BoolName[err] << endl;
        cout << endl;
        Debug::Unlock();
    }

    // Indicate that this is the correct server instance
    srpc->send_int(1);

    // send results
    srpc->send_int((int)err);
    srpc->send_end();
}

void ExpCache::StartMark(SRPC *srpc) throw (SRPC::failure)
{
    // Get the server instance fingerprint.
    FP::Tag server_instance(*srpc);

    // get arguments
    srpc->recv_end();

    // If we have a server instance mismatch...
    if(!check_server_instance(srpc, server_instance, "StartMark"))
      {
        // Don't do anything else.
        return;
      }

    // pre debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- StartMark" << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    int newLogVer;
    BitVector *res = cs->StartMark(/*OUT*/ newLogVer);

    // post debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- StartMark" << endl;
        cout << "  initCIs = " << *res << endl;
        cout << "  newLogVer = " << newLogVer << endl;
        cout << endl;
        Debug::Unlock();
    }

    // Indicate that this is the correct server instance
    srpc->send_int(1);

    // send results
    res->Send(*srpc);
    srpc->send_int(newLogVer);
    srpc->send_end();
}

void ExpCache::SetHitFilter(SRPC *srpc) throw (SRPC::failure)
{
    // Get the server instance fingerprint.
    FP::Tag server_instance(*srpc);

    // get arguments
    BitVector cis(*srpc);
    srpc->recv_end();

    // If we have a server instance mismatch...
    if(!check_server_instance(srpc, server_instance, "SetHitFilter"))
      {
        // Don't do anything else.
        return;
      }

    // pre debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- SetHitFilter" << endl;
        cout << "  cis = " << cis << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    cs->SetHitFilter(cis);

    // post debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- SetHitFilter" << endl;
        cout << endl;
        Debug::Unlock();
    }

    // Indicate that this is the correct server instance
    srpc->send_int(1);

    // send results
    srpc->send_end();
}

void ExpCache::GetLeases(SRPC *srpc) throw (SRPC::failure)
{
    // Get the server instance fingerprint.
    FP::Tag server_instance(*srpc);

    // get arguments
    srpc->recv_end();

    // If we have a server instance mismatch...
    if(!check_server_instance(srpc, server_instance, "GetLeases"))
      {
        // Don't do anything else.
        return;
      }

    // pre debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- GetLeases" << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    BitVector *res = cs->GetLeases();

    // post debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- GetLeases" << endl;
        cout << "  cis = " << *res << endl;
        cout << endl;
        Debug::Unlock();
    }

    // Indicate that this is the correct server instance
    srpc->send_int(1);

    // send results
    res->Send(*srpc);
    srpc->send_end();
}

void ExpCache::ResumeLeaseExp(SRPC *srpc) throw (SRPC::failure)
{
    // Get the server instance fingerprint.
    FP::Tag server_instance(*srpc);

    // get arguments
    srpc->recv_end();

    // If we have a server instance mismatch...
    if(!check_server_instance(srpc, server_instance, "ResumeLeaseExp"))
      {
        // Don't do anything else.
        return;
      }

    // pre debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- ResumeLeaseExp" << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    cs->ResumeLeaseExp();

    // post debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- ResumeLeaseExp" << endl;
        cout << endl;
        Debug::Unlock();
    }

    // Indicate that this is the correct server instance
    srpc->send_int(1);

    // send results
    srpc->send_end();
}

void ExpCache::EndMark(SRPC *srpc) throw (SRPC::failure)
{
    // Get the server instance fingerprint.
    FP::Tag server_instance(*srpc);

    // get arguments
    BitVector cis(*srpc);
    PKPrefix::List pfxs(*srpc);
    srpc->recv_end();

    // If we have a server instance mismatch...
    if(!check_server_instance(srpc, server_instance, "EndMark"))
      {
        // Don't do anything else.
        return;
      }

    // pre debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- EndMark" << endl;
        cout << "  cis = " << cis << endl;
        cout << "  prefixes ="; pfxs.Print(cout, /*indent=*/ 4);
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    int chkptVer = cs->EndMark(cis, pfxs);

    // post debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- EndMark" << endl;
        cout << "  chkptVer = " << chkptVer << endl;
        cout << endl;
        Debug::Unlock();
    }

    // Indicate that this is the correct server instance
    srpc->send_int(1);

    // send results
    srpc->send_int(chkptVer);
    srpc->send_end();
}

void ExpCache::CommitChkpt(SRPC *srpc) throw (SRPC::failure)
{
    // Get the server instance fingerprint.
    FP::Tag server_instance(*srpc);

    // get arguments
    Text chkptFileName;
    srpc->recv_Text(/*OUT*/ chkptFileName);
    srpc->recv_end();

    // If we have a server instance mismatch...
    if(!check_server_instance(srpc, server_instance, "CommitChkpt"))
      {
        // Don't do anything else.
        return;
      }

    // pre debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- CommitChkpt" << endl;
        cout << "  chkptFileName = " << chkptFileName << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    bool l_result = cs->CommitChkpt(chkptFileName);

    // post debugging
    if (this->debug >= CacheIntf::WeederOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- CommitChkpt" << endl;
        cout << "  result: checkpoint " << (l_result?"accepted":"rejected")
             << endl;
        cout << endl;
        Debug::Unlock();
    }

    // Indicate that this is the correct server instance
    srpc->send_int(1);

    // send results
    srpc->send_int((int) l_result);
    srpc->send_end();
}

void ExpCache::FlushAll(SRPC *srpc) throw (SRPC::failure)
{
    // get arguments
    srpc->recv_end();

    // pre debugging
    if (this->debug >= CacheIntf::MPKFileFlush) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- FlushAll" << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    cs->FlushAll();

    // post debugging
    if (this->debug >= CacheIntf::MPKFileFlush) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- FlushAll" << endl;
        cout << endl;
        Debug::Unlock();
    }

    // send results
    srpc->send_end();
}

void ExpCache::GetCacheId(SRPC *srpc) throw (SRPC::failure)
{
    // get arguments
    srpc->recv_end();

    // pre debugging
    if (this->debug >= CacheIntf::OtherOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- GetCacheId" << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    CacheId id;
    cs->GetCacheId(/*OUT*/ id);

    // post debugging
    if (this->debug >= CacheIntf::OtherOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- GetCacheId" << endl;
        id.Print(cout, /*indent=*/ 2);
        cout << endl;
        Debug::Unlock();
    }

    // send results
    id.Send(*srpc);
    srpc->send_end();
}

void ExpCache::GetCacheInstance(SRPC *srpc) throw (SRPC::failure)
{
    // get arguments
    srpc->recv_end();

    // pre debugging
    if (this->debug >= CacheIntf::OtherOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- GetCacheInstance" << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    FP::Tag fp = cs->GetCacheInstance();

    // post debugging
    if (this->debug >= CacheIntf::OtherOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- GetCacheInstance" << endl
             << "  " << fp << endl;;
        cout << endl;
        Debug::Unlock();
    }

    // send results
    fp.Send(*srpc);
    srpc->send_end();
}

void ExpCache::GetCacheState(SRPC *srpc) throw (SRPC::failure)
{
    // get arguments
    srpc->recv_end();

    // pre debugging
    if (this->debug >= CacheIntf::OtherOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "CALLED -- GetCacheState" << endl;
        cout << endl;
        Debug::Unlock();
    }

    // call server function
    CacheState state;
    cs->GetCacheState(/*OUT*/ state);

    // post debugging
    if (this->debug >= CacheIntf::OtherOps) {
        Debug::Lock();
        cout << Debug::Timestamp() << "RETURNED -- GetCacheState" << endl;
        state.Print(cout, /*indent=*/ 2);
        cout << endl;
        Debug::Unlock();
    }

    // send results
    state.Send(*srpc);
    srpc->send_end();
}

---