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()); }