libgist.cc~

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

    HANDLEEXC(env);
    Gist_qsTotalInternalIosId = env->GetFieldID(Gist_queryStatsClass,
        "totalInternalIos", "I");
    HANDLEEXC(env);
    Gist_qsInternalUtilLossId = env->GetFieldID(Gist_queryStatsClass,
        "internalUtilLoss", "F");
    HANDLEEXC(env);
    Gist_qsInternalExcCovLossId = env->GetFieldID(Gist_queryStatsClass,
        "internalExcCovLoss", "F");
    HANDLEEXC(env);

    // get global ref to AnalysisInfo class
    DBGPRINT(3, cout << "find AnalysisInfo" << endl);
    jclass analysisInfoClass = env->FindClass("AnalysisInfo");
    HANDLEEXC(env);
    DBGPRINT(3, cout << "found AnalysisInfo" << endl);
    Gist_analysisInfoClass = (jclass) env->NewGlobalRef(analysisInfoClass);
    Gist_aiActualNameId = env->GetFieldID(Gist_analysisInfoClass, "actualName",
        "Ljava/lang/String;");
    HANDLEEXC(env);
    Gist_aiActualHasWkldStatsId = env->GetFieldID(Gist_analysisInfoClass,
        "actualHasWkldStats", "Z");
    HANDLEEXC(env);
    Gist_aiActualHasSplitStatsId = env->GetFieldID(Gist_analysisInfoClass,
        "actualHasSplitStats", "Z");
    HANDLEEXC(env);
    Gist_aiActualHasPenaltyStatsId = env->GetFieldID(Gist_analysisInfoClass,
        "actualHasPenaltyStats", "Z");
    HANDLEEXC(env);
    Gist_aiOptNameId = env->GetFieldID(Gist_analysisInfoClass, "optName",
        "Ljava/lang/String;");
    HANDLEEXC(env);
    Gist_aiOptHasWkldStatsId = env->GetFieldID(Gist_analysisInfoClass,
        "optHasWkldStats", "Z");
    HANDLEEXC(env);
    Gist_aiOptHasSplitStatsId = env->GetFieldID(Gist_analysisInfoClass,
        "optHasSplitStats", "Z");
    HANDLEEXC(env);
    Gist_aiOptHasPenaltyStatsId = env->GetFieldID(Gist_analysisInfoClass,
        "optHasPenaltyStats", "Z");
    HANDLEEXC(env);
    Gist_aiRandomRunsId = env->GetFieldID(Gist_analysisInfoClass, "randomRuns", "I");
    HANDLEEXC(env);
    Gist_aiTargetUtilId = env->GetFieldID(Gist_analysisInfoClass, "targetUtil", "F");
    HANDLEEXC(env);
    Gist_aiQueryFileId = env->GetFieldID(Gist_analysisInfoClass, "queryFile",
        "Ljava/lang/String;");
    HANDLEEXC(env);
    Gist_aiNumQueriesId = env->GetFieldID(Gist_analysisInfoClass, "numQueries", "I");
    HANDLEEXC(env);
    Gist_aiNumRetrievedId = env->GetFieldID(Gist_analysisInfoClass, "numRetrieved", "I");
    HANDLEEXC(env);
    Gist_aiNumItemsId = env->GetFieldID(Gist_analysisInfoClass, "numItems", "I");
    HANDLEEXC(env);

    // get global ref to LibgistCommand class
    DBGPRINT(3, cout << "find LibgistCommand" << endl);
    jclass libgistCommandClass = env->FindClass("LibgistCommand");
    HANDLEEXC(env);
    DBGPRINT(3, cout << "found LibgistCommand" << endl);
    Gist_libgistCommandClass = (jclass) env->NewGlobalRef(libgistCommandClass);
    Gist_lcCmdTypeId = env->GetFieldID(Gist_libgistCommandClass, "cmdType", "I");
    HANDLEEXC(env);
    Gist_lcFetchLimitId = env->GetFieldID(Gist_libgistCommandClass, "fetchLimit", "I");
    HANDLEEXC(env);
    Gist_lcQualId = env->GetFieldID(Gist_libgistCommandClass, "qual",
        "Ljava/lang/StringBuffer;");
    HANDLEEXC(env);
    Gist_lcKeyId = env->GetFieldID(Gist_libgistCommandClass, "key",
        "Ljava/lang/StringBuffer;");
    HANDLEEXC(env);
    Gist_lcDataId = env->GetFieldID(Gist_libgistCommandClass, "data",
        "Ljava/lang/StringBuffer;");
    HANDLEEXC(env);
    Gist_lcIndexNameId = env->GetFieldID(Gist_libgistCommandClass, "indexName",
        "Ljava/lang/StringBuffer;");
    HANDLEEXC(env);
    Gist_lcExtensionId = env->GetFieldID(Gist_libgistCommandClass, "data",
        "Ljava/lang/StringBuffer;");
    HANDLEEXC(env);
    Gist_lcFillFactorId = env->GetFieldID(Gist_libgistCommandClass, "fillFactor", "F");
    HANDLEEXC(env);
    Gist_lcLoadFileId = env->GetFieldID(Gist_libgistCommandClass,
        "loadFile", "Ljava/lang/StringBuffer;");
    HANDLEEXC(env);
    Gist_lcScriptFileId = env->GetFieldID(Gist_libgistCommandClass,
        "scriptFile", "Ljava/lang/StringBuffer;");
    HANDLEEXC(env);
    Gist_lcAnalysisFileId = env->GetFieldID(Gist_libgistCommandClass,
        "analysisFile", "Ljava/io/File;");
    HANDLEEXC(env);
    Gist_lcNumRandomRunsId = env->GetFieldID(Gist_libgistCommandClass,
        "numRandomRuns", "I");
    HANDLEEXC(env);

    DBGPRINT(3, cout << "find DisplayPredInfo" << endl);
    jclass displayPredInfoClass = env->FindClass("DisplayPredInfo");
    HANDLEEXC(env);
    DBGPRINT(3, cout << "found DisplayPredInfo" << endl);
    Gist_displayPredInfoClass =
        (jclass) env->NewGlobalRef(displayPredInfoClass);
    Gist_dpiNodeId = env->GetFieldID(Gist_displayPredInfoClass, "node", "I");
    HANDLEEXC(env);
    Gist_dpiSlotId = env->GetFieldID(Gist_displayPredInfoClass, "slot", "I");
    HANDLEEXC(env);
    Gist_dpiLevelId = env->GetFieldID(Gist_displayPredInfoClass, "level", "I");
    HANDLEEXC(env);
    Gist_dpiColorId = env->GetFieldID(Gist_displayPredInfoClass, "color", "I");
    HANDLEEXC(env);

    // get global ref to SplitStats class
    DBGPRINT(3, cout << "find SplitStats" << endl);
    jclass splitStatsClass = env->FindClass("SplitStats");
    HANDLEEXC(env);
    DBGPRINT(3, cout << "found SplitStats" << endl);
    Gist_splitStatsClass = (jclass) env->NewGlobalRef(splitStatsClass);
    Gist_ssPreIosId = env->GetFieldID(Gist_splitStatsClass, "preIos", "F");
    HANDLEEXC(env);
    Gist_ssOptIosId = env->GetFieldID(Gist_splitStatsClass, "optIos", "F");
    HANDLEEXC(env);
    Gist_ssActualIosId = env->GetFieldID(Gist_splitStatsClass, "actualIos", "F");
    HANDLEEXC(env);
    Gist_ssPreExcCovLossId = env->GetFieldID(Gist_splitStatsClass, "preExcCovLoss",
        "F");
    HANDLEEXC(env);
    Gist_ssActualExcCovLossId = env->GetFieldID(Gist_splitStatsClass,
        "actualExcCovLoss", "F");
    HANDLEEXC(env);
    Gist_ssOptClusterDeltaId = env->GetFieldID(Gist_splitStatsClass,
        "optClusterDelta", "F");
    HANDLEEXC(env);
    Gist_ssActualClusterDeltaId = env->GetFieldID(Gist_splitStatsClass,
        "actualClusterDelta", "F");
    HANDLEEXC(env);
    Gist_ssClusterLossId = env->GetFieldID(Gist_splitStatsClass,
        "clusterLoss", "F");
    HANDLEEXC(env);
    Gist_ssClusterOhId = env->GetFieldID(Gist_splitStatsClass,
        "clusterOh", "F");
    HANDLEEXC(env);
    Gist_ssClusterSuccessId = env->GetFieldID(Gist_splitStatsClass,
        "clusterSuccess", "F");
    HANDLEEXC(env);
    Gist_ssExcCovDeltaId = env->GetFieldID(Gist_splitStatsClass,
        "excCovDelta", "F");
    HANDLEEXC(env);
    Gist_ssExcCovLossId = env->GetFieldID(Gist_splitStatsClass,
        "excCovLoss", "F");
    HANDLEEXC(env);
    Gist_ssExcCovOhId = env->GetFieldID(Gist_splitStatsClass,
        "excCovOh", "F");
    HANDLEEXC(env);
    Gist_ssExcCovSuccessId = env->GetFieldID(Gist_splitStatsClass,
        "excCovSuccess", "F");
    HANDLEEXC(env);

    // get global ref to PenaltyStats class
    DBGPRINT(3, cout << "find PenaltyStats" << endl);
    jclass penaltyStatsClass = env->FindClass("PenaltyStats");
    HANDLEEXC(env);
    DBGPRINT(3, cout << "found PenaltyStats" << endl);
    Gist_penaltyStatsClass = (jclass) env->NewGlobalRef(penaltyStatsClass);
    Gist_psActualAddIosId = env->GetFieldID(Gist_penaltyStatsClass, "actualAddIos", "F");
    HANDLEEXC(env);
    Gist_psOptAddIosId = env->GetFieldID(Gist_penaltyStatsClass, "optAddIos", "F");
    HANDLEEXC(env);
    Gist_psActualExcCovId = env->GetFieldID(Gist_penaltyStatsClass, "actualExcCov", "F");
    HANDLEEXC(env);
    Gist_psExcCovDeltaId = env->GetFieldID(Gist_penaltyStatsClass, "excCovDelta", "F");
    HANDLEEXC(env);
    Gist_psClusterLossId = env->GetFieldID(Gist_penaltyStatsClass, "clusterLoss", "F");
    HANDLEEXC(env);
    Gist_psExcCovOhId = env->GetFieldID(Gist_penaltyStatsClass, "excCovOh", "F");
    HANDLEEXC(env);
    Gist_psExcCovSuccessId = env->GetFieldID(Gist_penaltyStatsClass, "excCovSuccess", "F");
    HANDLEEXC(env);
    Gist_psKeyId = env->GetFieldID(Gist_penaltyStatsClass, "key", "Ljava/lang/String;");
    HANDLEEXC(env);

}

JNIEXPORT jobjectArray JNICALL
Java_Libgist_libGetExtensionInfo(
    JNIEnv *env,
    jclass cl)
{
    jclass extInfoClass;
    jobjectArray extArray;
    jobject extInfo;
    jmethodID initMethod;
    const char *name;
    int id;

    extInfoClass = env->FindClass("ExtensionInfo");
    HANDLEEXCR(env, NULL);
    assert(extInfoClass);
    extArray = env->NewObjectArray(gist_ext_t::gist_numext, extInfoClass, NULL);
    HANDLEEXCR(env, NULL);
    assert(extArray);
    initMethod = env->GetMethodID(extInfoClass, "<init>", "(Ljava/lang/String;I)V");
    HANDLEEXCR(env, NULL);
    int i;
    for (i = 0; i < gist_ext_t::gist_numext; i++) {
        // construct the new ExtInfo object
	DBGPRINT(3, cout << "ext_list[" << i << "]: " << gist_ext_t::gist_ext_list[i] << endl);
	name = gist_ext_t::gist_ext_list[i]->myName;
	id = gist_ext_t::gist_ext_list[i]->myId;
	extInfo = env->NewObject(extInfoClass, initMethod, env->NewStringUTF(name), id);
	HANDLEEXCR(env, NULL);
	env->SetObjectArrayElement(extArray, i, extInfo);
	HANDLEEXCR(env, NULL);
    }

    //printf("x finished!\n");
    return extArray;
}

JNIEXPORT void JNICALL
Java_Libgist_libCreate(
    JNIEnv *env,
    jclass cl,
    jstring fileName,
    jint extId)
{
    DBGPRINT(1, cout << "libCreate()" << endl);
    const char* fname = env->GetStringUTFChars(fileName, NULL);
    //printf("creating: %s with %s\n", fname, gist_ext_t::gist_ext_list[extId]->myName);
    Gist_env = env;
    rc_t status = Gist_gist->create(fname, gist_ext_t::gist_ext_list[extId]);
    CHECKSTATUS(status, env, "gist::create failed");

    // remember the filename, in case we need to copy the file
    free(Gist_filename);
    Gist_filename = strdup(fname);

    // create a main-memory representation of the index structure
    delete Gist_indexStruct;
    Gist_indexStruct = new amdb_idxstruct(Gist_gist);

    env->ReleaseStringUTFChars(fileName, fname);
}


///////////////////////////////////////////////////////////////////////////////
// libOppen - open index, create amdb_idxstruct_t and reset treemap
//
// Description:
//
// Exceptions:
//      LibgistException
///////////////////////////////////////////////////////////////////////////////

JNIEXPORT void JNICALL
Java_Libgist_libOpen(
    JNIEnv *env,
    jclass cl,
    jstring fileName)
{
    DBGPRINT(1, cout << "libOpen()" << endl);
    const char* fname = env->GetStringUTFChars(fileName, NULL);
    cout << "opening: " << fname << endl;
    if (Gist_gist != NULL) {
        Java_Libgist_libClose(env, cl);
    }
    Gist_env = env;
    rc_t status = Gist_gist->open(fname);
    CHECKSTATUS(status, env, "gist::open failed");

    // remember the filename, in case we need to copy the file
    free(Gist_filename);
    Gist_filename = strdup(fname);

    // create a main-memory representation of the index structure
    delete Gist_indexStruct;
    Gist_indexStruct = new amdb_idxstruct(Gist_gist);

    // reset nodeStats to force recomputation
    delete _treeMap;
    _treeMap = NULL;

    env->ReleaseStringUTFChars(fileName, fname);
}


///////////////////////////////////////////////////////////////////////////////
// libCleanup - close index and analysis and free associated resources
//
// Description:
//
// Exceptions:
//      LibgistException
///////////////////////////////////////////////////////////////////////////////

JNIEXPORT void JNICALL
Java_Libgist_libCleanup(
    JNIEnv* env,
    jclass cl)
{
    if (Gist_analysis != NULL) {
	Java_Libgist_libCloseAnalysis(env, cl);
    }
    if (Gist_gist != NULL) {
        Java_Libgist_libClose(env, cl);
    }
}


///////////////////////////////////////////////////////////////////////////////
// libOpenAnalysis - allocate and read analysis
//
// Description:
//
// Exceptions:
//      LibgistException
///////////////////////////////////////////////////////////////////////////////

JNIEXPORT void JNICALL
Java_Libgist_libOpenAnalysis(
    JNIEnv *env,
    jclass cl,
    jstring name)
{
    DBGPRINT(1, cout << "libOpenAnalysis()" << endl);
    const char* fname = env->GetStringUTFChars(name, NULL);
    cout << "opening analysis: " << fname << endl;
    if (Gist_analysis != NULL) {
	Java_Libgist_libCloseAnalysis(env, cl);
    }
    Gist_analysis = new amdb_analysis();
    rc_t status = Gist_analysis->read(fname);
    CHECKSTATUS(status, env, "amdb_analysis::read() failed");

    // remember the filename in order to be able to write it back later
    free(Gist_analysisname);
    Gist_analysisname = strdup(fname);

    env->ReleaseStringUTFChars(name, fname);
    DBGPRINT(1, cout << "exit libOpenAnalysis()" << endl);
}


///////////////////////////////////////////////////////////////////////////////
// libClose - close index and free associated resources
//
// Description:
//
// Exceptions:
//      LibgistException
///////////////////////////////////////////////////////////////////////////////

JNIEXPORT void JNICALL
Java_Libgist_libClose(
    JNIEnv *env,
    jclass cl)
{
    DBGPRINT(1, cout << "libClose()" << endl);
    //printf("closing\n");
    Gist_env = env;
    rc_t status = Gist_gist->close();
    CHECKSTATUS(status, env, "gist::close failed");

    free(Gist_filename);
    Gist_filename = NULL;
    delete Gist_indexStruct;
    Gist_indexStruct = NULL;
    delete _treeMap;
    _treeMap = NULL;
    DBGPRINT(1, cout << "exit libClose()" << endl);
}


///////////////////////////////////////////////////////////////////////////////
// libWriteAnalysis - write analysis back to file
//
// Description:
// Exceptions: LibgistException
//
///////////////////////////////////////////////////////////////////////////////

JNIEXPORT void JNICALL
Java_Libgist_libWriteAnalysis(
    JNIEnv *env,
    jclass cl)
{
    DBGPRINT(1, cout << "libWriteAnalysis()" << endl);
    //printf("closing\n");
    assert(Gist_analysis != NULL);
    rc_t status = Gist_analysis->write(Gist_analysisname, false);
    CHECKSTATUS(status, env, "amdb_analysis::write() failed");
}


///////////////////////////////////////////////////////////////////////////////
// libCloseAnalysis - deallocate analysis
//
// Description:
// Exceptions: LibgistException
//
///////////////////////////////////////////////////////////////////////////////

JNIEXPORT void JNICALL
Java_Libgist_libCloseAnalysis(
    JNIEnv *env,
    jclass cl)
{
    DBGPRINT(1, cout << "libCloseAnalysis()" << endl);
    free(Gist_analysisname);
    Gist_analysisname = NULL;
    delete Gist_analysis;
    Gist_analysis = NULL;
}

JNIEXPORT void JNICALL
Java_Libgist_libFlush(
    JNIEnv *env,