| /** @name internal_aggregate_engine.cpp |
| ----------------------------------------------------------------------------- |
| |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| |
| ----------------------------------------------------------------------------- |
| |
| Description: This file contains class AggregateEngine |
| |
| ----------------------------------------------------------------------------- |
| |
| |
| 4/27/1999 Initial creation |
| |
| -------------------------------------------------------------------------- */ |
| |
| #define UIMA_ENGINE_MAIN_CPP |
| |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Include dependencies */ |
| /* ----------------------------------------------------------------------- */ |
| |
| #include "uima/pragmas.hpp" //must be included first to disable warnings |
| #include "uima/annotator_timing.hpp" |
| #include "uima/engine.hpp" |
| |
| #include "uima/internal_aggregate_engine.hpp" |
| #include "uima/internal_fspromoter.hpp" |
| #include "uima/resmgr.hpp" |
| #include "uima/comp_ids.h" |
| #include "uima/err_ids.h" |
| #include "uima/annotator_mgr.hpp" |
| #include "uima/internal_casimpl.hpp" |
| |
| #include "uima/macros.h" |
| #include "uima/trace.hpp" |
| #include "uima/consoleui.hpp" |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Constants */ |
| /* ----------------------------------------------------------------------- */ |
| using namespace std; |
| namespace uima { |
| |
| namespace internal { |
| |
| static const char * gs_cpszReservedPrefix = _TEXT("UIMA"); |
| |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Forward declarations */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Types / Classes */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Private Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* |
| Most of the implementations required by uima::internal::EngineBase |
| directly call the ASB. |
| */ |
| |
| |
| TyErrorId AggregateEngine::init2(util::Trace & rclTrace) |
| /* ----------------------------------------------------------------------- */ |
| { |
| TyErrorId utErrorId = UIMA_ERR_NONE; |
| |
| try { |
| /* now, after all the general init and config has been done, |
| we can init the annotator manager which will init all annotators */ |
| utErrorId = iv_annotatorMgr.launchInit(); |
| if (utErrorId != UIMA_ERR_NONE) { |
| /* since the init failed, we must deinit all annotators in order |
| to release all user allocated stuff */ |
| (void) iv_annotatorMgr.launchDeInit(); /* ignore this RC */ |
| return(utErrorId); |
| } |
| |
| /* at this point, everything is fine and the engine is up and running! */ |
| |
| } |
| /* we need to catch any unexpected exceptions from init */ |
| catch (Exception & rclException) { |
| rclTrace.dump(_TEXT("UIMACPP exception during init")); |
| rclTrace.dump(_TEXT("UIMACPP exception id"), rclException.getErrorInfo().getErrorId()); |
| rclTrace.dump(_TEXT("UIMACPP exception name"), rclException.getName()); |
| rclTrace.dump(_TEXT("UIMACPP exception message"), rclException.getErrorInfo().getMessage().asString().c_str()); |
| getAnnotatorContext().getLogger().logError(rclException.getErrorInfo()); |
| return(logError(rclTrace, rclException.getErrorInfo().getErrorId())); |
| } |
| #ifdef NDEBUG |
| catch (...) { |
| /* this should never occur!!! */ |
| rclTrace.dump(_TEXT("Unexpected unknown exception")); |
| assertWithMsg(false, _TEXT("Unexpected unknown exception in init()")); //lint !e506: Constant value Boolean |
| return(logError(rclTrace, UIMA_ERR_ENGINE_UNEXPECTED_EXCEPTION)); /* in case the assert() is no longer here */ |
| } |
| #endif |
| return(utErrorId); |
| } |
| |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| |
| AggregateEngine::AggregateEngine(AnnotatorContext & rANC, bool bOwnsANC, |
| bool bOwnsTAESpecififer, |
| uima::internal::CASDefinition & casDefs, bool ownsCasDefs) : |
| EngineBase(rANC, bOwnsANC, bOwnsTAESpecififer, casDefs, ownsCasDefs), |
| iv_annotatorMgr(*this) { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| |
| clTrace.dump(_TEXT("UIMACPP Version"), AggregateEngine::getVersionInfo()); |
| clTrace.dump(_TEXT("UIMACPP Level"), AggregateEngine::getLevelInfo()); |
| assert(iv_state == EngineState::enEngineState_readyForInit); |
| |
| #ifndef NDEBUG |
| |
| /* taph 18.10.2001: this code can be useful if you want to debug |
| UIMACPP in an environment where you can't start the debugger directly |
| e.g. if UIMACPP is called from Java. |
| The programm will wait in the loop below which gives you time to |
| attach the debugger to the (Java) process and start debugging. |
| */ |
| util::Location tempDir; |
| util::Filename clLockfileName(tempDir.getAsCString(), "uimacpplock","lck"); |
| clLockfileName.normalizeAbsolute(); |
| if (clLockfileName.isExistent()) { |
| cout << "In AggregateEngine Ctor: Debug Lockfile detected." << endl; |
| cout << "Halting UIMACPP execution until " << clLockfileName.getAsCString() << " is deleted/renamed..." << endl; |
| do { |
| apr_sleep(3000000); // 3 seconds |
| } while (clLockfileName.isExistent()); |
| cout << "Continuing..." << endl; |
| } |
| #endif |
| |
| } |
| |
| |
| |
| AggregateEngine::~AggregateEngine(void) |
| /* ----------------------------------------------------------------------- */ |
| { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| destroyIfNeeded(); |
| |
| } |
| |
| |
| |
| TyErrorId AggregateEngine::initializeImpl(AnalysisEngineDescription const & ) { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| TyErrorId utErrorId = UIMA_ERR_NONE; |
| |
| /* continue with the rest of init() */ |
| utErrorId = init2(clTrace); |
| if (utErrorId != UIMA_ERR_NONE) { |
| return(logError(clTrace, utErrorId)); |
| } |
| |
| return(logError(clTrace, utErrorId)); |
| } |
| |
| |
| TyErrorId AggregateEngine::reinitTypeSystemImpl() { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| return iv_annotatorMgr.launchReinitTypeSystem(); |
| } |
| |
| |
| TyErrorId AggregateEngine::destroyImpl(void) { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| return iv_annotatorMgr.launchDeInit(); |
| } |
| |
| |
| TyErrorId AggregateEngine::processImpl(CAS & cas, ResultSpecification const & crResultSpec) { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| return iv_annotatorMgr.launchProcessDocument(cas, crResultSpec ); |
| } |
| |
| |
| TyErrorId AggregateEngine::reconfigureImpl(void) { |
| util::Trace clTrace(util::enTraceDetailMedium, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| return iv_annotatorMgr.launchConfig(); |
| } |
| |
| TyErrorId AggregateEngine::batchProcessCompleteImpl(void) { |
| util::Trace clTrace(util::enTraceDetailMedium, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| return iv_annotatorMgr.launchCollectionProcessComplete(); |
| } |
| |
| TyErrorId AggregateEngine::collectionProcessCompleteImpl(void) { |
| util::Trace clTrace(util::enTraceDetailMedium, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| return iv_annotatorMgr.launchCollectionProcessComplete(); |
| } |
| |
| bool AggregateEngine::hasNextImpl() { |
| return false; |
| } |
| |
| CAS & AggregateEngine::nextImpl() { |
| UIMA_EXC_THROW_NEW(ExcInvalidRequest, |
| UIMA_ERR_NOT_YET_IMPLEMENTED, |
| UIMA_MSG_ID_EXC_INVALID_CALL_TO_NEXT, |
| UIMA_MSG_ID_EXC_INVALID_CALL_TO_NEXT, |
| ErrorInfo::unrecoverable); |
| } |
| |
| int AggregateEngine::getCasInstancesRequiredImpl() { |
| return 0; |
| } |
| |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Static functions */ |
| /* ----------------------------------------------------------------------- */ |
| |
| #ifdef UIMA_DEBUG_ANNOTATOR_TIMING |
| |
| size_t |
| AggregateEngine::getNbrOfAnnotators( void ) const { |
| return iv_annotatorMgr.getNbrOfAnnotators(); |
| } |
| |
| icu::UnicodeString const & |
| AggregateEngine::getAnnotatorName( size_t uiAnnotatorIndex ) const { |
| // it is not easy to find the names for the delegate engines |
| // given only their position in the flow |
| AnalysisEngineMetaData const * pMetaData = |
| getAnnotatorContext().getTaeSpecifier().getAnalysisEngineMetaData(); |
| assert(EXISTS(pMetaData)); |
| FlowConstraints const * pFlow = pMetaData->getFlowConstraints(); |
| assert(EXISTS(pFlow)); |
| return pFlow->getNodes()[uiAnnotatorIndex]; |
| } |
| |
| uima::Timer |
| AggregateEngine::getAnnotatorTimer( size_t uAnnotatorIndex, EnAnnotatorTimer enAnnotatorTimer) const { |
| return iv_annotatorMgr.getAnnotatorTimer(uAnnotatorIndex, enAnnotatorTimer); |
| } |
| |
| |
| void AggregateEngine::displayTimingData(util::ConsoleUI const & rConsole, bool bVerbose) const { |
| string strTemp; |
| double dTotalLoadTime = (double)0.0; |
| double dTotalInitTime = (double)0.0; |
| double dTotalDeInitTime = (double)0.0; |
| double dTotalConfigTime = (double)0.0; |
| double dTotalProcessDocumentTime = (double)0.0; |
| double dTotalAnnotatorTime = (double)0.0; |
| size_t i; |
| |
| |
| // first sum up times to get totals |
| for ( i = 0; i < getNbrOfAnnotators(); ++i ) { |
| dTotalLoadTime += getAnnotatorTimer(i, enLoadAnnotatorTime).getAccumulatedTime(); |
| dTotalInitTime += getAnnotatorTimer(i, enInitAnnotatorTime).getAccumulatedTime(); |
| dTotalDeInitTime += getAnnotatorTimer(i, enDeinitAnnotatorTime).getAccumulatedTime(); |
| dTotalConfigTime += getAnnotatorTimer(i, enConfigAnnotatorTime).getAccumulatedTime(); |
| dTotalProcessDocumentTime+= getAnnotatorTimer(i, enProcessAnnotatorTime).getAccumulatedTime(); |
| } /* e-o-for */ |
| dTotalAnnotatorTime = dTotalLoadTime + dTotalInitTime + dTotalDeInitTime + dTotalConfigTime + dTotalProcessDocumentTime; |
| |
| rConsole.formatHeader("Overall annotator timing data"); |
| rConsole.format("Total time spent in annotators", uima::Timer::timeString(dTotalAnnotatorTime).c_str()); |
| if (bVerbose) { |
| rConsole.format("- library-load time", uima::Timer::timeString(dTotalLoadTime).c_str()); |
| rConsole.format("- initialize time", uima::Timer::timeString(dTotalInitTime).c_str()); |
| rConsole.format("- reconfigure time", uima::Timer::timeString(dTotalConfigTime).c_str()); |
| rConsole.format("- process time", uima::Timer::timeString(dTotalProcessDocumentTime).c_str()); |
| } |
| |
| // now dump the individual, total and relative times |
| rConsole.header("Individual annotator timing data (% for this annotator)"); |
| for ( i = 0; i < getNbrOfAnnotators(); ++i ) { |
| string str; |
| UnicodeStringRef uref(getAnnotatorName(i)); |
| uref.extract(str); |
| rConsole.format(str.c_str(), getAnnotatorTimer(i, enTotalAnnotatorTime).timeAndPercentString(dTotalAnnotatorTime).c_str()); |
| if (bVerbose) { |
| rConsole.format("- library load time", getAnnotatorTimer(i, enLoadAnnotatorTime).timeAndPercentString(dTotalLoadTime).c_str()); |
| rConsole.format("- initialize time", getAnnotatorTimer(i, enInitAnnotatorTime).timeAndPercentString(dTotalInitTime).c_str()); |
| rConsole.format("- reconfigure time", getAnnotatorTimer(i, enConfigAnnotatorTime).timeAndPercentString(dTotalConfigTime).c_str()); |
| rConsole.format("- process time", getAnnotatorTimer(i, enProcessAnnotatorTime).timeAndPercentString(dTotalProcessDocumentTime).c_str()); |
| rConsole.newline(); |
| } |
| } /* e-o-for */ |
| } |
| |
| #endif //UIMA_DEBUG_ANNOTATOR_TIMING |
| |
| } |
| |
| } // namespace uima |
| |
| /* <EOF> */ |
| |
| |