libgist.cc

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

// return # of pages in index
JNIEXPORT jint JNICALL
Java_Libgist_libPageCount(
    JNIEnv* env,
    jclass cl)
{
    return Gist_gist->pageCount();
}


///////////////////////////////////////////////////////////////////////////////
// libGetWkldNodeStats - return amdb_wkldprofile/-stats node stats
//
// Description:
//	- query-dependent node stats are extracted from analysis
//	- structural stats are extract from tree map, which is computed
// 	  on demand
//
// Exceptions: none
//
///////////////////////////////////////////////////////////////////////////////

// corresponds to constants in Gist.java
enum WkldStatTypes {
    traversals = 0,
    retrievals,
    emptySubtrees,
    clusterLoss,
    clusterOh,
    utilLoss,
    utilOh,
    excCovLoss,
    excCovOh,
    nodeUtil,
    slotCnt,
    predSize,
    numWkldStatsTypes
};

JNIEXPORT void JNICALL
Java_Libgist_libGetWkldNodeStats(
    JNIEnv* env,
    jclass cl,
    jint statsType,
    jint queryNo,
    jboolean minStats,
    jfloatArray stats)
{
    DBGPRINT(1, cout << "libGetWkldNodeStats()" << endl);
    jsize statsSize = env->GetArrayLength(stats);
    if (statsSize < Gist_gist->pageCount()) {
        cerr << "statsSize < pageCount (" << statsSize << " < " << 
	    Gist_gist->pageCount() << ")" << endl;
        assert(statsSize >= Gist_gist->pageCount());
    }
    jfloat* statsCopy = env->GetFloatArrayElements(stats, NULL);

    // initialize stats array to statsType-specific value
    int initVal[numWkldStatsTypes] = {
        0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0
    };
    int i;
    for (i = 0; i < statsSize; i++) {
        statsCopy[i] = initVal[statsType];
    }

    // for now, we only deal with the actual tree
    amdb_analysis::TreeAnalysis& target = Gist_analysis->actualAnalysis;

    // extract from amdb_wkldprofile::TraversalStats
    if (statsType == traversals || statsType == retrievals ||
        statsType == emptySubtrees) {

	assert(Gist_analysis != NULL);
	assert(target.profile != NULL);

	amdb_wkldprofile::TraversalStatsMap* tsMap;
	if (queryNo == 0) {
	    // we want totals
	    tsMap = &target.profile->statsTotals.traversalStats;
	} else {
	    tsMap = new amdb_wkldprofile::TraversalStatsMap();
	    amdb_wkldprofile::Query* query =
	        (amdb_wkldprofile::Query *) target.profile->queries[queryNo-1];
	    target.profile->createTraversalStats(*query, *tsMap);
	}

	amdb_wkldprofile::TraversalStatsMap::const_iterator it;
	for (it = tsMap->begin(); it != tsMap->end(); it++) {
	    shpid_t pageno = (shpid_t) (*it).first;
	    amdb_wkldprofile::TraversalStats* ts = 
	        (amdb_wkldprofile::TraversalStats *) (*it).second;

	    switch (statsType) {
	    case traversals:
	        statsCopy[pageno] = (float) ts->traversalCnt;
		break;
	    case retrievals:
	        statsCopy[pageno] = (float) ts->retrievalCnt;
		break;
	    case emptySubtrees:
	        statsCopy[pageno] = (float) ts->emptySubtree;
		break;
	    default: assert(0); // this isn't right
	    }
	}

	if (queryNo != 0) {
	    // get rid of tsMap
	    amdb_wkldprofile::clearTraversalStatsMap(*tsMap);
	    delete tsMap;
	}
    }

    // extract from amdb_wkldstats::NodeStats
    if (statsType == clusterLoss || statsType == clusterOh ||
        statsType == utilLoss || statsType == utilOh ||
	statsType == excCovLoss || statsType == excCovOh) {

	assert(Gist_analysis != NULL);
	assert(target.wkldStats != NULL);

	amdb_wkldstats::NodeStatsMap* nsMap;
	if (queryNo == 0) {
	    // we want totals
	    nsMap = &target.wkldStats->nodeStats;
	} else {
	    nsMap = new amdb_wkldstats::NodeStatsMap();
	    target.wkldStats->createNodeStats(queryNo, *target.profile,
	        *target.map, Gist_analysis->parameters, *nsMap);
	}

	amdb_wkldstats::NodeStatsMap::const_iterator it;
	for (it = nsMap->begin(); it != nsMap->end(); it++) {
	    shpid_t pageno = (shpid_t) (*it).first;
	    amdb_wkldstats::NodeStats* ns = 
	        (amdb_wkldstats::NodeStats *) (*it).second;

	    switch (statsType) {
	    case clusterLoss:
	        statsCopy[pageno] =
		    (minStats ? ns->minClusterLoss : ns->optClusterLoss);
		break;
	    case clusterOh:
	        statsCopy[pageno] =
		    (minStats ? ns->minClusterOh : ns->optClusterOh);
		break;
	    case utilLoss:
	        statsCopy[pageno] = ns->utilLoss;
		break;
	    case utilOh:
	        statsCopy[pageno] = ns->utilOh;
		break;
	    case excCovLoss:
	        statsCopy[pageno] = ns->excCovLoss;
		break;
	    case excCovOh:
	        statsCopy[pageno] = ns->excCovOh;
		break;
	    default: assert(0); // this isn't right
	    }
	}

	if (queryNo != 0) {
	    // get rid of tsMap
	    amdb_wkldstats::clearNodeStatsMap(*nsMap);
	    delete nsMap;
	}
    }

    // extract from amdb_treemap::PageInfo
    if (statsType == nodeUtil || statsType == slotCnt ||
        statsType == predSize) {

	if (_treeMap == NULL) {
	    // not computed yet
	    _treeMap = new amdb_treemap();
	    Gist_gist->computeTreeMap(_treeMap);
	}

	amdb_treemap::PageMap::const_iterator it;
	for (it = _treeMap->pageMap.begin(); it != _treeMap->pageMap.end(); it++) {

	    shpid_t pageno = (shpid_t) (*it).first;
	    amdb_treemap::PageInfo* info =
	        (amdb_treemap::PageInfo *) (*it).second;

	    switch (statsType) {
	    case nodeUtil:
	        statsCopy[pageno] = info->util;
		break;
	    case slotCnt:
	        statsCopy[pageno] = (float) info->itemCnt;
		break;
	    case predSize:
	        statsCopy[pageno] = info->avgPredLen;
		break;
	    default: assert(0); // this isn't right
	    }
	}
    }

    env->ReleaseFloatArrayElements(stats, statsCopy, 0);
}


///////////////////////////////////////////////////////////////////////////////
// libGetSplitNodeStats - return amdb_splitstats node stats
//
// Description:
//	- only set those array elements that correspond to leaves,
//	  leave rest unchanged
//
// Exceptions: none
//
///////////////////////////////////////////////////////////////////////////////

// corresponds to constants in Gist.java
enum SplitStatsTypes {
    clustLossStats = 0,
    excCovLossStats,
    clustSuccessStats,
    excCovSuccessStats,
    optClustDeltaStats,
    actualClustDeltaStats,
    excCovDeltaStats,
    numSplitStatsTypes
};

JNIEXPORT void JNICALL
Java_Libgist_libGetSplitNodeStats(
    JNIEnv* env,
    jclass cl,
    jint statsType,
    jboolean delta,
    jboolean weighted,
    jfloatArray statsArray)
{
    DBGPRINT(1, cout << "libGetSplitNodeStats()" << endl);
    jsize statsSize = env->GetArrayLength(statsArray);
    if (statsSize < Gist_gist->pageCount()) {
        cerr << "statsSize < pageCount (" << statsSize << " < " << 
	    Gist_gist->pageCount() << ")" << endl;
        assert(statsSize >= Gist_gist->pageCount());
    }
    jfloat* statsCopy = env->GetFloatArrayElements(statsArray, NULL);

    // initialize stats array to statsType-specific value
    int initVal[numSplitStatsTypes] = {
        0, 0, 0, 0, 0, 0, 0
    };
    int i;
    for (i = 0; i < statsSize; i++) {
        statsCopy[i] = initVal[statsType];
    }

    // for now, we only deal with the actual tree
    assert(Gist_analysis != NULL);
    amdb_analysis::TreeAnalysis& target = Gist_analysis->actualAnalysis;
    assert(target.splitStats != NULL);
    assert(target.map != NULL);

    amdb_splitstats::SplitStatsMap::const_iterator it;
    amdb_splitstats::FullSplitStats stats;
    for (it = target.splitStats->splitStats.begin();
        it != target.splitStats->splitStats.end(); it++) {

	shpid_t pageno = (shpid_t) (*it).first;
	DBGPRINT(3, cout << "pageno " << pageno << endl);
	amdb_splitstats::SplitStats* st =
	    (amdb_splitstats::SplitStats *) (*it).second;
	assert(st != NULL);
        // compute display values
	stats.set(*st, Gist_analysis->parameters.targetUtil,
	    target.map->util(pageno));

	switch (statsType) {
	case clustLossStats:
	    statsCopy[pageno] = stats.clusterLoss(weighted);
	    break;
	case excCovLossStats:
	    statsCopy[pageno] = stats.excCovLoss();
	    break;
	case clustSuccessStats:
	    statsCopy[pageno] = stats.clusterSuccess(weighted);
	    break;
	case excCovSuccessStats:
	    statsCopy[pageno] = stats.excCovSuccess();
	    break;
	case optClustDeltaStats:
	    statsCopy[pageno] = stats.optClusterDelta(weighted);
	    break;
	case actualClustDeltaStats:
	    statsCopy[pageno] = stats.actualClusterDelta(weighted);
	    break;
	case excCovDeltaStats:
	    statsCopy[pageno] =
	        (float) (stats.actualExcCovLoss - stats.preExcCovLoss);;
	    break;

	default: assert(0); // this isn't right
	}
    }
    env->ReleaseFloatArrayElements(statsArray, statsCopy, 0);
}


///////////////////////////////////////////////////////////////////////////////
// libGetAnalysisInfo - set fields in  Java AnalysisInfo
//
// Description:
//
// Exception:
//	OutOfMemoryError
///////////////////////////////////////////////////////////////////////////////

// return Java ProfileParams
JNIEXPORT void JNICALL
Java_Libgist_libGetAnalysisInfo(
    JNIEnv* env,
    jclass cl,
    jobject info)
{
    DBGPRINT(1, cout << "libGetProfileParams()" << endl);
    assert(Gist_analysis != NULL);

    if (Gist_analysis->actualAnalysis.filename != NULL) {
	jobject str = env->NewStringUTF(Gist_analysis->actualAnalysis.filename);
	HANDLEEXC(env);
	env->SetObjectField(info, Gist_aiActualNameId, str);
    }
    env->SetBooleanField(info, Gist_aiActualHasWkldStatsId,
        (jboolean) (Gist_analysis->actualAnalysis.wkldStats != NULL));
    env->SetBooleanField(info, Gist_aiActualHasSplitStatsId,
        (jboolean) (Gist_analysis->actualAnalysis.splitStats != NULL));
    env->SetBooleanField(info, Gist_aiActualHasPenaltyStatsId,
        (jboolean) (Gist_analysis->actualAnalysis.penaltyStats != NULL));
    if (Gist_analysis->optAnalysis.filename != NULL) {
	jobject str = env->NewStringUTF(Gist_analysis->optAnalysis.filename);
	HANDLEEXC(env);
	env->SetObjectField(info, Gist_aiOptNameId, str);
    }
    env->SetBooleanField(info, Gist_aiOptHasWkldStatsId,
        (jboolean) (Gist_analysis->optAnalysis.wkldStats != NULL));
    env->SetBooleanField(info, Gist_aiOptHasSplitStatsId,
        (jboolean) (Gist_analysis->optAnalysis.splitStats != NULL));
    env->SetBooleanField(info, Gist_aiOptHasPenaltyStatsId,
        (jboolean) (Gist_analysis->optAnalysis.penaltyStats != NULL));
    env->SetIntField(info, Gist_aiRandomRunsId, Gist_analysis->parameters.randomRuns);
    env->SetFloatField(info, Gist_aiTargetUtilId, Gist_analysis->parameters.targetUtil);
    if (Gist_analysis->queryFile != NULL) {
	jobject str = env->NewStringUTF(Gist_analysis->queryFile);
	HANDLEEXC(env);
	env->SetObjectField(info, Gist_aiQueryFileId, str);
    }
    env->SetIntField(info, Gist_aiNumQueriesId,
        Gist_analysis->actualAnalysis.profile->queries.size());
    env->SetIntField(info, Gist_aiNumRetrievedId,
        Gist_analysis->actualAnalysis.profile->statsTotals.dataCoverage);
    env->SetIntField(info, Gist_aiNumItemsId,
        Gist_analysis->actualAnalysis.map->itemMap.size());

}


///////////////////////////////////////////////////////////////////////////////
// libGetQueryStats  -
//	return Java QueryStats for individual query or totals
//
// Description:
//
///////////////////////////////////////////////////////////////////////////////

JNIEXPORT void JNICALL
Java_Libgist_libGetQueryStats(
    JNIEnv* env,
    jclass cl,
    jint queryNo,
    jobject s)
{
    DBGPRINT(1, cout << "libGetQueryStats()" << endl);
    assert(Gist_analysis != NULL);
    assert(Gist_analysis->actualAnalysis.profile != NULL);
    assert((unsigned) queryNo <=
        Gist_analysis->actualAnalysis.profile->queries.size());
    amdb_wkldprofile::QueryStats* pqs;
    amdb_wkldstats::QueryStats* qs;
    amdb_analysis::TreeAnalysis& target = Gist_analysis->actualAnalysis;

    if (queryNo == 0) {
	// no resultSetLimit or qual
        // we want cumulative stats
	env->SetIntField(s, Gist_qsResultSetSizeId,
	    target.profile->statsTotals.retrievedCnt);
	pqs = &target.profile->statsTotals.stats;
	qs = &target.wkldStats->statsTotals;
    } else {
	amdb_wkldprofile::Query* query =
	    (amdb_wkldprofile::Query *) target.profile->queries[queryNo-1];
	assert(query != NULL);
	env->SetIntField(s, Gist_qsResultSetLimitId, query->retrLimit);
	stringBufferAppend(env, env->GetObjectField(s, Gist_qsQualId), query->qual);
	env->SetIntField(s, Gist_qsResultSetSizeId, (int) query->resultSetSize);
	pqs = &query->stats;
	qs = (amdb_wkldstats::QueryStats *)
	    target.wkldStats->queryStats[queryNo-1];
	//cout << "query->resultSet->size(): " << query->resultSetSize << endl;
    }
    assert(pqs != NULL); // we need those 

    env->SetFloatField(s, Gist_qsAvgUtilId, pqs->leafStats.avgUtil);
    env->SetIntField(s, Gist_qsRetrievalVolId, pqs->leafStats.retrievalVol);
    env->SetIntField(s, Gist_qsTotalLeafIosId, pqs->leafStats.totalIos);