amdb_wkldprofile.cc

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

	    totalsStats = new TraversalStats(ts->pageno);
	    statsTotals.traversalStats[ts->pageno] = (void *) totalsStats;
	}

	totalsStats->isLeaf = ts->isLeaf;
	totalsStats->add(*ts);

	if (!ts->isLeaf) {
	    // record internal nodes only
	    query->traversalStats[i] = *ts;
	    i++;
	} else if (ts->emptyNode == 1) {
	    query->emptyLeaves[j] = ts->pageno;
	    j++;
	}
    }

    // reset _resultSet and traversalStats
    _resultSet.erase(_resultSet.begin(), _resultSet.end());
    for (tsit = _traversalStats.begin(); tsit != _traversalStats.end(); tsit++) {
	delete (TraversalStats *) (*tsit).second;
    }
    _traversalStats.erase(_traversalStats.begin(), _traversalStats.end());
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::createTraversalStats - 
//	generate map of traversal stats out of Query
//
// Description:
//	- always leaves retrievalVol = 0 for internal nodes
//
/////////////////////////////////////////////////////////////////////////

void
amdb_wkldprofile::createTraversalStats(
    const Query& query,
    TraversalStatsMap& tsMap) const
{
    // reset map
    clearTraversalStatsMap(tsMap);

    // convert emptyLeaves
    int i;
    for (i = 0; i < query.numEmptyLeaves; i++) {
        TraversalStats* stats = new TraversalStats(query.emptyLeaves[i]);
	tsMap[stats->pageno] = (void *) stats;
	stats->isLeaf = true;
	stats->traversalCnt = 1;
	stats->retrievalCnt = 0;
	stats->retrievalVol = 0;
	stats->emptyNode = 1;
	stats->emptySubtree = 1;
    }

    // convert traversalStats
    for (i = 0; i < query.traversalStatsSize; i++) {
        InternalTraversalStats* qstats = &query.traversalStats[i];
        TraversalStats* stats = new TraversalStats(qstats->pageno);
	tsMap[stats->pageno] = (void *) stats;
	stats->isLeaf = false;
	stats->traversalCnt = 1;
	stats->retrievalCnt = qstats->retrievalCnt;
	stats->retrievalVol = 0; // not recorded for internal nodes
	stats->emptyNode = (qstats->emptyNode ? 1 : 0);
	stats->emptySubtree = ((qstats->retrievalCnt == 0) ? 1 : 0);
    }

    // convert resultSet
    for (i = 0; i < query.resultSetSize; i++) {
	const amdb_treemap::RecInfo* info =
	      _treeMap->itemInfo(query.resultSet[i]);
        shpid_t pageno = info->loc.treeLoc.page;
	TraversalStats* stats = (TraversalStats *) tsMap[pageno];
	if (stats == NULL) {
	    // entry doesn\'t exist yet
	    stats = new TraversalStats(pageno);
	    tsMap[pageno] = (void *) stats;
	    stats->isLeaf = true;
	    stats->traversalCnt = 1;
	}
	// add item to corresponding TraversalStat
	stats->retrievalCnt++;
	stats->retrievalVol += 
            _treeMap->itemInfo(query.resultSet[i])->size;
    }
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::clearTraversalStatsMap - resets map
//
// Description:
/////////////////////////////////////////////////////////////////////////

void
amdb_wkldprofile::clearTraversalStatsMap(TraversalStatsMap& tmap)
{
    TraversalStatsMap::iterator it;
    for (it = tmap.begin(); it != tmap.end(); it++) {
	TraversalStats* stats = (TraversalStats *) (*it).second;
	delete stats;
    }
    tmap.erase(tmap.begin(), tmap.end());
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::extractResultSets - extract result sets from 'queries'
//
// Description:
//	- doesn't allocate storage for the items, only stores a 
//	  pointer to them in the amdb_clustering::ResultSet
/////////////////////////////////////////////////////////////////////////

void
amdb_wkldprofile::extractResultSets(
    amdb_clustering::ResultSet *&resultSets) const
{
    resultSets = new amdb_clustering::ResultSet[queries.size()];
    assert(resultSets != NULL);

    QueryVect::const_iterator it;
    int i;
    for (it = queries.begin(), i = 0; it != queries.end(); it++, i++) {
	Query *query = (Query *) *it;
        resultSets[i].itemCnt = query->resultSetSize;
        resultSets[i].items = query->resultSet;
    }
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::projectToClusters - project query result sets onto clusters
//
// Description:
//	- allocates result sets (as many as queries.size())
/////////////////////////////////////////////////////////////////////////

void
amdb_wkldprofile::projectToClusters(
    const amdb_clustering::Clustering&		clustering, // in
    amdb_clustering::ResultSet*&		resultSets) const // out
{
    int numResultSets = queries.size();
    resultSets = new amdb_clustering::ResultSet[numResultSets];
    QueryVect::const_iterator qit;
    IoCntMap map;
    // for each query, determine how many clusters it accesses
    int i;
    for (qit = queries.begin(), i = 0; qit != queries.end(); qit++, i++) {
	Query* query = (Query *) *qit;
	// compute the clusters
        computeIoCntMap(query, clustering, map);

	// construct the query's result set (in terms of the clustering)
	resultSets[i].itemCnt = map.size();
	resultSets[i].items = new ItemId[resultSets[i].itemCnt];
	IoCntMap::iterator mit;
	int j;
	for (mit = map.begin(), j = 0; mit != map.end(); mit++, j++) {
	    resultSets[i].items[j] = (ItemId) (*mit).first;
	}
    }
}


///////////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::computeIoCnt -
//	computes # of I/Os for single query and given clustering
//
// Description:
//
///////////////////////////////////////////////////////////////////////////////

int
amdb_wkldprofile::computeIoCnt(
    Query* query,
    const amdb_clustering::Clustering& clustering)
{
    IoCntMap map;
    computeIoCntMap(query, clustering, map);
    return(map.size());
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::computeIoCntMap - computes IoCntMap for single query
//
// Description:
//
/////////////////////////////////////////////////////////////////////////

void
amdb_wkldprofile::computeIoCntMap(
    Query* 				query,
    const amdb_clustering::Clustering& 	clustering,
    IoCntMap&				cntMap) // out
{
    int i;
    for (i = 0; i < query->resultSetSize; i++) {
	ItemId itemNo = query->resultSet[i];
	int clustNo = (int) clustering[itemNo].clusterNo;
	assert(clustNo != amdb_clustering::invalidNo); // can't happen: invalid clust no
	cntMap[(unsigned int) clustNo] = (void *) 1;
    }
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::retrievalVolume -
// 	return size of data that query returns from given page
//
// Description:
//
// Return Values:
//      size of data in bytes
/////////////////////////////////////////////////////////////////////////

int 
amdb_wkldprofile::retrievalVolume(
    const Query& query,
    shpid_t pgno) const
{
    smsize_t vol = 0;

    int i;
    for (i = 0; i < query.resultSetSize; i++) {
	const amdb_treemap::RecInfo* info = 
	    _treeMap->itemInfo(query.resultSet[i]);
        if (info->loc.treeLoc.page == pgno) {
	    vol += _treeMap->itemInfo(query.resultSet[i])->size;
        }
    }
    return (int) vol;
}


/////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::projectToNode - project result sets onto node
//
// Description:
//	- returned projected result sets contain item numbers recorded in
//	  'map'
//	- only return non-empty projections
//	- allocates projectedSets[].items
//
/////////////////////////////////////////////////////////////////////////

void
amdb_wkldprofile::projectToNode(
    shpid_t node, // in
    amdb_clustering::ResultSet projectedSets[], // out
    int& numProjected) const // out
{
    // XXX debug: record retrieval status of node items (map<ItemId, [01]>)
    Map nodeCnt;

    // construct itemset for contents of node
    amdb_itemset nodeContents;
    nodeContents.pageItems(*_treeMap, node);

    // XXX debug: init all to 0
    amdb_itemset::ItemIdVect::iterator iit;
    for (iit = nodeContents.itemIds.begin(); iit != nodeContents.itemIds.end(); iit++) {
        nodeCnt[*iit] = (void *) 0;
    }

    QueryVect::const_iterator qit;
    amdb_itemset intersection;
    bool intersects;
    int i = 0;
    numProjected = 0;
    for (qit = queries.begin(); qit != queries.end(); qit++, i++) {
	Query* query = (Query *) *qit;
        intersects = intersection.intersection(nodeContents, query->resultSet,
	    query->resultSetSize);

	// copy intersection to resultSet
	if (intersects) {
	    // XXX debug
	    //cout << i << " ";

	    projectedSets[numProjected].itemCnt = intersection.itemIds.size();
	    projectedSets[numProjected].items = new ItemId[intersection.itemIds.size()];
	    amdb_itemset::ItemIdVect::iterator it;
	    int j;
	    for (it = intersection.itemIds.begin(), j = 0;
	        it != intersection.itemIds.end(); it++, j++) {

		projectedSets[numProjected].items[j] = *it;
		nodeCnt[*it] = (void *) 1;
	    }
	    numProjected++;
	}
    }
    //cout << endl;
}


///////////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::copyResultSets - copy and translate result sets
//
// Description:
//
///////////////////////////////////////////////////////////////////////////////

void
amdb_wkldprofile::copyResultSets(
    const amdb_wkldprofile& source,
    const TranslationMap& tmap)
{
    // create empty queries
    queries.reserve(source.queries.size());

    // create each Query and copy and translate the result set, given
    // the translation map
    QueryVect::const_iterator it;
    for (it = source.queries.begin(); it != source.queries.end(); it++) {
	Query* query = (Query *) *it;
	Query* newQuery = new Query();
	queries.push_back((void *) newQuery);
	newQuery->resultSetSize = query->resultSetSize;
	newQuery->resultSet = new ItemId[newQuery->resultSetSize];

	int i;
	for (i = 0; i < newQuery->resultSetSize; i++) {
	    newQuery->resultSet[i] = (ItemId) (*tmap.find(query->resultSet[i])).second;
	}
	sort(newQuery->resultSet, newQuery->resultSet + newQuery->resultSetSize);
    }
}


///////////////////////////////////////////////////////////////////////////////
// amdb_wkldprofile::setQual - sets Query.qual and .retrLimit
//
// Description:
//
// Return Values:
//      RCOK
///////////////////////////////////////////////////////////////////////////////

void
amdb_wkldprofile::setQual(
    int queryNo,
    const char* qual,
    int retrLimit)
{
    assert(queryNo < queries.size());
    Query* query = (Query *) queries[queryNo];
    query->retrLimit = retrLimit;
    int len = strlen(qual) + 1;
    query->qual = new char[len];
    (void) memcpy(query->qual, qual, len);
}