libgist.cc~

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

    if (bp->event == amdb_breakpoints::insertEvent) {
	if (strcmp(param1, "") != 0) {
	    bp->param.updateParam.key =
	        strcpy((char *) malloc(strlen(param1) + 1), param1);
	} else {
	    bp->param.updateParam.key = NULL;
	}
	if (strcmp(param2, "") != 0) {
	    bp->param.updateParam.data =
	        strcpy((char *) malloc(strlen(param2) + 1), param2);
	} else {
	    bp->param.updateParam.data = NULL;
	}
	//printf("insert: key=%s, data=%s\n", bp->param.updateParam.key,
	    //bp->param.updateParam.data);
    }

    env->ReleaseStringUTFChars(param1String, param1);
    env->ReleaseStringUTFChars(param2String, param2);
}

// create new breakpoint and return its ID
JNIEXPORT void JNICALL
Java_Libgist_libCreateBp(
    JNIEnv* env,
    jclass cl,
    jobject jbp)
{
    Gist_bpCounter++;
    amdb_breakpoints::Breakpoint *bp = new amdb_breakpoints::Breakpoint();
    convertBreakpoint(bp, jbp, env);
    env->SetIntField(jbp, Gist_bpIdId, bp->id);
    if (bp->node == 0 || amdb_breakpoints::isEntryPoint(bp->event)) {
        // general breakpoint, for no particular node
	BpVect& vect = genBps[bp->event];
	vect.push_back(bp);
	//printf("new vect bp (%d): %d, %d\n", bp, bp->event, bp->node);
    } else {
        // applies to node
	BpMap& map = nodeBps[bp->event];
	map.insert(BpPair(bp->node, bp));
	//printf("new map bp (%d): %d, %d\n", bp, bp->event, bp->node);
    }
}

// get rid of all breakpoints
JNIEXPORT void JNICALL
Java_Libgist_libDeleteBps(
    JNIEnv* env,
    jclass cl)
{
    // empty all vectors/multimaps; also delete the Breakpoint objects
    int i;
    for (i = 0; i < amdb_breakpoints::numEvents; i++) {
	BpVect::iterator it;
	for (it = genBps[i].begin(); it != genBps[i].end(); it++) {
	    amdb_breakpoints::Breakpoint* bp = *it;
	    if (bp->event == amdb_breakpoints::insertEvent) {
	        free(bp->param.updateParam.key);
	        free(bp->param.updateParam.data);
	    }
	    delete bp;
	}
	BpMap::iterator mit;
	for (mit = nodeBps[i].begin(); mit != nodeBps[i].end(); mit++) {
	    amdb_breakpoints::Breakpoint* bp = (*mit).second;
	    if (bp->event == amdb_breakpoints::insertEvent) {
	        free(bp->param.updateParam.key);
	        free(bp->param.updateParam.data);
	    }
	    delete bp;
	}
        genBps[i].erase(genBps[i].begin(), genBps[i].end());
	nodeBps[i].erase(nodeBps[i].begin(), nodeBps[i].end());
    }
    Gist_bpCounter = 0; // start from 0 again
}

JNIEXPORT void JNICALL
Java_Libgist_libSingleStep(
    JNIEnv *env,
    jclass cl)
{
    Gist_whatNow = nowStep;
}

JNIEXPORT void JNICALL
Java_Libgist_libDisableAll(
    JNIEnv *env,
    jclass cl,
    jboolean disable)
{
    printf("all disabled: %d\n", (disable ? 1 : 0));
    Gist_allDisabled = disable;
}

// initialize Gist_infoObj with an amdb_breakpoints::BreakInfo structure
static jobject
createBreakInfo(
    amdb_breakpoints::BreakInfo* info,
    int id)
{
    printf("new BreakInfo\n");
    if (Gist_infoObj == NULL) {
	jobject infoObj = Gist_env->NewObject(Gist_breakInfoClass, Gist_breakInfoConstrId);
	Gist_infoObj = Gist_env->NewGlobalRef(infoObj);
    }
    jobject& result = Gist_infoObj;
    Gist_env->SetIntField(result, Gist_biIdId, id);
    Gist_env->SetIntField(result, Gist_biEventId, info->event);
    Gist_env->SetIntField(result, Gist_biNodeId, (int) info->node);
    if (info->event == amdb_breakpoints::locateLeafEvent) {
	Gist_env->SetDoubleField(result, Gist_biTargetPenaltyId,
	    info->param.locateLeafParam.targetPenalty);
	Gist_env->SetDoubleField(result, Gist_biMinPenaltyId,
	    info->param.locateLeafParam.minPenalty);
	Gist_env->SetIntField(result, Gist_biMinLeafId,
	    info->param.locateLeafParam.minLeaf);
    }
    printf("id=%d, event=%d, node=%d\n", id, info->event, info->node);
    return result;
}

// Test whether the break info triggers the given breakpoint. If it does, call the 
// Java break handler and set whatNow. If no breakpoint is specified, the handler
// is also called.
static bool
testBp(
    amdb_breakpoints::Breakpoint* bp,
    amdb_breakpoints::BreakInfo* info,
    WhatToDo& whatNow)
{
    bool triggersBp = true;
    int bpId = 0; // set to ID of the breakpoint, if it was triggered
    if (bp != NULL) {
	// locateLeaf: check if insertion penalty deviates too much from minimum
	int maxDev = bp->param.penaltyParam.maxDeviation;
	bpId = bp->id;
        if (bp->event == amdb_breakpoints::locateLeafEvent && maxDev != -1) {
	    triggersBp = (info->param.locateLeafParam.targetPenalty /
	        info->param.locateLeafParam.minPenalty) >   
		(1.0 + (double) maxDev / 100.0);
	}
    }
    if (triggersBp) {
	jobject infoObj = createBreakInfo(info, bpId);
	//HANDLEEXCR(Gist_env, false);
	whatNow = (WhatToDo) Gist_env->CallIntMethod(Gist_handler, Gist_handlerId, infoObj);
	//HANDLEEXCR(Gist_env, false);
	return true;
    } else {
        return false;
    }
}

// the C++ breakpoint handler, called from within libgist;
// returns true if the currently executing libgist interface function should
// be cancelled (because the user is tired of executing a script)
static bool
breakHandler(
    amdb_breakpoints::BreakInfo* info)
{

    // see if event signals a structure change
    if (amdb_breakpoints::isStructureUpdate(info->event)) {
	switch (info->event) { 
	case amdb_breakpoints::newNodeEvent: {
	    Gist_indexStruct->splitNode(info->param.newNodeParam.origNode,
		info->param.newNodeParam.rightSib,
		info->param.newNodeParam.rightChildren);
	    break;
	}
	case amdb_breakpoints::newRootEvent: {
	    Gist_indexStruct->splitRoot(info->param.newRootParam.leftNode,
		info->param.newRootParam.rightNode,
		info->param.newRootParam.rightChildren);
	    break;
	}
	case amdb_breakpoints::relocateChildEvent: {
	    Gist_indexStruct->splitRoot(info->param.newRootParam.leftNode,
		info->param.newRootParam.rightNode,
		info->param.newRootParam.rightChildren);
	    break;
	}
	case amdb_breakpoints::itemInsertedEvent:
	case amdb_breakpoints::itemDeletedEvent:
	case amdb_breakpoints::bpUpdatedEvent: {
	    // cout << "Node changed: " << info->param.updNodeParam << endl;
	    Gist_indexStruct->updateNode(info->param.updNodeParam);
	    break;
	}
	default: 
	    assert(0);
	}
	// structure has changed: this invalidates existing tree map
	delete _treeMap;
	_treeMap = NULL;
        // return false;
    }

    if (Gist_whatNow == nowStep) {
        // we're single-stepping
	(void) testBp(NULL, info, Gist_whatNow);
	HANDLEEXCR(Gist_env, false);
	return (Gist_whatNow == nowCancel);
    }
    if (Gist_allDisabled) {
        return false;
    }
    if (Gist_whatNow == nowNext && amdb_breakpoints::isEntryPoint(info->event)) {
        // we stop at the beginning of every interface function
	(void) testBp(NULL, info, Gist_whatNow);
	HANDLEEXCR(Gist_env, false);
	return (Gist_whatNow == nowCancel);
    }

    // see if we hit any breakpoints
    BpVect& vect = genBps[info->event];
    // check the general breakpoint(s)
    int i;
    for (i = 0; i < 2; i++) {
	// two rounds: first with original event...
	BpVect::iterator it;
	for (it = vect.begin(); it != vect.end(); it++) {
	    bool triggeredBp = testBp(vect.front(), info, Gist_whatNow);
	    HANDLEEXCR(Gist_env, false);
	    if (triggeredBp) { return Gist_whatNow == nowCancel; }
	}
	// .. the second with a traversalEvent instead of the locateLeafEvent
	if (info->event == amdb_breakpoints::locateLeafEvent) {
	    // Locating an insertion target leaf implies a node traversal, therefore
	    // all (more general) traversalEvent breakpoints also apply to (more specific)
	    // locateLeafEvents
	    vect = genBps[amdb_breakpoints::traversalEvent];
	} else {
	    // skip the 2nd round if no locateLeafEvent
	    break;
	}
    }

    // check the node-specific breakpoints
    BpMap& map = nodeBps[info->event];
    for (i = 0; i < 2; i++) {
        // two rounds again
	BpMap::iterator it;
	for (it = map.find(info->node); it != map.end(); it++) {
	    bool triggeredBp = testBp((*it).second, info, Gist_whatNow);
	    HANDLEEXCR(Gist_env, false);
	    if (triggeredBp) { return Gist_whatNow == nowCancel; }
	}
	if (info->event == amdb_breakpoints::locateLeafEvent) {
	    // Locating an insertion target leaf implies a node traversal, therefore
	    // all (more general) traversalEvent breakpoints also apply to (more specific)
	    // locateLeafEvents
	    map = nodeBps[amdb_breakpoints::traversalEvent];
	} else {
	    // skip the 2nd round if no locateLeafEvent
	    break;
	}
    }

    return false;
}

// determine class object and handler routine ID for later reference
JNIEXPORT void JNICALL
Java_Libgist_libSetBreakHandler(
    JNIEnv *env,
    jclass cl,
    jobject handler)
{
    Gist_handler = env->NewGlobalRef(handler);
    if (Gist_handler == NULL) {
        ERRORRETURN("out of memory");
    }
    jclass handlerClass = env->GetObjectClass(handler);
    Gist_handlerClass = (jclass) env->NewGlobalRef(handlerClass);
    if (Gist_handlerClass == NULL) {
        ERRORRETURN("out of memory");
    }
    Gist_handlerId = env->GetMethodID(Gist_handlerClass, "breakHandler", "(LBreakInfo;)I");
    HANDLEEXC(env);
}


/*
 * Libgist interface functions
 */

// precompute a couple of class and method IDs
JNIEXPORT void JNICALL
Java_Libgist_libInit(
    JNIEnv *env,
    jclass cl)
{
    Gist_gist->setBreakHandler(breakHandler);

    // get global ref to StringBuffer method ID
    DBGPRINT(3, cout << "find StringBuffer" << endl);
    //DBGPRINT(3, cout << "find StringBuffer" << endl);
    jclass stringBufferClass = env->FindClass("java/lang/StringBuffer");
    HANDLEEXC(env);
    DBGPRINT(3, cout << "found StringBuffer" << endl);
    Gist_stringBufferClass = (jclass) env->NewGlobalRef(stringBufferClass);
    Gist_sbAppendId = env->GetMethodID(Gist_stringBufferClass, "append",
        "(Ljava/lang/String;)Ljava/lang/StringBuffer;");
    HANDLEEXC(env);

    // get global ref to JTextArea method ID
    DBGPRINT(3, cout << "find JTextArea" << endl);
    jclass jTextAreaClass = env->FindClass("javax/swing/JTextArea");
    HANDLEEXC(env);
    DBGPRINT(3, cout << "found JTextArea" << endl);
    Gist_jTextAreaClass = (jclass) env->NewGlobalRef(jTextAreaClass);
    Gist_taAppendId = env->GetMethodID(Gist_jTextAreaClass, "append", "(Ljava/lang/String;)V");
    HANDLEEXC(env);

    // get global ref to File class and constructor
    DBGPRINT(3, cout << "find File" << endl);
    jclass fileClass = env->FindClass("java/io/File");
    HANDLEEXC(env);
    DBGPRINT(3, cout << "found File" << endl);
    Gist_fileClass = (jclass) env->NewGlobalRef(fileClass);
    Gist_fInitId = env->GetMethodID(Gist_fileClass, "<init>", "(Ljava/lang/String;)V");
    HANDLEEXC(env);

    // get global ref to Breakpoint class and field IDs
    jclass bpClass = env->FindClass("Breakpoint");
    HANDLEEXC(env);
    Gist_breakpointClass = (jclass) env->NewGlobalRef(bpClass);
    //Gist_breakpointConstrId = env->GetMethodID(Gist_breakpointClass, "<init>", "()V");
    //HANDLEEXC(env);
    Gist_bpIdId = env->GetFieldID(Gist_breakpointClass, "id", "I");
    HANDLEEXC(env);
    Gist_bpEventId = env->GetFieldID(Gist_breakpointClass, "event", "I");
    HANDLEEXC(env);
    Gist_bpNodeId = env->GetFieldID(Gist_breakpointClass, "nodeId", "I");
    HANDLEEXC(env);
    Gist_bpParam1Id = env->GetFieldID(Gist_breakpointClass, "param1", "Ljava/lang/String;");
    HANDLEEXC(env);
    Gist_bpParam2Id = env->GetFieldID(Gist_breakpointClass, "param1", "Ljava/lang/String;");
    HANDLEEXC(env);

    // get global ref to BreakInfo class and field IDs
    jclass biClass = env->FindClass("BreakInfo");
    HANDLEEXC(env);
    Gist_breakInfoClass = (jclass) env->NewGlobalRef(biClass);
    Gist_breakInfoConstrId = env->GetMethodID(Gist_breakInfoClass, "<init>", "()V");
    HANDLEEXC(env);
    Gist_biIdId = env->GetFieldID(Gist_breakInfoClass, "id", "I");
    HANDLEEXC(env);
    Gist_biEventId = env->GetFieldID(Gist_breakInfoClass, "event", "I");
    HANDLEEXC(env);
    Gist_biNodeId = env->GetFieldID(Gist_breakInfoClass, "nodeId", "I");
    HANDLEEXC(env);
    Gist_biTargetPenaltyId = env->GetFieldID(Gist_breakInfoClass, "targetPenalty", "D");
    HANDLEEXC(env);
    Gist_biMinPenaltyId = env->GetFieldID(Gist_breakInfoClass, "minPenalty", "D");
    HANDLEEXC(env);
    Gist_biMinLeafId = env->GetFieldID(Gist_breakInfoClass, "minLeaf", "I");
    HANDLEEXC(env);
    //jobject infoObj = Gist_env->NewObject(Gist_breakInfoClass, Gist_breakInfoConstrId);
    //Gist_infoObj = env->NewGlobalRef(infoObj);

    // get global ref to QueryStats class
    jclass queryStatsClass = env->FindClass("QueryStats");
    HANDLEEXC(env);
    Gist_queryStatsClass = (jclass) env->NewGlobalRef(queryStatsClass);
    Gist_qsResultSetLimitId = env->GetFieldID(Gist_queryStatsClass,
        "resultSetLimit", "I");
    HANDLEEXC(env);
    Gist_qsQualId = env->GetFieldID(Gist_queryStatsClass, "qual",
        "Ljava/lang/StringBuffer;");
    HANDLEEXC(env);
    Gist_qsResultSetSizeId = env->GetFieldID(Gist_queryStatsClass, "resultSetSize", "I");
    HANDLEEXC(env);
    Gist_qsAvgUtilId = env->GetFieldID(Gist_queryStatsClass, "avgUtil", "F");
    HANDLEEXC(env);
    Gist_qsRetrievalVolId = env->GetFieldID(Gist_queryStatsClass, "retrievalVol", "I");
    HANDLEEXC(env);
    Gist_qsTotalLeafIosId = env->GetFieldID(Gist_queryStatsClass, "totalLeafIos", "I");
    HANDLEEXC(env);
    Gist_qsMinIosId = env->GetFieldID(Gist_queryStatsClass, "minIos", "I");
    HANDLEEXC(env);
    Gist_qsOptimalIosId = env->GetFieldID(Gist_queryStatsClass, "optimalIos", "I");
    HANDLEEXC(env);
    Gist_qsOptimalOhId = env->GetFieldID(Gist_queryStatsClass, "optimalOh", "F");
    HANDLEEXC(env);
    Gist_qsOptLeafOhId = env->GetFieldID(Gist_queryStatsClass, "optLeafOh", "F");
    HANDLEEXC(env);
    Gist_qsMinLeafOhId = env->GetFieldID(Gist_queryStatsClass, "minLeafOh", "F");
    HANDLEEXC(env);
    Gist_qsRandomIosId = env->GetFieldID(Gist_queryStatsClass, "randomIos", "F");
    HANDLEEXC(env);
    Gist_qsRandomStdDevId = env->GetFieldID(Gist_queryStatsClass, "randomStdDev", "F");
    HANDLEEXC(env);
    Gist_qsOptRandomOhId = env->GetFieldID(Gist_queryStatsClass, "optRandomOh", "F");
    HANDLEEXC(env);
    Gist_qsMinRandomOhId = env->GetFieldID(Gist_queryStatsClass, "minRandomOh", "F");
    HANDLEEXC(env);
    Gist_qsOptClusterLossId = env->GetFieldID(Gist_queryStatsClass, "optClusterLoss", "F");
    HANDLEEXC(env);
    Gist_qsMinClusterLossId = env->GetFieldID(Gist_queryStatsClass, "minClusterLoss", "F");
    HANDLEEXC(env);
    Gist_qsOptClusterOhId = env->GetFieldID(Gist_queryStatsClass, "optClusterOh", "F");
    HANDLEEXC(env);
    Gist_qsMinClusterOhId = env->GetFieldID(Gist_queryStatsClass, "minClusterOh", "F");
    HANDLEEXC(env);
    Gist_qsLeafUtilLossId = env->GetFieldID(Gist_queryStatsClass, "leafUtilLoss", "F");
    HANDLEEXC(env);
    Gist_qsUtilOhId = env->GetFieldID(Gist_queryStatsClass, "utilOh", "F");
    HANDLEEXC(env);
    Gist_qsLeafExcCovLossId = env->GetFieldID(Gist_queryStatsClass, "leafExcCovLoss", "F");
    HANDLEEXC(env);
    Gist_qsExcCovOhId = env->GetFieldID(Gist_queryStatsClass, "excCovOh", "F");