amdb_wkldprofile.cc

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

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

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

// VCPORT_B
#ifdef WIN32
#pragma warning(disable:4786)
#endif

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

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "amdb_wkldprofile.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_treemap.h"
#include "amdb_itemset.h"

// STL
// VCPORT_B
#ifndef WIN32

#include <vector.h>
#include <algo.h>
#include <fstream.h>

#else

#include <vector>
#include <algorithm>
#include <fstream>
#include <iostream>

using namespace std;

#endif
// VCPORT_E

// size w/o 'children' component (needed when reading/writing
// TraversalStats)
static amdb_wkldprofile::TraversalStats _dummyTs;
const int amdb_wkldprofile::TraversalStats::SIZE =
    sizeof(amdb_wkldprofile::TraversalStats) - 
    ((char *) &_dummyTs.pageno - (char *) &_dummyTs);


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::TraversalStats::add - add up traversal stats
//
// Description:
//	- adds up traversal stats for same page (for statsTotals)
//
/////////////////////////////////////////////////////////////////////////

void
amdb_wkldprofile::TraversalStats::add(
    const TraversalStats& 	stats) 
{
    assert(pageno == stats.pageno);
    traversalCnt += stats.traversalCnt;
    retrievalCnt += stats.retrievalCnt;
    retrievalVol += stats.retrievalVol;
    emptyNode += stats.emptyNode;
    emptySubtree += stats.emptyNode;
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::InternalTraversalStats::operator= -
//	copy data from TraversalStats
//
// Description:
//
// Return Values:
//      *this
/////////////////////////////////////////////////////////////////////////

amdb_wkldprofile::InternalTraversalStats&
amdb_wkldprofile::InternalTraversalStats::operator=(
    const TraversalStats& s)
{
    pageno = s.pageno;
    retrievalCnt = s.retrievalCnt;
    emptyNode = s.emptyNode == 1;
    return *this;
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::TraversalStats::operator= - 
//
// Description:
//
// Return Values:
//      *this
/////////////////////////////////////////////////////////////////////////

amdb_wkldprofile::TraversalStats&
amdb_wkldprofile::TraversalStats::operator=(
    const TraversalStats& s)
{
    pageno = s.pageno;
    isLeaf = s.isLeaf;
    children.erase(children.begin(), children.end());
    traversalCnt = s.traversalCnt;
    retrievalCnt = s.retrievalCnt;
    retrievalVol = s.retrievalVol;
    emptyNode = s.emptyNode;
    emptySubtree = s.emptySubtree;
    return(*this);
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::TraversalStats::TraversalStats - constructor
//
// Description:
//	- called when reading TraversalStats from input stream
/////////////////////////////////////////////////////////////////////////

amdb_wkldprofile::TraversalStats::TraversalStats()
{
    TraversalStats(0);
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::TraversalStats::TraversalStats - constructor
//
// Description:
//	- called when allocating TraversalStats for specific page
/////////////////////////////////////////////////////////////////////////

amdb_wkldprofile::TraversalStats::TraversalStats(
    shpid_t 	pageno) :
    pageno(pageno), isLeaf(false), children(), traversalCnt(0), retrievalCnt(0),
    retrievalVol(0), emptyNode(0), emptySubtree(0)
{
}


///////////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::StatsTotals::StatsTotals - constructor
//
// Description:
//	- leaves traversalStats empty, entries are allocated and inserted
//	  as needed in finalizeQuery()
///////////////////////////////////////////////////////////////////////////////

amdb_wkldprofile::StatsTotals::StatsTotals() : 
    retrievedCnt(0), dataCoverage(0), traversalStats(), stats()
{
}

amdb_wkldprofile::StatsTotals::~StatsTotals()
{
    //cout << "~StatsTotals()" << endl;
    TraversalStatsMap::iterator it;
    for (it = traversalStats.begin(); it != traversalStats.end(); it++) {
	TraversalStats* stats = (TraversalStats *) (*it).second;
	delete stats;
    }
}


amdb_wkldprofile::Query::Query() :
    retrLimit(0), qual(NULL), resultSetSize(0), resultSet(NULL),
    numEmptyLeaves(0), emptyLeaves(NULL), traversalStatsSize(0),
    traversalStats(NULL)
{
}

amdb_wkldprofile::Query::~Query()
{
    //cout << "~Query()" << endl;
    delete [] qual;
    delete [] resultSet;
    delete [] emptyLeaves;
    delete [] traversalStats;
}


///////////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::amdb_wkldprofile - constructor
//
// Description:
///////////////////////////////////////////////////////////////////////////////

amdb_wkldprofile::amdb_wkldprofile() :
    queries(), statsTotals(), _resultSet(), _traversalStats(), _treeMap(NULL)
{
}

#if 0
///////////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::amdb_wkldprofile - constructor
//
// Description:
//	- construct profile that will subsequently be used on specific tree
///////////////////////////////////////////////////////////////////////////////

amdb_wkldprofile::amdb_wkldprofile(const amdb_treemap* map) :
    queries(), statsTotals(), _resultSet(), _traversalStats(), _treeMap(map)
{
    assert(map != NULL);
}
#endif


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

void
amdb_wkldprofile::clear()
{
    cout << "amdb_wkldprofile::clear()" << endl;

    int numQueries = queries.size(); // needed for optResultSets
    QueryVect::iterator qit;
    for (qit = queries.begin(); qit != queries.end(); qit++) {
	Query* query = (Query *) *qit;
	delete query;
    }
    queries.erase(queries.begin(), queries.end());
    //cout << "delete queries" << endl;

    TraversalStatsMap::iterator tmit;
    for (tmit = statsTotals.traversalStats.begin();
        tmit != statsTotals.traversalStats.end(); tmit++) {
        
	TraversalStats* stats = (TraversalStats *) (*tmit).second;
	delete stats;
    }
    statsTotals.traversalStats.erase(statsTotals.traversalStats.begin(),
        statsTotals.traversalStats.end());
    //cout << "delete statsTotals.traversalStats" << endl;

    _resultSet.erase(_resultSet.begin(), _resultSet.end());

    for (tmit = _traversalStats.begin(); tmit != _traversalStats.end(); tmit++) {
        TraversalStats* stats = (TraversalStats *) (*tmit).second;
	delete stats;
    }
    _traversalStats.erase(_traversalStats.begin(), _traversalStats.end());

    _treeMap = NULL;

}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::~amdb_wkldprofile - destructor
//
// Description:
//
/////////////////////////////////////////////////////////////////////////

amdb_wkldprofile::~amdb_wkldprofile()
{
    cout << "~amdb_wkldprofile()" << endl;

    clear();
    //cout << "    delete queries" << endl;
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::write - write out profile
//
// Description:
//	- don't save _treeMap, only used when accumulating data
//
// Return Values:
//      RCOK
/////////////////////////////////////////////////////////////////////////

rc_t 
amdb_wkldprofile::write(
    ostream& 	s, // in: name of file to save to
    bool		ascii) // in: if true, write out in ASCII
{
    cout << "amdb_wkldprofile::write()" << endl;

    // save queries
    QueryVect::size_type queriesSize = queries.size();
    s.write((char *) &queriesSize, sizeof(queriesSize));

    int curQuery = 0;
    QueryVect::iterator qit;
    for (qit = queries.begin(); qit != queries.end(); qit++) {
	Query* query = (Query *) *qit;

	// save queries.retrLimit
	s.write((char *) &query->retrLimit, sizeof(query->retrLimit));

	// save queries.qual
	int len = (query->qual == 0 ? 0 : strlen(query->qual));
	s.write((char *) &len, sizeof(len));
	if (query->qual != NULL) {
	    s.write(query->qual, strlen(query->qual));
	}

	// save queries.resultSet
	s.write((char *) &query->resultSetSize,
	    sizeof(query->resultSetSize));
	int i;
	for (i = 0; i < query->resultSetSize; i++) {
	    s.write((char *) &query->resultSet[i],
		sizeof(query->resultSet[i]));
	}

	// save queries.emptyLeaves
	s.write((char *) &query->numEmptyLeaves,
	    sizeof(query->numEmptyLeaves));
	for (i = 0; i < query->numEmptyLeaves; i++) {
	    s.write((char *) &query->emptyLeaves[i],
		sizeof(query->emptyLeaves[i]));
	}

	// save queries.traversalStats
	s.write((char *) &query->traversalStatsSize,
	    sizeof(query->traversalStatsSize));
	int statno;
	for (statno = 0; statno < query->traversalStatsSize; statno++) {
	    s.write((char *) &query->traversalStats[statno],
		sizeof(query->traversalStats[statno]));
	}

	// write queries.stats
	s.write((char *) &query->stats, sizeof(query->stats));
    }

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

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

    // save statsTotals.traversalStats