amdb_wkldstats.cc

Libgist is an implementation of the Generalized Search Tree, a template index structure that makes i

// amdb_wkldstat.cc -*- c++ -*-
// Copyright (c) 1998, Regents of the University of California
// $Id: amdb_wkldstats.cc,v 1.2 2000/03/15 00:24:23 mashah Exp $

#ifdef __GNUG__
#pragma implementation "amdb_wkldstats.h"
#endif

// VCPORT_B
#ifdef HAVE_VALUES_H
#include <values.h>
#endif

#ifdef WIN32
#pragma warning(disable:4786) // Templates can cause names to get too long for
							  // debug information. Disables this warning.
#endif
// VCPORT_E

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "amdb_wkldstats.h"
#include "amdb_clustering.h"

#include <assert.h>
#include "gist.h"
#include "gist_compat.h"
#include "gist_p.h"
#include "amdb_ext.h"
#include "amdb_wkldprofile.h"
#include "amdb_treemap.h"

// STL
// VCPORT_B
#ifdef WIN32
#include <vector>
#include <algorithm>
#include <fstream>
#include <iostream>

using namespace std;
#else
#include <vector.h>
#include <algo.h>
#endif
// VCPORT_E

/////////////////////////////////////////////////////////////////////////
// amdb_wkldstats::NodeStats::NodeStats() - constructor
//
// Description:
//
/////////////////////////////////////////////////////////////////////////

amdb_wkldstats::NodeStats::NodeStats() :
    utilLoss(0.0), utilOh(0.0), optClusterLoss(0.0), optClusterOh(0.0),
    minClusterLoss(0.0), minClusterOh(0.0), excCovLoss(0.0), excCovOh(0.0)
{
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldstats::amdb_wkldstats - constructor
//
// Description:
//
/////////////////////////////////////////////////////////////////////////

amdb_wkldstats::amdb_wkldstats() :
    nodeStats(), queryStats(), statsTotals()
{
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldstats::clear - reset state
//
// Description:
// 	- don't deallocate anything, we might still need it for 
//	  subsequent read() calls
/////////////////////////////////////////////////////////////////////////

void
amdb_wkldstats::clear()
{
    cout << "amdb_wkldstats::clear()" << endl;
    NodeStatsMap::iterator nsit;
    for (nsit = nodeStats.begin(); nsit != nodeStats.end(); nsit++) {
	NodeStats* s = (NodeStats *) (*nsit).second;
        delete s;
    }
    //cout << "delete NodeStats: " << endl;
    nodeStats.erase(nodeStats.begin(), nodeStats.end());

    QueryStatsVect::iterator qit;
    for (qit = queryStats.begin(); qit != queryStats.end(); qit++) {
	QueryStats* qs = (QueryStats *) *qit;
	delete qs;
    }
    queryStats.erase(queryStats.begin(), queryStats.end());
    //cout << "delete queries" << endl;

}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldstats::~wkldstats - free dynamically allocated state
//
// Description:
/////////////////////////////////////////////////////////////////////////

amdb_wkldstats::~amdb_wkldstats()
{
    cout << "~amdb_wkldstat()" << endl;

    clear();
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldstats::write - write out state
//
// Description:
//
// Preconditions:
// Postconditions:
// Notes:
//
// Return Values:
//      RCOK
/////////////////////////////////////////////////////////////////////////

rc_t 
amdb_wkldstats::write(
    ostream& s,
    bool ascii)
{
    cout << "amdb_wkldstats::write()" << endl;

    // save nodeStats
    NodeStatsMap::size_type nodeStatsSize = nodeStats.size();
    s.write((char *) &nodeStatsSize, sizeof(nodeStatsSize));

    shpid_t tmpPg;
    NodeStatsMap::iterator nsit;
    for (nsit = nodeStats.begin(); nsit != nodeStats.end(); nsit++) {
	shpid_t pgno = (shpid_t) (*nsit).first;
	NodeStats* ns = (NodeStats*) (*nsit).second;
	s.write((char *) &pgno, sizeof(pgno));
	s.write((char *) ns, sizeof(*ns));
    }

    // save queryStats
    QueryStatsVect::size_type queryStatsSize = queryStats.size();
    s.write((char *) &queryStatsSize, sizeof(queryStatsSize));

    int curQuery = 0;
    QueryStatsVect::iterator qit;
    for (qit = queryStats.begin(); qit != queryStats.end(); qit++) {
	QueryStats* qs = (QueryStats *) *qit;
	s.write((char *) qs, sizeof(*qs));
    }

    // save statsTotals
    s.write((char *) &statsTotals, sizeof(statsTotals));

    // check for errors
    if (!s) return(eFILEERROR);

    return(RCOK);
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldstats::read - read binary profile from file
//
// Description:
//
// Return Values:
//      RCOK
//	eFILEERROR
/////////////////////////////////////////////////////////////////////////

rc_t
amdb_wkldstats::read(
    istream& 	s)
{
    cout << "amdb_wkldstats::read()" << endl;

    clear(); // delete current data, if there is any 

    // read nodeStats;
    //cout << "read nodeStats" << endl;
    NodeStatsMap::size_type nodeStatsSize;
    s.read((char *) &nodeStatsSize, sizeof(nodeStatsSize));
    int cnt;
    for (cnt = 0; cnt < nodeStatsSize; cnt++) {
	shpid_t pgno;
	s.read((char *) &pgno, sizeof(pgno));
	NodeStats* ns = new NodeStats();
	s.read((char *) ns, sizeof(*ns));
	nodeStats[pgno] = (void *) ns;
    }

    // read queryStats
    //cout << "read queries" << endl;
    QueryStatsVect::size_type queryStatsSize;
    s.read((char *) &queryStatsSize, sizeof(queryStatsSize));
    queryStats.reserve(queryStatsSize);
    unsigned queryno;
    for (queryno = 0; queryno < queryStatsSize; queryno++) {
        QueryStats* q = new QueryStats();
	queryStats.push_back((void *) q);
	s.read((char *) q, sizeof(*q));
    }

    // read statsTotals
    s.read((char *) &statsTotals, sizeof(statsTotals));

    // check for errors
    if (!s) {
        return(eFILEERROR);
    }

    return(RCOK);
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldstats::_computeRandomIos
//
// Description:
//  	- Computes I/O numbers for random clusterings. Stores the result of
//	  each run in a local variable and computes avg and std dev at the end.
//
/////////////////////////////////////////////////////////////////////////

void
amdb_wkldstats::_computeRandomIos(
    const amdb_wkldprofile&		profile, // in
    const amdb_treemap& 		tmap, // in
    int					runs, // in
    float				fillFactor) // in
{
    typedef Vector* VectorPtr; // used as vector<int>: # of I/Os
    VectorPtr* tempResults = new VectorPtr[runs];
    assert(tempResults != NULL);
    int numQueries = profile.queries.size(); // one record per query
    int run;
    amdb_clustering::Clustering clustering;

    // temporarily need the result sets separated from profile
    amdb_clustering::ResultSet* resultSets;
    profile.extractResultSets(resultSets);

    for (run = 0; run < runs; run++) {
        amdb_clustering::randomClustering(resultSets, numQueries, fillFactor,
	    false, tmap, clustering);

	// evaluate queries against clustering
        tempResults[run] = new Vector(numQueries+1); // +1: for totalIos
	int queryCnt = 0;
	amdb_wkldprofile::QueryVect::const_iterator it;
	for (it = profile.queries.begin(); it != profile.queries.end();
	    it++, queryCnt++) {

	    // compute I/Os for single query
	    amdb_wkldprofile::Query* query = (amdb_wkldprofile::Query *) *it;
	    (*tempResults[run])[queryCnt] =
	        (void *) profile.computeIoCnt(query, clustering);
	    // add to total
	    int* total = (int *) &(*tempResults[run])[numQueries];
	    *total += (int) (*tempResults[run])[queryCnt];
	}
    }

    // summarize the I/O results for each query and for total (compute avg. and std. dev.)
    int qno;
    for (qno = 0; qno <= numQueries; qno++) {
	QueryStats* stats;
        if (qno < numQueries) {
	    stats = (QueryStats *) queryStats[qno];
	} else {
	    stats = &statsTotals;
	}

        int ioCnt = 0;
	for (run = 0; run < runs; run++) {
	    ioCnt += (int) (*tempResults[run])[qno];
	}
	stats->leafStats.randomIos = (float) ioCnt / (float) runs;
	// compute std dev
	float var = 0.0;
	for (run = 0; run < runs; run++) {
	    int res = (int) (*tempResults[run])[qno];
	    float diff = (float) res - stats->leafStats.randomIos;
	    var += diff * diff;
	}
	var /= (float) runs;
	stats->leafStats.randomStdDev = sqrt(var);
    }

    // deallocate tempResults
    for (run = 0; run < runs; run++) {
        tempResults[run]->erase(tempResults[run]->begin(), tempResults[run]->end());
	delete tempResults[run];
    }
    delete [] tempResults;

    delete [] resultSets;
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldstats::_computeOptimalIos
//
// Description:
//	- computes optimal clustering and I/O counts for all queries
//	  as well as total
//
// Return Values:
//      RCOK
/////////////////////////////////////////////////////////////////////////

void
amdb_wkldstats::_computeOptimalIos(
    const amdb_wkldprofile& profile,
    const amdb_clustering::Clustering& optClustering)
{
    // compute optimalIos for each query and the total
    amdb_wkldprofile::QueryVect::const_iterator qit;
    QueryStatsVect::iterator qsit;
    for (qit = profile.queries.begin(), qsit = queryStats.begin();
        qit != profile.queries.end(); qit++, qsit++) {

	amdb_wkldprofile::Query* query = (amdb_wkldprofile::Query *) *qit;
	QueryStats* qs = (QueryStats *) *qsit;
	qs->leafStats.optimalIos = profile.computeIoCnt(query, optClustering);
    }
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldstats::_computeQueryStats - complete QueryStats
//
// Description:
/////////////////////////////////////////////////////////////////////////

void
amdb_wkldstats::_computeQueryStats(
    const amdb_wkldprofile& profile, // in
    const amdb_treemap& tmap, // in
    float targetUtil) // in
{
    QueryStatsVect::iterator it;
    amdb_wkldprofile::QueryVect::const_iterator pit;
    for (it = queryStats.begin(), pit = profile.queries.begin();
        it != queryStats.end(); it++, pit++) {

	QueryStats* qs = (QueryStats *) *it;
	amdb_wkldprofile::Query* query = (amdb_wkldprofile::Query *) *pit;
	int nonEmptyLeaves =
	    query->stats.leafStats.totalIos - query->numEmptyLeaves;

	// compute excCovLoss, utilLoss of leaves and internal nodes
	qs->leafStats.excCovLoss = query->numEmptyLeaves;
	qs->leafStats.utilLoss =