void CmdInterpreter::beginTxn(ProxyBeginTxnCmd &cmd, bool readOnly, TxnId csn)
{
assert(readOnly || csn == NULL_TXN_ID);
// block checkpoints during this method
DbHandle *pDbHandle = getDbHandle(cmd.getDbHandle());
SharedDatabase pDb = pDbHandle->pDb;
SXMutexSharedGuard actionMutexGuard(
pDb->getCheckpointThread()->getActionMutex());
std::auto_ptr<TxnHandle> pTxnHandle(newTxnHandle());
JniUtil::incrementHandleCount(TXNHANDLE_TRACE_TYPE_STR, pTxnHandle.get());
pTxnHandle->pDb = pDb;
pTxnHandle->readOnly = readOnly;
// TODO: CacheAccessor factory
pTxnHandle->pTxn = pDb->getTxnLog()->newLogicalTxn(pDb->getCache());
pTxnHandle->pResourceGovernor = pDbHandle->pResourceGovernor;
// NOTE: use a null scratchAccessor; individual ExecStreamGraphs
// will have their own
SegmentAccessor scratchAccessor;
pTxnHandle->pFtrsTableWriterFactory = SharedFtrsTableWriterFactory(
new FtrsTableWriterFactory(
pDb,
pDb->getCache(),
pDb->getTypeFactory(),
scratchAccessor));
// If snapshots are enabled, set up 2 snapshot segments -- one of which
// only reads committed data. This will be used for streams that need to
// read a snapshot of the data before other portions of the stream graph
// have modified the segment.
if (pDb->areSnapshotsEnabled()) {
if (csn == NULL_TXN_ID) {
csn = pTxnHandle->pTxn->getTxnId();
}
pTxnHandle->pSnapshotSegment =
pDb->getSegmentFactory()->newSnapshotRandomAllocationSegment(
pDb->getDataSegment(),
pDb->getDataSegment(),
csn,
false);
pTxnHandle->pReadCommittedSnapshotSegment =
pDb->getSegmentFactory()->newSnapshotRandomAllocationSegment(
pDb->getDataSegment(),
pDb->getDataSegment(),
csn,
true);
} else {
assert(csn == NULL_TXN_ID);
}
setTxnHandle(cmd.getResultHandle(), pTxnHandle.release());
}
void CmdInterpreter::visit(ProxyCmdCreateExecutionStreamGraph &cmd)
{
#if 0
struct mallinfo minfo = mallinfo();
std::cout << "Number of allocated bytes before stream graph construction = "
<< minfo.uordblks << " bytes" << std::endl;
#endif
TxnHandle *pTxnHandle = getTxnHandle(cmd.getTxnHandle());
SharedDatabase pDb = pTxnHandle->pDb;
SharedExecStreamGraph pGraph =
ExecStreamGraph::newExecStreamGraph();
pGraph->setTxn(pTxnHandle->pTxn);
pGraph->setResourceGovernor(pTxnHandle->pResourceGovernor);
std::auto_ptr<StreamGraphHandle> pStreamGraphHandle(
new StreamGraphHandle());
JniUtil::incrementHandleCount(
STREAMGRAPHHANDLE_TRACE_TYPE_STR, pStreamGraphHandle.get());
pStreamGraphHandle->javaRuntimeContext = NULL;
pStreamGraphHandle->pTxnHandle = pTxnHandle;
pStreamGraphHandle->pExecStreamGraph = pGraph;
pStreamGraphHandle->pExecStreamFactory.reset(
new ExecStreamFactory(
pDb,
pTxnHandle->pFtrsTableWriterFactory,
pStreamGraphHandle.get()));
// When snapshots are enabled, allocate DynamicDelegatingSegments for the
// stream graph so if the stream graph is executed in different txns,
// we can reset the delegate to whatever is the snapshot segment associated
// with the current txn.
if (pDb->areSnapshotsEnabled()) {
pStreamGraphHandle->pSegment =
pDb->getSegmentFactory()->newDynamicDelegatingSegment(
pTxnHandle->pSnapshotSegment);
pStreamGraphHandle->pReadCommittedSegment =
pDb->getSegmentFactory()->newDynamicDelegatingSegment(
pTxnHandle->pReadCommittedSnapshotSegment);
}
setStreamGraphHandle(
cmd.getResultHandle(),
pStreamGraphHandle.release());
}
void CmdInterpreter::visit(ProxyCmdOpenDatabase &cmd)
{
ConfigMap configMap;
SharedProxyDatabaseParam pParam = cmd.getParams();
for (; pParam; ++pParam) {
configMap.setStringParam(pParam->getName(), pParam->getValue());
}
CacheParams cacheParams;
cacheParams.readConfig(configMap);
SharedCache pCache = Cache::newCache(cacheParams);
JniUtilParams jniUtilParams;
jniUtilParams.readConfig(configMap);
JniUtil::configure(jniUtilParams);
DeviceMode openMode = cmd.isCreateDatabase()
? DeviceMode::createNew
: DeviceMode::load;
std::auto_ptr<DbHandle> pDbHandle(newDbHandle());
JniUtil::incrementHandleCount(DBHANDLE_TRACE_TYPE_STR, pDbHandle.get());
JavaTraceTarget *pJavaTraceTarget = newTraceTarget();
pDbHandle->pTraceTarget.reset(pJavaTraceTarget);
// on a fatal error, echo the backtrace to the log file:
AutoBacktrace::setTraceTarget(pDbHandle->pTraceTarget);
SharedDatabase pDb;
try {
pDb = Database::newDatabase(
pCache,
configMap,
openMode,
pDbHandle->pTraceTarget,
SharedPseudoUuidGenerator(new JniPseudoUuidGenerator()));
} catch (...) {
AutoBacktrace::setTraceTarget();
throw;
}
pDbHandle->pDb = pDb;
ExecStreamResourceKnobs knobSettings;
knobSettings.cacheReservePercentage =
configMap.getIntParam("cacheReservePercentage");
knobSettings.expectedConcurrentStatements =
configMap.getIntParam("expectedConcurrentStatements");
ExecStreamResourceQuantity resourcesAvailable;
resourcesAvailable.nCachePages = pCache->getMaxLockedPages();
pDbHandle->pResourceGovernor =
SharedExecStreamGovernor(
new SimpleExecStreamGovernor(
knobSettings, resourcesAvailable,
pDbHandle->pTraceTarget,
"xo.resourceGovernor"));
if (pDb->isRecoveryRequired()) {
SegmentAccessor scratchAccessor =
pDb->getSegmentFactory()->newScratchSegment(pDb->getCache());
FtrsTableWriterFactory recoveryFactory(
pDb,
pDb->getCache(),
pDb->getTypeFactory(),
scratchAccessor);
pDb->recover(recoveryFactory);
cmd.setResultRecoveryRequired(true);
} else {
cmd.setResultRecoveryRequired(false);
}
pDbHandle->statsTimer.setTarget(*pJavaTraceTarget);
pDbHandle->statsTimer.addSource(pDb);
pDbHandle->statsTimer.addSource(pDbHandle->pResourceGovernor);
pDbHandle->statsTimer.start();
// Cache initialization may have been unable to allocate the requested
// number of pages -- check for this case and report it in the log.
if (pCache->getMaxAllocatedPageCount() != cacheParams.nMemPagesMax
|| pCache->getAllocatedPageCount() != cacheParams.nMemPagesInit)
{
FENNEL_DELEGATE_TRACE(
TRACE_WARNING,
pDb,
"Unable to allocate "
<< cacheParams.nMemPagesInit
<< " (of "
<< cacheParams.nMemPagesMax
<< " max) cache pages; allocated "
<< pCache->getAllocatedPageCount()
<< " cache pages.");
}
setDbHandle(cmd.getResultHandle(), pDbHandle.release());
}