/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeExportAction * * @param ackAction true if this call contains an ack * @param pollAction true if this call requests a poll * @param syncAction true if the stream offset being set for a table * @param ackOffset if acking, the universal stream offset being acked/released * @param tableSignature Signature of the table to which the Export action applies * * @return the universal stream offset for the last octet in any * returned poll results (returned via the query results buffer). On * any error this will be less than 0. For any call with no * pollAction, any value >= 0 may be ignored. */ SHAREDLIB_JNIEXPORT jlong JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeExportAction (JNIEnv *env, jobject obj, jlong engine_ptr, jboolean syncAction, jlong ackOffset, jlong seqNo, jbyteArray tableSignature) { VOLT_DEBUG("nativeExportAction in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); jbyte *signatureChars = env->GetByteArrayElements(tableSignature, NULL); std::string signature(reinterpret_cast<char *>(signatureChars), env->GetArrayLength(tableSignature)); env->ReleaseByteArrayElements(tableSignature, signatureChars, JNI_ABORT); try { try { engine->resetReusedResultOutputBuffer(); return engine->exportAction(syncAction, static_cast<int64_t>(ackOffset), static_cast<int64_t>(seqNo), signature); } catch (SQLException e) { throwFatalException("%s", e.message().c_str()); } } catch (FatalException e) { topend->crashVoltDB(e); } return 0; }
/* * Serialize more tuples to one or more output streams. * Returns a long for the remaining tuple count, -1 when done, or -2 for an error. * Streams an int position array through the reused result buffer. * Class: org_voltdb_jni_ExecutionEngine * Method: nativeTableStreamSerializeMore * Signature: (JII[B)J; */ SHAREDLIB_JNIEXPORT jlong JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeTableStreamSerializeMore (JNIEnv *env, jobject obj, jlong engine_ptr, jint tableId, jint streamType, jbyteArray serialized_buffers) { VOLT_DEBUG("nativeTableStreamSerializeMore in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); jsize length = env->GetArrayLength(serialized_buffers); VOLT_DEBUG("nativeTableStreamSerializeMore: deserializing %d buffer bytes ...", (int) length); jbyte *bytes = env->GetByteArrayElements(serialized_buffers, NULL); ReferenceSerializeInput serialize_in(bytes, length); try { try { voltdb::TableStreamType tst = static_cast<voltdb::TableStreamType>(streamType); jlong tuplesRemaining = engine->tableStreamSerializeMore(tableId, tst, serialize_in); return tuplesRemaining; } catch (const SQLException &e) { throwFatalException("%s", e.message().c_str()); } } catch (const FatalException &e) { topend->crashVoltDB(e); } // Won't get here, but -2 is an error. return -2; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeGetUSOForExportTable * Signature: (JLjava/lang/String;)[J */ SHAREDLIB_JNIEXPORT jlongArray JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeGetUSOForExportTable (JNIEnv *env, jobject obj, jlong engine_ptr, jbyteArray tableSignature) { VOLT_DEBUG("nativeGetUSOForExportTable in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); jbyte *signatureChars = env->GetByteArrayElements(tableSignature, NULL); std::string signature(reinterpret_cast<char *>(signatureChars), env->GetArrayLength(tableSignature)); env->ReleaseByteArrayElements(tableSignature, signatureChars, JNI_ABORT); try { jlong data[2]; size_t ackOffset; int64_t seqNo; engine->getUSOForExportTable(ackOffset, seqNo, signature); data[0] = ackOffset; data[1] = seqNo; jlongArray retval = env->NewLongArray(2); env->SetLongArrayRegion(retval, 0, 2, data); return retval; } catch (FatalException e) { topend->crashVoltDB(e); } return NULL; }
/** * Executes a plan fragment with the given parameter set. * @param engine_ptr the VoltDBEngine pointer * @param plan_fragment_id ID of the plan fragment to be executed. * @return error code */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeExecutePlanFragment ( JNIEnv *env, jobject obj, jlong engine_ptr, jlong plan_fragment_id, jint outputDependencyId, jint inputDependencyId, jlong txnId, jlong lastCommittedTxnId, jlong undoToken) { VOLT_DEBUG("nativeExecutePlanFragment() start"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); assert(engine); try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated engine->setUndoToken(undoToken); engine->resetReusedResultOutputBuffer(); NValueArray ¶ms = engine->getParameterContainer(); Pool *stringPool = engine->getStringPool(); const int paramcnt = deserializeParameterSet(engine->getParameterBuffer(), engine->getParameterBufferCapacity(), params, engine->getStringPool()); engine->setUsedParamcnt(paramcnt); const int retval = engine->executeQuery(plan_fragment_id, outputDependencyId, inputDependencyId, params, txnId, lastCommittedTxnId, true, true); stringPool->purge(); return retval; } catch (FatalException e) { topend->crashVoltDB(e); } return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; }
/** * Sets (or re-sets) the buffer shared between java and the EE. This is for reducing * cost of GetDirectBufferAddress(). * @param pointer the VoltDBEngine pointer * @param parameter_buffer direct byte buffer to be set * @param m_parameterBuffersize size of the buffer * @param result_buffer direct byte buffer to be set * @param result_buffer_size size of the buffer * @param exception_buffer direct byte buffer to be set * @param exception_buffer_size size of the buffer * @return error code */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeSetBuffers (JNIEnv *env, jobject obj, jlong engine_ptr, jobject parameter_buffer, jint parameter_buffer_size, jobject result_buffer, jint result_buffer_size, jobject exception_buffer, jint exception_buffer_size) { VOLT_DEBUG("nativeSetBuffers() start"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) { return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated char *parameterBuffer = reinterpret_cast<char*>( env->GetDirectBufferAddress(parameter_buffer)); int parameterBufferCapacity = parameter_buffer_size; char *reusedResultBuffer = reinterpret_cast<char*>( env->GetDirectBufferAddress(result_buffer)); int reusedResultBufferCapacity = result_buffer_size; char *exceptionBuffer = reinterpret_cast<char*>( env->GetDirectBufferAddress(exception_buffer)); int exceptionBufferCapacity = exception_buffer_size; engine->setBuffers(parameterBuffer, parameterBufferCapacity, reusedResultBuffer, reusedResultBufferCapacity, exceptionBuffer, exceptionBufferCapacity); } catch (FatalException e) { topend->crashVoltDB(e); } return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; }
/** * Serialize the result temporary table. * @param engine_ptr the VoltDBEngine pointer * @param table_id Id of the table to be serialized * @return serialized temporary table */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeSerializeTable( JNIEnv *env, jobject obj, jlong engine_ptr, jint table_id, jobject output_buffer, jint output_capacity) { //VOLT_DEBUG("nativeSerializeTable() start"); VoltDBEngine *engine = castToEngine(engine_ptr); if (engine == NULL) { VOLT_ERROR("The VoltDBEngine pointer is null!"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated void* data = env->GetDirectBufferAddress(output_buffer); ReferenceSerializeOutput out(data, output_capacity); bool success = engine->serializeTable(table_id, &out); if (!success) return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; else return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; } catch (FatalException e) { topend->crashVoltDB(e); } return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; }
SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeAntiCacheReadBlocks ( JNIEnv *env, jobject obj, jlong engine_ptr, jint tableId, jshortArray blockIdsArray) { int retval = org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; VOLT_DEBUG("nativeAntiCacheReadBlocks() start"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) return (retval); try { jsize numBlockIds = env->GetArrayLength(blockIdsArray); jshort *_blockIds = env->GetShortArrayElements(blockIdsArray, NULL); if (_blockIds == NULL) { VOLT_ERROR("No evicted blockIds were given to the EE"); return (retval); } // XXX: Is this necessary? uint16_t *blockIds = new uint16_t[numBlockIds]; for (int ii = 0; ii < numBlockIds; ii++) { blockIds[ii] = _blockIds[ii]; } // FOR retval = engine->antiCacheReadBlocks(static_cast<int32_t>(tableId), static_cast<int>(numBlockIds), blockIds); } catch (FatalException e) { topend->crashVoltDB(e); } return (retval); }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeExportAction * * @param ackAction true if this call contains an ack * @param pollAction true if this call requests a poll * @param syncAction true if the stream offset being set for a table * @param ackOffset if acking, the universal stream offset being acked/released * @param tableId the table ID to which the Export action applies * * @return the universal stream offset for the last octet in any * returned poll results (returned via the query results buffer). On * any error this will be less than 0. For any call with no * pollAction, any value >= 0 may be ignored. */ SHAREDLIB_JNIEXPORT jlong JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeExportAction (JNIEnv *env, jobject obj, jlong engine_ptr, jboolean ackAction, jboolean pollAction, jboolean resetAction, jboolean syncAction, jlong ackOffset, jlong seqNo, jlong tableId) { VOLT_DEBUG("nativeExportAction in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { try { engine->resetReusedResultOutputBuffer(); return engine->exportAction(ackAction, pollAction, resetAction, syncAction, static_cast<int64_t>(ackOffset), static_cast<int64_t>(seqNo), static_cast<int64_t>(tableId)); } catch (SQLException e) { throwFatalException("%s", e.message().c_str()); } } catch (FatalException e) { topend->crashVoltDB(e); } return 0; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeTableStreamSerializeMore * Signature: (JJIIII)I */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeTableStreamSerializeMore (JNIEnv *env, jobject obj, jlong engine_ptr, jlong bufferPtr, jint offset, jint length, jint tableId, jint streamType) { VOLT_DEBUG("nativeTableStreamSerializeMore in C++ called"); ReferenceSerializeOutput out(reinterpret_cast<char*>(bufferPtr) + offset, length - offset); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { try { return engine->tableStreamSerializeMore( &out, tableId, static_cast<voltdb::TableStreamType>(streamType)); } catch (SQLException e) { throwFatalException("%s", e.message().c_str()); } } catch (FatalException e) { topend->crashVoltDB(e); } return 0; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeActivateTableStream * Signature: (JIII[B)Z */ SHAREDLIB_JNIEXPORT jboolean JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeActivateTableStream( JNIEnv *env, jobject obj, jlong engine_ptr, jint tableId, jint streamType, jbyteArray serialized_predicates) { VOLT_DEBUG("nativeActivateTableStream in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); // deserialize predicates. jsize length = env->GetArrayLength(serialized_predicates); VOLT_DEBUG("deserializing %d predicate bytes ...", (int) length); jbyte *bytes = env->GetByteArrayElements(serialized_predicates, NULL); ReferenceSerializeInput serialize_in(bytes, length); try { try { voltdb::TableStreamType tableStreamType = static_cast<voltdb::TableStreamType>(streamType); bool success = engine->activateTableStream(tableId, tableStreamType, serialize_in); env->ReleaseByteArrayElements(serialized_predicates, bytes, JNI_ABORT); VOLT_DEBUG("deserialized predicates (success=%d)", (int)success); return success; } catch (SerializableEEException &e) { engine->resetReusedResultOutputBuffer(); e.serialize(engine->getExceptionOutputSerializer()); } } catch (const FatalException& e) { topend->crashVoltDB(e); } return false; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeLoadPlanFragment * Signature: (JJ[B)I */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeLoadPlanFragment ( JNIEnv *env, jobject obj, jlong engine_ptr, jbyteArray plan) { VOLT_DEBUG("nativeUnloadPlanFragment() start"); // setup VoltDBEngine *engine = castToEngine(engine_ptr); assert(engine); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); //JNIEnv pointer can change between calls, must be updated updateJNILogProxy(engine); // convert java plan string to stdc++ string plan jbyte *str = env->GetByteArrayElements(plan, NULL); assert(str); // get the buffer to write results to engine->resetReusedResultOutputBuffer(); ReferenceSerializeOutput* out = engine->getResultOutputSerializer(); // output from the engine's loadFragment method int64_t fragId = 0; bool wasHit = 0; int64_t cacheSize = 0; // load int result = 1; try { result = engine->loadFragment(reinterpret_cast<char *>(str), env->GetArrayLength(plan), fragId, wasHit, cacheSize); } catch (FatalException e) { topend->crashVoltDB(e); } assert((result == 1) || (fragId != 0)); // release plan memory env->ReleaseByteArrayElements(plan, str, JNI_ABORT); // write results back to java out->writeLong(fragId); out->writeBool(wasHit); out->writeLong(cacheSize); if (result == 1) return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; else return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeTick * Signature: (JJJ)V * * Called roughly every 1 second by the Java Runtime to allow the EE to do * periodic non-transactional work. * * @param env Pointer to the JNIEnv for this thread * @param obj Pointer to the object on which this method was called * @param engine_ptr Pointer to a VoltDBEngine instance * @param timeInMillis The current java timestamp (System.currentTimeMillis()); * @param lastCommittedSpHandle The id of the last committed transaction. */ SHAREDLIB_JNIEXPORT void JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeTick (JNIEnv *env, jobject obj, jlong engine_ptr, jlong timeInMillis, jlong lastCommittedSpHandle) { VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated engine->tick(timeInMillis, lastCommittedSpHandle); } catch (FatalException e) { topend->crashVoltDB(e); } }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeActivateTableStream * Signature: (JII)Z */ SHAREDLIB_JNIEXPORT jboolean JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeActivateTableStream (JNIEnv *env, jobject obj, jlong engine_ptr, jint tableId, jint streamType) { VOLT_DEBUG("nativeActivateTableStream in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { return engine->activateTableStream(tableId, static_cast<voltdb::TableStreamType>(streamType)); } catch (FatalException e) { topend->crashVoltDB(e); } return false; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeQuiesce * Signature: (JJ)V * * Called to instruct the EE to reach an idle steady state. */ SHAREDLIB_JNIEXPORT void JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeQuiesce (JNIEnv *env, jobject obj, jlong engine_ptr, jlong lastCommittedTxnId) { VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { // JNIEnv pointer can change between calls, must be updated updateJNILogProxy(engine); engine->quiesce(lastCommittedTxnId); } catch (FatalException e) { topend->crashVoltDB(e); } }
/** * Initializes the execution engine with given parameter. * @param enginePtr the VoltDBEngine pointer to be initialized * @param clusterId id of the cluster the execution engine belongs to * @param nodeId this id will be set to the execution engine * @return error code */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeInitialize( JNIEnv *env, jobject obj, jlong enginePtr, jint clusterIndex, jlong siteId, jint partitionId, jint hostId, jbyteArray hostname, jlong tempTableMemory, jint hashinatorType, jbyteArray hashinatorConfig) { VOLT_DEBUG("nativeInitialize() start"); VoltDBEngine *engine = castToEngine(enginePtr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) { VOLT_ERROR("engine_ptr was NULL or invalid pointer"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated jbyte *hostChars = env->GetByteArrayElements( hostname, NULL); std::string hostString(reinterpret_cast<char*>(hostChars), env->GetArrayLength(hostname)); env->ReleaseByteArrayElements( hostname, hostChars, JNI_ABORT); jbyte *hashinatorConfigData = env->GetByteArrayElements(hashinatorConfig, NULL); // initialization is separated from constructor so that constructor // never fails. VOLT_DEBUG("calling initialize..."); bool success = engine->initialize(clusterIndex, siteId, partitionId, hostId, hostString, tempTableMemory, (HashinatorType)hashinatorType, (char*)hashinatorConfigData); env->ReleaseByteArrayElements( hashinatorConfig, hashinatorConfigData, JNI_ABORT); if (success) { VOLT_DEBUG("initialize succeeded"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; } else { throwFatalException("initialize failed"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } } catch (const FatalException &e) { topend->crashVoltDB(e); } return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; }
/** * Class: org_voltdb_jni_ExecutionEngine * Method: nativeGetStats * Signature: (I[I)Z * * Called to retrieve statistics * * @param env Pointer to the JNIEnv for this thread * @param obj Pointer to the object on which this method was called * @param engine_ptr Pointer to a VoltDBEngine instance * @param selector Ordinal value from StatisticsSelectorType enum indicating the type of stats to retrieve * @param locatorsArray Java array of CatalogIds indicating what set of sources should the statistics be retrieved from. * @return Number of result tables, 0 on no results, -1 on failure. */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeGetStats(JNIEnv *env, jobject obj, jlong pointer, jint selector, jintArray locatorsArray, jboolean jinterval, jlong now) { VoltDBEngine *engine = castToEngine(pointer); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); /* * Can't use the standard JNI EE error code here because this method * actually uses that integer to indicate the number of result tables. */ int result = -1; //JNIEnv pointer can change between calls, must be updated updateJNILogProxy(engine); engine->resetReusedResultOutputBuffer(); /* * Retrieve locators if any */ int *locators = NULL; int numLocators = 0; if (locatorsArray != NULL) { locators = env->GetIntArrayElements(locatorsArray, NULL); if (locators == NULL) { env->ExceptionDescribe(); return JNI_FALSE; } numLocators = env->GetArrayLength(locatorsArray); if (env->ExceptionCheck()) { env->ExceptionDescribe(); env->ReleaseIntArrayElements(locatorsArray, locators, JNI_ABORT); return JNI_FALSE; } } const bool interval = jinterval == JNI_TRUE ? true : false; try { result = engine->getStats(static_cast<int>(selector), locators, numLocators, interval, now); } catch (FatalException e) { topend->crashVoltDB(e); } env->ReleaseIntArrayElements(locatorsArray, locators, JNI_ABORT); return static_cast<jint>(result); }
/* * Executes a plan fragment of an adhoc query. * Class: org_voltdb_jni_ExecutionEngine * Method: nativeExecuteCustomPlanFragment * Signature: (JLjava/lang/String;JJJ)I */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeExecuteCustomPlanFragment ( JNIEnv *env, jobject obj, jlong engine_ptr, jstring plan, jint outputDependencyId, jint inputDependencyId, jlong txnId, jlong lastCommittedTxnId, jlong undoToken) { int retval = org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; VOLT_DEBUG("nativeExecuteCustomPlanFragment() start"); // setup VoltDBEngine *engine = castToEngine(engine_ptr); assert(engine); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); //JNIEnv pointer can change between calls, must be updated updateJNILogProxy(engine); engine->resetReusedResultOutputBuffer(); engine->setUndoToken(undoToken); static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); Pool *stringPool = engine->getStringPool(); // convert java plan string to stdc++ string plan const char *str = static_cast<const char*>(env->GetStringUTFChars(plan, NULL)); assert(str); string cppplan = str; env->ReleaseStringUTFChars(plan, str); // execute engine->setUsedParamcnt(0); try { retval = engine->executePlanFragment(cppplan, outputDependencyId, inputDependencyId, txnId, lastCommittedTxnId); } catch (FatalException e) { topend->crashVoltDB(e); } // cleanup stringPool->purge(); return retval; }
/** * Initializes the execution engine with given parameter. * @param enginePtr the VoltDBEngine pointer to be initialized * @param clusterId id of the cluster the execution engine belongs to * @param nodeId this id will be set to the execution engine * @return error code */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeInitialize( JNIEnv *env, jobject obj, jlong enginePtr, jint clusterIndex, jlong siteId, jint partitionId, jint hostId, jstring hostname, jlong tempTableMemory, jint totalPartitions) { VOLT_DEBUG("nativeInitialize() start"); VoltDBEngine *engine = castToEngine(enginePtr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) { VOLT_ERROR("engine_ptr was NULL or invalid pointer"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated const char *hostChars = env->GetStringUTFChars( hostname, NULL); std::string hostString(hostChars); env->ReleaseStringUTFChars( hostname, hostChars); // initialization is separated from constructor so that constructor // never fails. VOLT_DEBUG("calling initialize..."); bool success = engine->initialize(clusterIndex, siteId, partitionId, hostId, hostString, tempTableMemory, totalPartitions); if (success) { VOLT_DEBUG("initialize succeeded"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; } else { throwFatalException("initialize failed"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } } catch (FatalException e) { topend->crashVoltDB(e); } return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeSetLogLevels * Signature: (JJ)Z */ SHAREDLIB_JNIEXPORT jboolean JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeSetLogLevels (JNIEnv *env, jobject obj, jlong engine_ptr, jlong logLevels) { VOLT_DEBUG("nativeSetLogLevels in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated if (engine) { engine->getLogManager()->setLogLevels(logLevels); } return JNI_FALSE; } catch (FatalException e) { topend->crashVoltDB(e); } return false; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeTableHashCode * Signature: (JI)J */ SHAREDLIB_JNIEXPORT jlong JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeTableHashCode (JNIEnv *env, jobject obj, jlong engine_ptr, jint tableId) { VOLT_DEBUG("nativeTableHashCode in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { try { return engine->tableHashCode(tableId); } catch (SQLException e) { throwFatalException("%s", e.message().c_str()); } } catch (FatalException e) { topend->crashVoltDB(e); } return 0; }
/** * Release the undo token * @returns JNI_TRUE on success. JNI_FALSE otherwise. */ SHAREDLIB_JNIEXPORT jboolean JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeReleaseUndoToken (JNIEnv *env, jobject obj, jlong engine_ptr, jlong undoToken) { VOLT_DEBUG("nativeReleaseUndoToken in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated if (engine) { engine->releaseUndoToken(undoToken); return JNI_TRUE; } } catch (FatalException e) { topend->crashVoltDB(e); } return JNI_FALSE; }
JNIEXPORT void JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeExecuteTask (JNIEnv *env, jobject obj, jlong engine_ptr) { VOLT_DEBUG("nativeHashinate in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); assert(engine); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated engine->resetReusedResultOutputBuffer(); ReferenceSerializeInput input(engine->getParameterBuffer(), engine->getParameterBufferCapacity()); TaskType taskId = static_cast<TaskType>(input.readLong()); engine->executeTask(taskId, engine->getParameterBuffer() + sizeof(int64_t)); } catch (const FatalException &e) { topend->crashVoltDB(e); } }
void signalHandler(int signum, siginfo_t *info, void *context) { if (currentVM == NULL || currentEngine == NULL) return; char err_msg[128]; snprintf(err_msg, 128, "SIGSEGV caught: signal number %d, error value %d," " signal code %d\n\n", info->si_signo, info->si_errno, info->si_code); std::string message = err_msg; message.append(currentEngine->debug()); JNIEnv *env; if (currentVM->AttachCurrentThread((void **)(void *)&env, NULL) != 0) exit(-1); Topend *topend = static_cast<JNITopend*>(currentEngine->getTopend())->updateJNIEnv(env); topend->crashVoltDB(SegvException(message.c_str(), context, __FILE__, __LINE__)); currentVM->DetachCurrentThread(); }
/** * This method is called to initially load table data. * @param pointer the VoltDBEngine pointer * @param table_id catalog ID of the table * @param serialized_table the table data to be loaded */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeLoadTable ( JNIEnv *env, jobject obj, jlong engine_ptr, jint table_id, jbyteArray serialized_table, jlong spHandle, jlong lastCommittedSpHandle, jboolean returnUniqueViolations, jlong undoToken) { VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) { return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } engine->resetReusedResultOutputBuffer(); engine->setUndoToken(undoToken); //JNIEnv pointer can change between calls, must be updated updateJNILogProxy(engine); VOLT_DEBUG("loading table %d in C++...", table_id); // deserialize dependency. jsize length = env->GetArrayLength(serialized_table); VOLT_DEBUG("deserializing %d bytes ...", (int) length); jbyte *bytes = env->GetByteArrayElements(serialized_table, NULL); ReferenceSerializeInput serialize_in(bytes, length); try { try { bool success = engine->loadTable(table_id, serialize_in, spHandle, lastCommittedSpHandle, returnUniqueViolations); env->ReleaseByteArrayElements(serialized_table, bytes, JNI_ABORT); VOLT_DEBUG("deserialized table"); if (success) return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; } catch (const SerializableEEException &e) { engine->resetReusedResultOutputBuffer(); e.serialize(engine->getExceptionOutputSerializer()); } } catch (const FatalException &e) { topend->crashVoltDB(e); } return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeUpdateHashinator * Signature: (JI)I */ SHAREDLIB_JNIEXPORT void JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeUpdateHashinator(JNIEnv *env, jobject obj, jlong engine_ptr) { VOLT_DEBUG("nativeUpdateHashinator in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); assert(engine); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated NValueArray& params = engine->getParameterContainer(); Pool *stringPool = engine->getStringPool(); deserializeParameterSet(engine->getParameterBuffer(), engine->getParameterBufferCapacity(), params, engine->getStringPool()); HashinatorType hashinatorType = static_cast<HashinatorType>(voltdb::ValuePeeker::peekAsInteger(params[0])); const char *configValue = static_cast<const char*>(voltdb::ValuePeeker::peekObjectValue(params[1])); engine->updateHashinator(hashinatorType, configValue); stringPool->purge(); } catch (const FatalException &e) { topend->crashVoltDB(e); } }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeProcessRecoveryMessage * Signature: (JJII)V */ SHAREDLIB_JNIEXPORT void JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeProcessRecoveryMessage (JNIEnv *env, jobject obj, jlong engine_ptr, jlong buffer_ptr, jint offset, jint remaining) { //ProfilerEnable(); VOLT_DEBUG("nativeProcessRecoveryMessage in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); char *data = reinterpret_cast<char*>(buffer_ptr) + offset; try { if (data == NULL) { throwFatalException("Failed to get byte array elements of recovery message"); } ReferenceSerializeInput input(data, remaining); RecoveryProtoMsg message(&input); return engine->processRecoveryMessage(&message); } catch (FatalException e) { topend->crashVoltDB(e); } //ProfilerDisable(); }
SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeAntiCacheMergeBlocks ( JNIEnv *env, jobject obj, jlong engine_ptr, jint tableId) { int retval = org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; VOLT_DEBUG("nativeAntiCacheMergeBlocks() start"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) return (retval); try { retval = engine->antiCacheMergeBlocks(static_cast<int32_t>(tableId)); } catch (FatalException e) { topend->crashVoltDB(e); } return (retval); }
/** * Load the system catalog for this engine. * @param engine_ptr the VoltDBEngine pointer * @param serialized_catalog the root catalog object serialized as text strings. * human-readable text strings separated by line feeds. * @return error code */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeUpdateCatalog( JNIEnv *env, jobject obj, jlong engine_ptr, jlong timestamp, jbyteArray catalog_diffs) { VOLT_DEBUG("nativeUpdateCatalog() start"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) { VOLT_ERROR("engine_ptr was NULL or invalid pointer"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } //JNIEnv pointer can change between calls, must be updated updateJNILogProxy(engine); //copy to std::string. utf_chars may or may not by a copy of the string jbyte* utf_chars = env->GetByteArrayElements(catalog_diffs, NULL); string str(reinterpret_cast<char*>(utf_chars), env->GetArrayLength(catalog_diffs)); env->ReleaseByteArrayElements(catalog_diffs, utf_chars, JNI_ABORT); VOLT_DEBUG("calling loadCatalog..."); try { bool success = engine->updateCatalog( timestamp, str); if (success) { VOLT_DEBUG("updateCatalog succeeded"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; } } catch (const SerializableEEException &e) { engine->resetReusedResultOutputBuffer(); e.serialize(engine->getExceptionOutputSerializer()); } catch (const FatalException &fe) { if (topend != NULL) { topend->crashVoltDB(fe); } } VOLT_ERROR("updateCatalog failed"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; }
SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeAntiCacheEvictBlock ( JNIEnv *env, jobject obj, jlong engine_ptr, jint tableId, jlong blockSize) { int retval = -1; VOLT_DEBUG("nativeAntiCacheEvictBlocks() start"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) return (retval); engine->resetReusedResultOutputBuffer(); try { retval = engine->antiCacheEvictBlock(static_cast<int32_t>(tableId), static_cast<long>(blockSize)); } catch (FatalException e) { topend->crashVoltDB(e); } return (retval); }
/** * Enables the anti-cache feature in the EE. * This can only be called *after* the buffers have been initialized * but *before* the catalog has been initialized * @param pointer the VoltDBEngine pointer * @param dbDir the directory of where the EE should store the anti-cache database * @return error code */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeAntiCacheInitialize ( JNIEnv *env, jobject obj, jlong engine_ptr, jstring dbDir) { VOLT_DEBUG("nativeAntiCacheInitialize() start"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) { return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } try { const char *dbDirChars = env->GetStringUTFChars(dbDir, NULL); std::string dbDirString(dbDirChars); env->ReleaseStringUTFChars(dbDir, dbDirChars); engine->antiCacheInitialize(dbDirString); } catch (FatalException e) { topend->crashVoltDB(e); } return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; }