TyErrorId EngineBase::initialize(AnalysisEngineDescription const& specifier) {
try {
util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE);
if (!checkAndSetCallingSequenceInitialize()) {
return logError(clTrace, UIMA_ERR_ENGINE_INVALID_CALLING_SEQUENCE);
}
assert((&specifier) == (&iv_pAnnotatorContext->getTaeSpecifier()));
// call implementation in subclass
TyErrorId utErrorId = initializeImpl(specifier);
if (utErrorId != UIMA_ERR_NONE) {
destroy();
return utErrorId;
}
utErrorId = initializeCompleteResultSpec();
if (utErrorId != UIMA_ERR_NONE) {
destroy();
return utErrorId;
}
int numCasRequired = getCasInstancesRequiredImpl();
if (numCasRequired > 0) {
utErrorId = iv_pAnnotatorContext->defineCASPool(numCasRequired);
}
return utErrorId;
} catch (Exception& rclException) {
getAnnotatorContext().getLogger().logError(rclException.getErrorInfo());
return rclException.getErrorInfo().getErrorId();
}
}
void TpetraVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>::constInitialize(
const RCP<const TpetraVectorSpace<Scalar,LocalOrdinal,GlobalOrdinal,Node> > &tpetraVectorSpace,
const RCP<const Tpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> > &tpetraVector
)
{
initializeImpl(tpetraVectorSpace, tpetraVector);
}
TEST_F(TestConcurrentCompositeStateNoArgs,BasicConcurrentCompositeStateInteractions4)
{
typedef TestConcurrentCompositeStateNoArgsMock
< TestStateMachineNoEventArgsMock
> ConcurrentCompositeStateMockType;
::testing::NiceMock<TestStateMachineNoEventArgsMock> stateMachine;
::testing::NiceMock
< ConcurrentCompositeStateMockType
> compositeState(&stateMachine);
::testing::NiceMock
< TestRegionNoArgsMock<ConcurrentCompositeStateMockType>
> region(&compositeState);
stateMachine.autoFinalize(false);
compositeState.setRegion(0,®ion);
stateMachine.initialState(&compositeState);
// Setup mock call expectations
//----------------------------------------------------------------------------
EXPECT_CALL(compositeState,entryImpl(&stateMachine))
.Times(1);
EXPECT_CALL(compositeState,startDoImpl(&stateMachine))
.Times(1);
EXPECT_CALL(compositeState,endDoImpl(&stateMachine))
.Times(1);
EXPECT_CALL(compositeState,exitImpl(&stateMachine))
.Times(1);
// Check region calls
EXPECT_CALL(region,enterRegionImpl(&compositeState))
.Times(1);
EXPECT_CALL(region,startingRegionThread())
.Times(1);
EXPECT_CALL(region,initializeImpl(_))
.Times(2);
// TODO: Eliminate (superflous?) 3rd call of finalize(Impl)
EXPECT_CALL(region,finalizeImpl(_))
.Times(3);
EXPECT_CALL(region,endingRegionThread())
.Times(1);
EXPECT_CALL(region,exitRegionImpl(&compositeState))
.Times(1);
// Run the state machine
//----------------------------------------------------------------------------
// STTCL_TEST_LOG_ALL();
// compositeState.enableLogging(true);
// innerState.enableLogging(true);
stateMachine.initialize(true);
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.finalize(true);
EXPECT_TRUE(region.waitForDoActionExited(sttcl::TimeDuration<>(0,0,0,100),10));
// STTCL_TEST_LOG_END();
}
TEST_F(TestRegionNoArgs,BasicRegion_ShallowHistory_Interactions2)
{
typedef TestConcurrentCompositeStateNoArgsMock
< TestStateMachineNoEventArgsMock
> ConcurrentCompositeStateMockType;
typedef TestRegionNoArgsMock
< ConcurrentCompositeStateMockType
, sttcl::CompositeStateHistoryType::Shallow
> RegionMockType;
::testing::NiceMock<TestStateMachineNoEventArgsMock> stateMachine;
::testing::NiceMock
< ConcurrentCompositeStateMockType
> compositeState(&stateMachine);
::testing::NiceMock
< RegionMockType
> region(&compositeState);
::testing::NiceMock
< TestRegionInnerStateNoArgsMock<ConcurrentCompositeStateMockType,RegionMockType>
> innerState;
stateMachine.autoFinalize(false);
compositeState.setRegion(0,®ion);
region.initialState(&innerState);
stateMachine.initialState(&compositeState);
// Setup mock call expectations
//----------------------------------------------------------------------------
// Check region calls
EXPECT_CALL(region,enterRegionImpl(&compositeState))
.Times(1);
EXPECT_CALL(region,startingRegionThread())
.Times(1);
EXPECT_CALL(region,initializeImpl(_))
.Times(1);
EXPECT_CALL(region,finalizeImpl(_))
.Times(1);
EXPECT_CALL(region,endingRegionThread())
.Times(1);
EXPECT_CALL(region,exitRegionImpl(&compositeState))
.Times(1);
EXPECT_CALL(innerState,entryImpl(®ion))
.Times(1);
EXPECT_CALL(innerState,startDoImpl(®ion))
.Times(1);
EXPECT_CALL(innerState,initSubStateMachinesImpl(_))
.Times(1);
EXPECT_CALL(innerState,endDoImpl(®ion))
.Times(1);
EXPECT_CALL(innerState,exitImpl(®ion))
.Times(1);
// Run the state machine
//----------------------------------------------------------------------------
stateMachine.initialize();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.finalize(true);
}
void TpetraMultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>::constInitialize(
const RCP<const TpetraVectorSpace<Scalar,LocalOrdinal,GlobalOrdinal,Node> > &tpetraVectorSpace,
const RCP<const ScalarProdVectorSpaceBase<Scalar> > &domainSpace,
const RCP<const Tpetra::MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> > &tpetraMultiVector
)
{
initializeImpl(tpetraVectorSpace, domainSpace, tpetraMultiVector);
}
void CommandList::initialize(const std::shared_ptr<CommandAllocator>& allocator, const std::shared_ptr<PipelineState>& pipeline)
{
initializeImpl(allocator, pipeline);
if (pipeline)
{
list_->SetGraphicsRootSignature(getOwnerDevice()->getD3DRootSignature(*pipeline));
pipeline->applyParameters(list_.get());
}
}
void Node::enable()
{
if( ! mInitialized )
initializeImpl();
if( mEnabled )
return;
mEnabled = true;
enableProcessing();
}
void FirstPersonViewCli::initialize()
{
if (m_initialized)
{
Q_EMIT warning("Warning : already initialized");
return;
}
initializeImpl();
m_initialized = true;
}
void System::initialize()
{
if (mState == SYSTEM_STATE_INITIALIZED)
return;
mState = SYSTEM_STATE_INITIALIZING;
if (Log::getInstance() != nullptr) Log::getInstance()->logMessage(mName, "Initializing");
if (mSystemDriver != nullptr)
mSystemDriver->initialize();
registerDefaultFactories();
initializeImpl();
mState = SYSTEM_STATE_INITIALIZED;
if (Log::getInstance() != nullptr) Log::getInstance()->logMessage(mName, "Initialized");
}
// TODO: Checking for DelayNode below is a kludge and will not work for other types that want to support feedback.
// With more investigation it might be possible to avoid this, or at least define some interface that
// specifies whether this input needs to be summed.
void Node::configureConnections()
{
CI_ASSERT( getContext() );
mProcessInPlace = supportsProcessInPlace();
if( getNumConnectedInputs() > 1 || getNumConnectedOutputs() > 1 )
mProcessInPlace = false;
bool isDelay = ( dynamic_cast<DelayNode *>( this ) != nullptr ); // see note above
bool inputChannelsUnequal = inputChannelsAreUnequal();
for( auto &input : mInputs ) {
bool inputProcessInPlace = true;
size_t inputNumChannels = input->getNumChannels();
if( ! supportsInputNumChannels( inputNumChannels ) ) {
if( mChannelMode == ChannelMode::MATCHES_INPUT )
setNumChannels( getMaxNumInputChannels() );
else if( input->getChannelMode() == ChannelMode::MATCHES_OUTPUT ) {
input->setNumChannels( mNumChannels );
input->configureConnections();
}
else {
mProcessInPlace = false;
inputProcessInPlace = false;
}
}
// inputs with more than one output cannot process in-place, so make them sum
if( input->getProcessesInPlace() && input->getNumConnectedOutputs() > 1 )
inputProcessInPlace = false;
// when there are multiple inputs and their channel counts don't match, they must be summed
if( inputChannelsUnequal )
inputProcessInPlace = false;
// if we're unable to process in-place and we're a DelayNode, its possible that the input may be part of a feedback loop, in which case input must sum.
if( ! mProcessInPlace && isDelay )
inputProcessInPlace = false;
if( ! inputProcessInPlace )
input->setupProcessWithSumming();
input->initializeImpl();
}
for( auto &out : mOutputs ) {
NodeRef output = out.lock();
if( ! output )
continue;
if( ! output->supportsInputNumChannels( mNumChannels ) ) {
if( output->getChannelMode() == ChannelMode::MATCHES_INPUT ) {
output->setNumChannels( mNumChannels );
output->configureConnections();
}
else
mProcessInPlace = false;
}
}
if( ! mProcessInPlace )
setupProcessWithSumming();
initializeImpl();
}
TEST_F(TestRegionNoArgs,BasicRegion_ShallowHistory_Resume2)
{
typedef TestConcurrentCompositeStateNoArgsMock
< TestStateMachineNoEventArgsMock
> ConcurrentCompositeStateMockType;
typedef TestRegionNoArgsMock
< ConcurrentCompositeStateMockType
, sttcl::CompositeStateHistoryType::Shallow
> RegionMockType;
typedef TestRegionInnerStateNoArgsMock<ConcurrentCompositeStateMockType,RegionMockType> RegionInnerStateMockType;
::testing::NiceMock<TestStateMachineNoEventArgsMock> stateMachine("stateMachine");
::testing::NiceMock
< ConcurrentCompositeStateMockType
> compositeState(&stateMachine);
::testing::NiceMock
< RegionMockType
> region(&compositeState,"region");
::testing::NiceMock
< RegionInnerStateMockType
> innerState1("innerState1");
::testing::NiceMock
< RegionInnerStateMockType
> innerState2("innerState1");
::testing::NiceMock
< TestSimpleStateNoArgsMock<TestStateMachineNoEventArgsMock>
> outerState("outerState");
stateMachine.autoFinalize(false);
compositeState.setRegion(0,®ion);
region.initialState(&innerState1);
stateMachine.initialState(&compositeState);
// Setup mock call expectations
//----------------------------------------------------------------------------
EXPECT_CALL(compositeState,handleEvent1(&stateMachine))
.Times(1);
EXPECT_CALL(compositeState,handleEvent2(&stateMachine))
.Times(1)
.WillOnce( TRIGGER_STATE_CHANGE(ConcurrentCompositeStateMockType, handleEvent2, &compositeState, &outerState) );
EXPECT_CALL(compositeState,endDoImpl(&stateMachine))
.Times(2);
EXPECT_CALL(compositeState,exitImpl(&stateMachine))
.Times(2);
// Check region calls
EXPECT_CALL(region,enterRegionImpl(&compositeState))
.Times(2);
EXPECT_CALL(region,startingRegionThread())
.Times(2);
EXPECT_CALL(region,initializeImpl(_))
.Times(2);
// TODO: Eliminiate (superflous?) calls to finalize(Impl)
EXPECT_CALL(region,finalizeImpl(_))
.Times(3);
EXPECT_CALL(region,endingRegionThread())
.Times(2);
EXPECT_CALL(region,exitRegionImpl(&compositeState))
.Times(2);
EXPECT_CALL(outerState,entryImpl(&stateMachine))
.Times(1);
EXPECT_CALL(outerState,startDoImpl(&stateMachine))
.Times(1);
EXPECT_CALL(outerState,handleEvent3(&stateMachine))
.Times(1)
.WillOnce( TRIGGER_STATE_CHANGE(TestSimpleStateNoArgsMock<TestStateMachineNoEventArgsMock>, handleEvent3, &outerState, &compositeState) );
EXPECT_CALL(outerState,endDoImpl(&stateMachine))
.Times(1);
EXPECT_CALL(outerState,exitImpl(&stateMachine))
.Times(1);
EXPECT_CALL(innerState1,entryImpl(®ion))
.Times(1);
EXPECT_CALL(innerState1,startDoImpl(®ion))
.Times(1);
// TODO: Eliminiate (superflous?) calls to initSubStateMachinesImpl
EXPECT_CALL(innerState1,initSubStateMachinesImpl(true))
.Times(2);
// EXPECT_CALL(innerState1,initSubStateMachinesImpl(true))
// .Times(1);
EXPECT_CALL(innerState1,handleEvent1(&compositeState,®ion))
.Times(1)
.WillOnce( TRIGGER_STATE_CHANGE2(RegionInnerStateMockType, handleEvent1, &innerState1, &innerState2) );
EXPECT_CALL(innerState1,endDoImpl(®ion))
.Times(1);
EXPECT_CALL(innerState1,exitImpl(®ion))
.Times(1);
EXPECT_CALL(innerState2,entryImpl(®ion))
.Times(1);
EXPECT_CALL(innerState2,startDoImpl(®ion))
.Times(1);
// EXPECT_CALL(innerState2,initSubStateMachinesImpl(true))
// .Times(1);
EXPECT_CALL(innerState2,endDoImpl(®ion))
.Times(2);
EXPECT_CALL(innerState2,exitImpl(®ion))
.Times(2);
// Run the state machine
//----------------------------------------------------------------------------
// STTCL_TEST_LOG_ALL();
stateMachine.initialize(true);
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.triggerEvent1();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.triggerEvent2();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.triggerEvent3();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.finalize(true);
// STTCL_TEST_LOG_END();
}
TEST_F(TestConcurrentCompositeStateNoArgs,MultipleRegions)
{
typedef TestConcurrentCompositeStateNoArgsMock
< TestStateMachineNoEventArgsMock
> ConcurrentCompositeStateMockType;
::testing::NiceMock<TestStateMachineNoEventArgsMock> stateMachine;
::testing::NiceMock
< ConcurrentCompositeStateMockType
> compositeState(&stateMachine);
::testing::NiceMock
< TestRegionNoArgsMock<ConcurrentCompositeStateMockType>
> region1(&compositeState);
::testing::NiceMock
< TestRegionNoArgsMock<ConcurrentCompositeStateMockType>
> region2(&compositeState);
stateMachine.autoFinalize(false);
compositeState.setRegion(0,®ion1);
compositeState.setRegion(1,®ion2);
stateMachine.initialState(&compositeState);
// Setup mock call expectations
//----------------------------------------------------------------------------
EXPECT_CALL(compositeState,entryImpl(&stateMachine))
.Times(1);
EXPECT_CALL(compositeState,startDoImpl(&stateMachine))
.Times(1);
EXPECT_CALL(compositeState,endDoImpl(&stateMachine))
.Times(1);
EXPECT_CALL(compositeState,exitImpl(&stateMachine))
.Times(1);
// Check region calls
EXPECT_CALL(region1,enterRegionImpl(&compositeState))
.Times(1);
EXPECT_CALL(region1,startingRegionThread())
.Times(1);
EXPECT_CALL(region1,initializeImpl(_))
.Times(1);
EXPECT_CALL(region1,handleEvent1(&compositeState,®ion1))
.Times(1);
EXPECT_CALL(region1,handleEvent2(&compositeState,®ion1))
.Times(1);
EXPECT_CALL(region1,handleEvent3(&compositeState,®ion1))
.Times(1);
EXPECT_CALL(region1,handleEvent4(&compositeState,®ion1))
.Times(1);
EXPECT_CALL(region1,finalizeImpl(_))
.Times(1);
EXPECT_CALL(region1,endingRegionThread())
.Times(1);
EXPECT_CALL(region1,exitRegionImpl(&compositeState))
.Times(1);
EXPECT_CALL(region2,enterRegionImpl(&compositeState))
.Times(1);
EXPECT_CALL(region2,startingRegionThread())
.Times(1);
EXPECT_CALL(region2,initializeImpl(_))
.Times(1);
EXPECT_CALL(region2,handleEvent1(&compositeState,®ion2))
.Times(1);
EXPECT_CALL(region2,handleEvent2(&compositeState,®ion2))
.Times(1);
EXPECT_CALL(region2,handleEvent3(&compositeState,®ion2))
.Times(1);
EXPECT_CALL(region2,handleEvent4(&compositeState,®ion2))
.Times(1);
EXPECT_CALL(region2,finalizeImpl(_))
.Times(1);
EXPECT_CALL(region2,endingRegionThread())
.Times(1);
EXPECT_CALL(region2,exitRegionImpl(&compositeState))
.Times(1);
// Run the state machine
//----------------------------------------------------------------------------
// STTCL_TEST_LOG_ALL();
// compositeState.enableLogging(true);
// innerState.enableLogging(true);
stateMachine.initialize();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.triggerEvent1();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.triggerEvent2();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.triggerEvent3();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.triggerEvent4();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.finalize();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
EXPECT_TRUE(region1.waitForDoActionExited(sttcl::TimeDuration<>(0,0,0,100),10));
// STTCL_TEST_LOG_END();
}
