TestMarshalS.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 00:27:16 EDT 2005 by ken@xorian.net  
//      modified on Fri Jul 27 19:01:42 PDT 2001 by mann  
//      modified on Sat Jan 29 14:27:43 PST 2000 by heydon

/* This program is a simple test of the marshalling interfaces for the Vesta
   cache server. The modules are:

   Client side: CacheC, ParCacheC
   Server side: CacheS, ExpCache
   Both sides:  CacheIntf, Repository, CacheIndex, FV, Derived, VestaVal

   The syntax for the server application is:

     server [ maxRunning [ maxBlocked ] ]

   Any omitted argument defaults to a large integer. The first argument
   specifies the maximum number of server threads allowed to run at once. If
   it is specified, a supplied second argument specifies the maximum number of
   threads allowed to block when the maximum number of threads are running
   before refusing the connection. */

// basics
#include <Basics.H>
#include <Table.H>
#include <FP.H>

// cache-common
#include <CacheIntf.H>
#include <Debug.H>
#include <ReadConfig.H>
#include <PKPrefix.H>
#include <CacheState.H>
#include <Model.H>
#include <CacheIndex.H>
#include <FV.H>
#include <VestaVal.H>
#include <NewVal.H>

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

CacheS::CacheS(CacheIntf::DebugLevel debug, bool noHits) throw ()
{
    this->debug = CacheIntf::All;
}

FV::Epoch CacheS::FreeVariables(const FP::Tag& pk,
  /*OUT*/ FV::List &names, /*OUT*/ bool &isEmpty) throw ()
{
    FV::Epoch res;
    NewVal::NewNames(/*OUT*/ names);
    isEmpty = ((names.len == 0) && (Debug::MyRand(0, 5) > 1));
    res = Debug::MyRand(0, 1000);
    return(res);
}

CacheIntf::LookupRes
CacheS::Lookup(const FP::Tag &pk, FV::Epoch id, const FP::List &fps,
  /*OUT*/ CacheEntry::Index &ci, /*OUT*/ const VestaVal::T* &value) throw ()
{
    CacheIntf::LookupRes res;
    int i = Debug::MyRand(1, 10);
    if (i < 6) res = CacheIntf::Hit;
    else if (i < 8) res = CacheIntf::Miss;
    else res = CacheIntf::FVMismatch;
    if (res == CacheIntf::Hit) {
        ci = (int)Debug::MyRand(0,9999);
        VestaVal::T *newValue = NEW(VestaVal::T);// allocate non-const local
        NewVal::NewValue(*(newValue));           // fill it in
        value = (const VestaVal::T *)newValue;   // cast it to result
    }
    return(res);
}

CacheIntf::AddEntryRes
CacheS::AddEntry(FP::Tag *pk, FV::List *names, FP::List *fps,
  VestaVal::T *value, Model::T model, CacheEntry::Indices* kids,
  /*OUT*/ CacheEntry::Index& ci) throw ()
{
    CacheIntf::AddEntryRes res;
    int i = Debug::MyRand(0, 7);
    res = (i == 0) ? CacheIntf::NoLease : CacheIntf::EntryAdded;
    if (res == CacheIntf::EntryAdded) {
        ci = Debug::MyRand(0, 9999);
    }
    return res;
}

void CacheS::WeederRecovering(bool doneMarking) throw ()
{
    /* SKIP */
}

BitVector* CacheS::StartMark(/*OUT*/ int &newLogVer) throw ()
{
  BitVector *res = NEW(BitVector);
  for (int i = 0; i < 10; i++) {
    int j = Debug::MyRand(0, 60);
    (void) res->Set(j);
  }
  newLogVer = 0;
  return res;
}

void CacheS::SetHitFilter(const BitVector &cis) throw ()
{
    /* SKIP */
}

BitVector* CacheS::GetLeases() throw ()
{
  BitVector *res = NEW(BitVector);
  for (int i = 0; i < 10; i++) {
    int j = Debug::MyRand(0, 60);
    (void) res->Set(j);
  }
  return res;
}

void CacheS::ResumeLeaseExp() throw ()
{
    /* SKIP */
}

int CacheS::EndMark(const BitVector &cis, const PKPrefix::List &pfxs) throw ()
{
    return 1;
}

void CacheS::CommitChkpt() throw ()
{
    /* SKIP */
}

void CacheS::Checkpoint(const FP::Tag &pkgVersion, Model::T model,
  CacheEntry::Indices *cis, bool done) throw ()
{
    /* SKIP */
}

void CacheS::FlushAll() throw ()
{
    /* SKIP */
}

void CacheS::GetCacheId(/*OUT*/ CacheId &id) throw ()
{
    /* SKIP */
}

void CacheS::GetCacheState(/*OUT*/ CacheState &state) throw ()
{
    /* SKIP */
}

bool CacheS::RenewLeases(CacheEntry::Indices *cis) throw ()
{
    int i = Debug::MyRand(0,1);
    bool res = (i == 0);
    return res;
}

void CacheWorker::Start() throw ()
{
    /* NO-OP */
}

void ExitServer() throw ()
{
    cerr << "SYNTAX: server [ maxRunning [ maxBlocked ] ]" << endl;
    exit(1);
}

void HandleFailure(SRPC *srpc, const SRPC::failure &f, void *arg) throw ()
{
    cerr << "SRPC failure (code " << f.r << "):" << endl;
    cerr << "  " << f.msg << endl << endl;
}

void Server(int argc, char *argv[]) throw ()
{
    int maxRunning, maxBlocked;

    // parse arguments
    if (argc > 3) {
        cerr << "Error: Too many arguments" << endl;
        ExitServer();
    }
    maxRunning = maxBlocked = 10000;
    if (argc > 1) sscanf(argv[1], "%d", &maxRunning);
    if (argc > 2) sscanf(argv[2], "%d", &maxBlocked);

    // start server
    CacheS cs;
    Debug::Lock();
    cout << "Starting server:" << endl;
    cout << "  Config file = " << ReadConfig::Location() << endl;
    cout << "  Maximum number of running threads = " << maxRunning << endl;
    cout << "  Maximum number of blocked threads = " << maxBlocked << endl;
    cout << endl;
    Debug::Unlock();
    ExpCache exp(&cs, maxRunning, maxBlocked, HandleFailure);

    // Run the cache server
    while (1) {
        try {
            exp.Run();
        }
        catch (SRPC::failure f) {
            HandleFailure((SRPC *)NULL, f, (void *)NULL);
            // exit immediately if another server is already running
            if (f.r == SRPC::transport_failure) break;
        }
    }
}

int main(int argc, char *argv[]) throw ()
{
    Server(argc, argv);
    return(0);
}

---