diff options
author | 2021-01-19 18:06:48 +0530 | |
---|---|---|
committer | 2021-01-20 22:39:18 +0900 | |
commit | ca54ecb2f7ffdc1d68ed72836f09058d3ef242ec (patch) | |
tree | ced19c3a922cff59a552a10c0bd27afa05b87e5f /src/core/logic/RBAArbitrator.cpp | |
parent | 2cfe2c611be63ae4541abf4e13cfecff0f008f25 (diff) |
Create RBAArbitratorImpl class to hide internal interfaces
Signed-off-by: Anusha Gugale <external.agogale@jp.adit-jv.com>
Change-Id: Ica733746489825c5e9e5995964801ef2d173cd24
Diffstat (limited to 'src/core/logic/RBAArbitrator.cpp')
-rw-r--r-- | src/core/logic/RBAArbitrator.cpp | 1888 |
1 files changed, 24 insertions, 1864 deletions
diff --git a/src/core/logic/RBAArbitrator.cpp b/src/core/logic/RBAArbitrator.cpp index 74db3aa..e9fe59a 100644 --- a/src/core/logic/RBAArbitrator.cpp +++ b/src/core/logic/RBAArbitrator.cpp @@ -18,39 +18,24 @@ * Arbitrator class definition */ -#include <algorithm> -#include <sstream> #include "RBAArbitrator.hpp" #include "RBAModelImpl.hpp" #include "RBAResult.hpp" -#include "RBAResultSet.hpp" -#include "RBAAffectInfo.hpp" -#include "RBAConstraintImpl.hpp" -#include "RBAViewAction.hpp" -#include "RBAViewTransition.hpp" -#include "RBAViewMove.hpp" -#include "RBARollbacker.hpp" -#include "RBALogManager.hpp" -#include "RBAModelElementType.hpp" +#include "RBAArbitratorImpl.hpp" namespace rba { RBAArbitrator::RBAArbitrator(RBAModel* newModel) + : impl_{std::make_unique<RBAArbitrator::Impl>(this, + dynamic_cast<RBAModelImpl*>(newModel))} { - setModel(newModel); } #ifdef RBA_USE_LOG RBAArbitrator::RBAArbitrator(RBAModel* newModel, RBALogManager* logManager) + : impl_(std::make_unique<RBAArbitrator::Impl>(this, + dynamic_cast<RBAModelImpl*>(newModel), logManager)) { - setModel(newModel); - RBALogManager::setLogManager(logManager); - // Even if the argument logManager is null, it may be setLogManager() - // from outside the rba, so it is determined by getLogManager() instead of - // the argument determination. - if (RBALogManager::getLogManager() != nullptr) { - setSimulationMode(true); - } } #endif @@ -61,1927 +46,102 @@ RBAArbitrator::~RBAArbitrator() noexcept void RBAArbitrator::setModel(RBAModel* newModel) { - setModel(dynamic_cast<RBAModelImpl*>(newModel)); + impl_->setModel(dynamic_cast<RBAModelImpl*>(newModel)); } const RBAModel* RBAArbitrator::getModel() const { - return dynamic_cast<RBAModel*>(model_); + return impl_->getModel(); } void RBAArbitrator::initialize(std::list<std::string>& contexts) { - const std::lock_guard<std::recursive_mutex> lock{getMutex()}; - setRequestData(contexts, true); + impl_->initialize(contexts); } std::unique_ptr<RBAResult> RBAArbitrator::execute(const std::string& contextName, bool require) { - const std::lock_guard<std::recursive_mutex> lock {getMutex()}; - if (isValidContext(contextName) == false) { - // In case of error, creates a copy of "Result", - // sets the error flag in it and returns - std::unique_ptr<RBAResultImpl> result {std::make_unique<RBAResultImpl>( - this, std::make_unique<RBAResultSet>(*getBackupResultSet()))}; - result->setStatusType(RBAResultStatusType::UNKNOWN_CONTENT_STATE); - return std::move(result); - } else { - static_cast<void>(setRequestData(contextName, require, nullptr, - static_cast<std::uint32_t>(getRequestQue().size()))); - return arbitrateMain(); - } + return impl_->execute(contextName, require); } std::unique_ptr<RBAResult> RBAArbitrator::execute(std::list<std::string>& contexts, bool require) { - const std::lock_guard<std::recursive_mutex> lock {getMutex()}; - if (isValidContext(contexts) == false) { - // In case of error, creates a copy of "Result", - // sets the error flag in it and returns - std::unique_ptr<RBAResultImpl> result {std::make_unique<RBAResultImpl>( - this, std::make_unique<RBAResultSet>(*getBackupResultSet()))}; - result->setStatusType(RBAResultStatusType::UNKNOWN_CONTENT_STATE); - return std::move(result); - } else { - setRequestData(contexts, require); - return arbitrateMain(); - } + return impl_->execute(contexts, require); } std::unique_ptr<RBAResult> RBAArbitrator::execute(const std::string& sceneName, std::list<std::pair<std::string,std::int32_t>>& properties) { - const std::lock_guard<std::recursive_mutex> lock {getMutex()}; - // Check argument - if (isValidContext(sceneName) == false) { - // In case of error, creates a copy of "Result", - // sets the error flag in it and returns - std::unique_ptr<RBAResultImpl> result {std::make_unique<RBAResultImpl>( - this, std::make_unique<RBAResultSet>(*getBackupResultSet()))}; - result->setStatusType(RBAResultStatusType::UNKNOWN_CONTENT_STATE); - return std::move(result); - } else { - static_cast<void>(setRequestData(sceneName, true, &properties, - static_cast<std::uint32_t>(getRequestQue().size()))); - return arbitrateMain(); - } + return impl_->execute(sceneName, properties); } std::unique_ptr<RBAResult> RBAArbitrator::setResultContentState(const std::string& allocatableName, const std::string& contextName) { - const std::lock_guard<std::recursive_mutex> lock{getMutex()}; - RBAResultSet* const backupResultSetTmp {getBackupResultSet().get()}; - if (getReservedResultSet() == nullptr) { - setResult(std::make_unique<RBAResultImpl>(this, - std::make_unique<RBAResultSet>(), - std::move(getBackupResultSet()))); - } else { - RBAResultSet* const reservedResultSetTmp {getReservedResultSet().get()}; - setResult(std::make_unique<RBAResultImpl>(this, - std::move(getReservedResultSet()), - std::move(getBackupResultSet()))); - setReservedResultSet(std::make_unique<RBAResultSet>(*reservedResultSetTmp)); - } - setBackupResultSet(std::make_unique<RBAResultSet>(*backupResultSetTmp)); - - // find allocatable - const RBAAllocatable* alloc {nullptr}; - const RBAAreaImpl* const area {model_->findAreaImpl(allocatableName)}; - if(area != nullptr) { - alloc = area; - } - else { - const RBAZoneImpl* const zone {model_->findZoneImpl(allocatableName)}; - if(zone != nullptr) { - alloc = zone; - } - } - // find content state - const RBAContentState* state {nullptr}; - const RBAViewContentStateImpl* const viewState - {model_->findViewContentStateImpl(contextName)}; - if(viewState != nullptr) { - state = viewState; - } - else { - const RBASoundContentStateImpl* const soundState - {model_->findSoundContentStateImpl(contextName)}; - if(soundState != nullptr) { - state = soundState; - } - } - if( (alloc == nullptr) || (state == nullptr) ) { - // Unknown context or allocatable - getResult()->setStatusType(RBAResultStatusType::UNKNOWN_CONTENT_STATE); - return std::move(getResultRef()); - } - // Set alloc and state to result - const RBAContentState* const beforeContentState {alloc->getState()}; - const_cast<RBAAllocatable*>(alloc)->setState(state); - const_cast<RBAAllocatable*>(alloc)->setChecked(true); - getResult()->setActive(state, true); - getResult()->setContentState(alloc, state); - - // ---------------------------------------------------------- - // Post processing of Arbitration - // ---------------------------------------------------------- - postArbitrate(); - - // Excecute offline constraint -#ifdef RBA_USE_LOG - checkAllConstraints(); -#endif - - // ---------------------------------------------------------- - // Update the state of Content - // ---------------------------------------------------------- - if (beforeContentState != nullptr) { - // Update the state of the Content originally assigned to - // the requested Allocatable - dynamic_cast<RBAContent*>(beforeContentState->getOwner())->updateStatus(getResultRef().get()); - } - // Update the state of requested Content - dynamic_cast<RBAContent*>(state->getOwner())->updateStatus(getResultRef().get()); - - // Cancel processing of Content - checkCancelContent(); - - // Update display and non-display Area - updateResult(); - - // Generate Result - createResultData(); - - // Store backup of current arbitration result set - setBackupResultSet(getResult()->createBackupCurrentResultSet()); - // Create next arbitration result set - setNextResultSet(getResult()->createNextCurrentResultSet()); - - return std::move(getResultRef()); + return impl_->setResultContentState(allocatableName, contextName); } std::unique_ptr<RBAResult> RBAArbitrator::cancelArbitration() { - const std::lock_guard<std::recursive_mutex> lock{getMutex()}; - if(getReservedResultSet() == nullptr) { - std::unique_ptr<RBAResultImpl> res - {std::make_unique<RBAResultImpl>(this, - std::make_unique<RBAResultSet>())}; - res->setStatusType(RBAResultStatusType::CANCEL_ERROR); - return std::move(res); - } - - setResult( - std::make_unique<RBAResultImpl>(this, - std::make_unique<RBAResultSet>(), - std::move(getReservedResultSet()))); - setBackupResultSet(getResult()->createBackupCurrentResultSet()); - setNextResultSet(getResult()->createNextCurrentResultSet()); - - return std::move(getResultRef()); + return impl_->cancelArbitration(); } void RBAArbitrator::clearArbitration() { - std::lock_guard<std::recursive_mutex> lock {getMutex()}; - getCancelChecked().clear(); - setReservedResultSet(nullptr); - setBackupResultSet(std::make_unique<RBAResultSet>()); - for(const auto& scene : model_->getSceneImpls()) { - for(const std::string propertyName : scene->getPropertyNames()) { - const std::int32_t value {scene->getPropertyValue(propertyName)}; - getBackupResultSet()->setSceneProperty(scene, propertyName, value); - } - } - setNextResultSet( - std::make_unique<RBAResultSet>(*getBackupResultSet().get())); - setResult(std::make_unique<RBAResultImpl>( - this, - std::make_unique<RBAResultSet>(*getBackupResultSet().get()))); - - model_->clearElementsStatus(); + return impl_->clearArbitration(); } bool RBAArbitrator::setScene(const std::string& sceneName, bool require, std::list<std::pair<std::string, std::int32_t>>& properties) { - const std::lock_guard<std::recursive_mutex> lock{getMutex()}; - return setRequestData(sceneName, require, &properties); + return impl_->setScene(sceneName, require, properties); } bool RBAArbitrator::setContentState(const std::string& contextName, bool require) { - const std::lock_guard<std::recursive_mutex> lock{getMutex()}; - const std::deque<std::unique_ptr<RBARequestQueMember>>& requestQue{getRequestQue()}; - std::uint32_t syncIndex{static_cast<std::uint32_t>(requestQue.size())}; - if (syncIndex > 0U ) { - const std::unique_ptr<RBARequestQueMember>& prevReq{requestQue.back()}; - if (prevReq->isOn() == require) { - syncIndex = prevReq->getSyncIndex(); - } - } - return setRequestData(contextName, require, nullptr, syncIndex); + return impl_->setContentState(contextName, require); } bool RBAArbitrator::setAllocatableResult(const std::string& allocatableName, const std::string& contextName) { - std::lock_guard<std::recursive_mutex> lock {getMutex()}; - // Get allocatable - const auto alloc = model_->findAllocatable(allocatableName); - if(alloc == nullptr) { - return false; - } - - // Get context - const auto state = model_->findContentState(contextName); - if(state == nullptr) { - return false; - } - - // Set state to allocatable - const auto beforeContentState = alloc->getState(); - const_cast<RBAAllocatable*>(alloc)->setState(state); - RBAResultSet* const nextResultSet {getNextResultSet().get()}; - RBAResultSet* const prevResultSet {getBackupResultSet().get()}; - nextResultSet->setContentState(alloc, state); - prevResultSet->setContentState(alloc, state); - nextResultSet->setActive(state, true); - prevResultSet->setActive(state, true); - - // ---------------------------------------------------------- - // Update the state of Content - // ---------------------------------------------------------- - // Create "result" and update state, because updating the content state - // determines the transition destination this time - // based on previous state. - setResult(std::make_unique<RBAResultImpl>( - this, - std::make_unique<RBAResultSet>(*getBackupResultSet()), - std::make_unique<RBAResultSet>(*getNextResultSet()))); - RBAContent* const content {dynamic_cast<RBAContent*>(state->getOwner())}; - content->updateRequestStatus(getResult()->getCurResultSet().get(), true); - if (beforeContentState != nullptr) { - // Update the state of the content originally assigned to - // the requested Allocatable - dynamic_cast<RBAContent*>(beforeContentState->getOwner())->updateStatus(getResultRef().get()); - } - // Update the state of requested Content - content->updateStatus(getResultRef().get()); - - setBackupResultSet(std::make_unique<RBAResultSet>(*getResult()->getPreResultSet())); - setNextResultSet(getResult()->createNextCurrentResultSet()); - - return true; + return impl_->setAllocatableResult(allocatableName, contextName); } bool RBAArbitrator::RBAArbitrator::evaluate(RBAExpression* expression) { - if(expression == nullptr) { - return false; - } - const std::lock_guard<std::recursive_mutex> lock{getMutex()}; - RBAConstraintInfo info; - // Constraint expression evaluation - return expression->execute(&info, this); + return impl_->evaluate(expression); } const RBARuleObject* RBAArbitrator::evaluateObject(RBAExpression* expression) { - if(expression == nullptr) { - return nullptr; - } - const std::lock_guard<std::recursive_mutex> lock{getMutex()}; - RBAConstraintInfo info; - // Constraint expression evaluation - const RBARuleObject* const ruleObj - {expression->getReferenceObject(&info, this)}; - if (ruleObj != nullptr) { - return ruleObj->getRawObject(); - } else { - return nullptr; - } + return impl_->evaluateObject(expression); } int32_t RBAArbitrator::evaluateValue(RBAExpression* expression) { - if(expression == nullptr) { - return -99; - } - const std::lock_guard<std::recursive_mutex> lock{getMutex()}; - RBAConstraintInfo info; - // Constraint expression evaluation - return expression->getValue(&info, this); -} - - -void -RBAArbitrator::setModel(RBAModelImpl* const newModel) -{ - std::lock_guard<std::recursive_mutex> lock {getMutex()}; - model_ = newModel; - model_->createSortedAllocatables(); - clearArbitration(); -} - -bool -RBAArbitrator:: -satisfiesConstraints() const -{ - const std::lock_guard<std::recursive_mutex> lock{mutex_}; - // Temporarily store the actual result_ - // because result_ is used for evaluation - std::unique_ptr<RBAResultImpl> tmpResult {std::move(result_)}; - result_ = std::make_unique<RBAResultImpl>( - this, - std::make_unique<RBAResultSet>(*(reservedResultSet_.get())), - std::make_unique<RBAResultSet>(*(resultSetForSatisfiesConstraints_.get()))); - bool result {true}; - for(const RBAConstraintImpl*& constraint : model_->getConstraintImpls()) { - if (constraint->isRuntime() == true) { - result = const_cast<RBAConstraintImpl*>(constraint)->execute(const_cast<RBAArbitrator*>(this)); - if (result == false) { - break; - } - } - } - result_ = std::move(tmpResult); - return result; -} - -/** - * Execute arbitration - */ -std::unique_ptr<RBAResult> -RBAArbitrator::arbitrateMain() -{ - // Store request state before arbitration, - // in case cancelArbitration() is executed - reservedResultSet_ = std::make_unique<RBAResultSet>(*backupResultSet_); - - // Differential arbitration for each request - if (requestQue_.empty()) { - // Prepare Result here because it will be used in differenceArbitrate. - result_ = std::make_unique<RBAResultImpl>(this, - std::move(backupResultSet_), - std::move(nextResultSet_)); - // Arbitration request without arguments. - // there is a possibility of being queued in "requestQue_" - // due to "onDisplayed" in this, - differenceArbitrate(); - } - if (!requestQue_.empty()) { - result_ = std::make_unique<RBAResultImpl>(this, - std::move(backupResultSet_), - std::move(nextResultSet_)); - do { - const std::unique_ptr<RBARequestQueMember> request {std::move(requestQue_.front())}; - requestQue_.pop_front(); - result_->setActive(request->getContentState(), request->isOn()); - // Update the state of Content - RBAContent* const content {dynamic_cast<RBAContent*>(request->getContentState()->getOwner())}; - content->updateRequestStatus(result_->getCurResultSet().get(), request->isOn()); - if (requestQue_.empty()) { - differenceArbitrate(); - if (!requestQue_.empty()) { - // Update "result_" for the next differenceArbitrate(). - result_ = std::make_unique<RBAResultImpl>(this, - std::move(backupResultSet_), - std::move(nextResultSet_)); - } - } else if (requestQue_.front()->getSyncIndex() != request->getSyncIndex()) { - differenceArbitrate(); - // Update "result_" for the next differenceArbitrate(). - result_ = std::make_unique<RBAResultImpl>(this, - std::move(backupResultSet_), - std::move(nextResultSet_)); - } else { - // No Operation - } - } while (!requestQue_.empty()); - } - - result_ = std::make_unique<RBAResultImpl>( - this, std::make_unique<RBAResultSet>(*reservedResultSet_), - result_->createBackupCurrentResultSet()); - - // Cancel processing of Content - checkCancelContent(); - - // Update displayed and non-displayed Area - updateResult(); - -#ifdef RBA_USE_LOG - RBALogManager::setType(RBALogManager::TYPE_RESULT); - logResultArbitration(); - - setLogToResult(); - RBALogManager::setType(RBALogManager::TYPE_NOTHING); -#endif - - createResultData(); - // Store backup of current arbitration result set - backupResultSet_ = result_->createBackupCurrentResultSet(); - // Create next arbitration result set - nextResultSet_ = result_->createNextCurrentResultSet(); - - // The "result_" of the return value is changed to another name, - // because "result_" will be used for storing. - auto retResult = std::move(result_); - - // Hold the arbitration result because the arbitration result may be used - // in cases other than arbitration. - result_ = std::make_unique<RBAResultImpl>(retResult.get()); - - // A compile error occurs if std::move() is missing because - // std::unique_ptr<RBAResultImpl> is cast to std::unique_ptr<RBAResult> - return std::move(retResult); -} - -bool -RBAArbitrator:: -isValidContext(const std::string& context) -{ - if (context != "") { - const RBAContentState* const state {model_->findContentState(context)}; - if (state == nullptr) { - const RBASceneImpl* const scene {model_->findSceneImpl(context)}; - if (scene == nullptr) { - return false; - } - } - } - - return true; -} - -bool -RBAArbitrator:: -isValidContext(std::list<std::string>& contexts) -{ - for(const std::string contextName : contexts) { - if(isValidContext(contextName) == false) { - return false; - } - } - - return true; -} - -/** - * Reflect input information - */ - -bool -RBAArbitrator::setRequestData( - const std::string& context, bool require, - std::list<std::pair<std::string, std::int32_t>>* const properties, - std::uint32_t syncIndex) -{ - bool isSet {false}; - if (context != "") { - // When content state is specified - // If contextName is the only content name, pop the first content state - const RBAContentState* state {model_->findContentState(context)}; - if (state != nullptr) { - requestQue_.push_back( std::make_unique<RBARequestQueMember>(state, require, syncIndex)); - isSet = true; - } else { - // When Scene is specified - const RBASceneImpl* const scene {model_->findSceneImpl(context)}; - if (scene != nullptr) { - // for next arbitration - nextResultSet_->setActive(scene, require); - // For when "Result" is referenced before the next arbitration - result_->setActive(scene, require); - isSet = true; - if (properties != nullptr) { - for (auto& p : *properties) { - const RBAAbstractProperty* const ap {scene->getProperty(p.first)}; - if (ap != nullptr) { - // for next arbitration - nextResultSet_->setSceneProperty(ap, p.second); - // For when "Result" is referenced before the next arbitration - result_->setSceneProperty(ap, p.second); - } - } - } - } - } - } - return isSet; -} - -void -RBAArbitrator::setRequestData(const RBAContentState* state, - bool require) -{ - if (requestQue_.empty()){ - requestQue_.push_back( std::make_unique<RBARequestQueMember>(state, require, 0U)); - } else { - requestQue_.push_back( std::make_unique<RBARequestQueMember>(state, require, requestQue_.back()->getSyncIndex())); - } -} - -void -RBAArbitrator::setRequestData(const RBAContent* const content, - bool require) -{ - if (requestQue_.empty()){ - requestQue_.push_back( std::make_unique<RBARequestQueMember>(content->getStates().front(), require, 0U)); - } else { - requestQue_.push_back( std::make_unique<RBARequestQueMember>(content->getStates().front(), require, requestQue_.back()->getSyncIndex())); - } -} - -void -RBAArbitrator::setActive(const RBASceneImpl* const scene, const bool require) -{ - if (nextResultSet_ != nullptr) { - // Update nextResultSet_" when onScene is done in onRequest or onWithdrawn - nextResultSet_->setActive(scene, require); - } else { - result_->setActive(scene, require); - } -} - -void -RBAArbitrator::setSceneProperty(const RBAAbstractProperty* const prop, const std::int32_t value) -{ - if (nextResultSet_ != nullptr) { - // Update nextResultSet_" when onScene is done in onRequest or onWithdrawn - nextResultSet_->setSceneProperty(prop, value); - } else { - result_->getCurResultSet()->setSceneProperty(prop, value); - } -} - -void -RBAArbitrator::setRequestData(std::list<std::string>& contexts, - const bool require) -{ - const std::uint32_t syncIndex {static_cast<std::uint32_t>(requestQue_.size())}; - for (auto& c : contexts) { - static_cast<void>(setRequestData(c, require, nullptr, syncIndex)); - } -} - -/** - * @brief Execute an extended version of arbitration that allows arbitration - when the "implication" is false - * @param areas - */ -void -RBAArbitrator:: -arbitrate(std::list<RBAAllocatable*>& allocatables) -{ - LOG_arbitrateAreaLogLine("----Arbitrate----"); - std::set<const RBAAllocatable*> revisitedInitSet; - - std::set<const RBAAllocatable*> revisited; - for (auto& alloc : allocatables) { - revisited = revisitedInitSet; - // ------------------------------------------------------------------------- - // To prevent an infinite loop, generate information to limit registration - // of other "allocable" that affected the target "allocatable" - // during arbitration - // ------------------------------------------------------------------------- - RBAAffectInfo affectInfo; - LOG_arbitrateAreaLogLine( - alloc->getSymbol() + "[" + alloc->getElementName() + "] check start"); - arbitrateAllocatable(alloc, revisited, 0, &affectInfo, nullptr); - } - for (auto& a : model_->getSortedAllocatables()) { - result_->setContentState(a, a->getState()); - } -} - -/** - * @brief Recursively arbitrate "allocatable" - * @param allocatable Allocatable that you want to arbitrate - * @param revisited Allocatable that re-arbitration is complete - * @param nest Re-arbitration nesting hierarchy (first arbitration is zero) - * @param affectInfo Allocatable information affected by "allocatable" - */ -void RBAArbitrator::arbitrateAllocatable( - RBAAllocatable* allocatable, - std::set<const RBAAllocatable*>& revisited, - const std::int32_t nest, - RBAAffectInfo* const affectInfo, - RBARollbacker* const parentRollbacker) -{ -#ifdef RBA_USE_LOG - RBALogManager::setIndent(nest); -#endif - // "Allocable" affected by "Allocable" which is the target of this arbitration - // during the recursive process until this variable is defined, - std::set<const RBAAllocatable*> affectAllocatables; - affectAllocatables.insert(allocatable->getAllocatablesAffectedByYou().begin(), - allocatable->getAllocatablesAffectedByYou().end()); - - const RBAContentState* const beforeState {allocatable->getState()}; - - // Mark Content allocation for target Allocable" as "checked" - allocatable->setChecked(true); - // Get content status sorted by arbitration policy - // (only active requests) - std::list<const RBAContentState*> contentStates; - getSortedContentStates(allocatable, contentStates); - for(const RBAContentState* const contentState : contentStates) { - // Allocate Content to Area - allocatable->setState(contentState); -#ifdef RBA_USE_LOG - { - std::string str = " Content["; - if (contentState == nullptr) { - str += "null"; - } else { - str += contentState->getOwner()->getElementName() + "::" - + contentState->getElementName(); - } - str += "] check online constraints start"; - RBALogManager::arbitrateContentLogLine(str); - } -#endif - bool isSkipped {false}; - const bool isPassed {checkConstraintAndReArbitrate( - allocatable, revisited, nest, affectInfo, parentRollbacker, - allocatable->getConstraints(), &isSkipped, false)}; - if (isPassed == true) { - - // ---------------------------------------------------------- - // Check if self-allocatable should be hidden - // by constraint expression after content allocation process. - // Check even if content is not assigned because there is contentValue() - // ---------------------------------------------------------- -#ifdef RBA_USE_LOG - std::string alloSymbol = allocatable->getSymbol(); - std::string alloName = allocatable->getElementName(); - if (allocatable->isArea() == true) { - LOG_arbitrateAreaLogLine( - " check online constraints to confirm area hidden state"); - } else { - LOG_arbitrateAreaLogLine( - " check online constraints to confirm zone muted state"); - } -#endif - // Mark "hidden" of target "Allocable" as "checked" - allocatable->setHiddenChecked(true); - // Set "hidden" of target "Allocable" to false - allocatable->setHidden(false); - bool hiddenIsPassed {checkConstraintAndReArbitrate( - allocatable, revisited, nest, affectInfo, parentRollbacker, - allocatable->getHiddenFalseCheckConstraints(), &isSkipped, - !allocatable->isZone())}; - if (hiddenIsPassed == false) { - allocatable->setHidden(true); - hiddenIsPassed = checkConstraintAndReArbitrate( - allocatable, revisited, nest, affectInfo, parentRollbacker, - allocatable->getHiddenTrueCheckConstraints(), &isSkipped, - !allocatable->isZone()); - if (hiddenIsPassed == false) { - // Clear hiding state of Allocatable - allocatable->setHiddenChecked(false); - } else { - LOG_arbitrateAreaLogLine( - alloSymbol + "[" + alloName + "] change " - + allocatable->getHiddenSymbol()); - } - } - - // ------------------------------------- - // For Zone, judge attenuation after hiding (mute) - // ------------------------------------- - bool attenuateIsPassed {true}; - if (allocatable->isZone()) { - RBAZoneImpl* const zone {dynamic_cast<RBAZoneImpl*>(allocatable)}; - // Mark "attenuattion" of target "Zone" as checked" - zone->setAttenuateChecked(true); - // Set "attenuattion" of target "Zone" to false - zone->setAttenuated(false); - LOG_arbitrateAreaLogLine( - " check online constraints to confirm zone attenuated state"); - attenuateIsPassed = checkConstraintAndReArbitrate( - allocatable, revisited, nest, affectInfo, parentRollbacker, - allocatable->getAttenuateFalseCheckConstraints(), &isSkipped, true); - if (attenuateIsPassed == false) { - zone->setAttenuated(true); - attenuateIsPassed = checkConstraintAndReArbitrate( - allocatable, revisited, nest, affectInfo, parentRollbacker, - allocatable->getAttenuateTrueCheckConstraints(), &isSkipped, true); - if (attenuateIsPassed == false) { - allocatable->setAttenuateChecked(false); - } else { - LOG_arbitrateAreaLogLine( - alloSymbol + "[" + alloName + "] change attenuated"); - } - } - } -#ifdef RBA_USE_LOG - { - std::string str = alloSymbol + "[" + alloName + "] "; - if (allocatable->isArea() == true) { - str += "displays"; - } else { - str += "outputs"; - } - str += " Content["; - const RBAContentState* state = allocatable->getState(); - if (state == nullptr) { - str += "null"; - } else { - str += state->getOwner()->getElementName() + "::" - + state->getElementName(); - } - str += "] " + allocatable->getHiddenSymbol() + "[" - + RBALogManager::boolToString(allocatable->isHidden()) + "]"; - if (allocatable->isZone() == true) { - str += " attenuated[" - + RBALogManager::boolToString(allocatable->isAttenuated()) + "]"; - } - str += "\n"; - LOG_arbitrateAreaLogLine(str); - } -#endif - if ((hiddenIsPassed == true) && (attenuateIsPassed == true)) { - break; - } - } - } - // --------------------------------------------------------------------- - // Re-arbitration of the Allocatable that influenced - // --------------------------------------------------------------------- - if ((beforeState != allocatable->getState()) - || allocatable->isHidden() - || allocatable->isAttenuated()) { - - // Re-arbitration is performed in a state other than "hidden" - // When allocating content. Therefore, if state become "hidden" or - // "attenuation", re-arbitration is required for the "allocatable" - // that was affected by re-arbitration during content allocation. - // Update the increased Area that influenced - if (allocatable->isHidden() || allocatable->isAttenuated()) { - for (const auto& a : allocatable->getAllocatablesAffectedByYou()) { - static_cast<void>(affectAllocatables.insert(a)); - } - } - - // If the re-arbitration source of Area/Zone (including any re-arbitration - // sources, if any reconciliation nests) becomes an Area/Zone affected by - // the re-arbitration area/zone, such Area/Zone is excluded from - // the re-arbitration target and the affected Area/Zone is re-arbitrated. - // Further, even if the affected Area/Zone is unarbitrated Allocatable - // at that time, it is excluded from the re-arbitration target of - // the affected Area. This is because it is sufficient to arbitrate - // during normal arbitration. - for (const auto& a : revisited) { - if (affectAllocatables.find(a) != affectAllocatables.end() - || (!a->isChecked())) { - static_cast<void>(affectAllocatables.erase(a)); - } - } - std::list<const RBAAllocatable*> sortedAllocatables(affectAllocatables.begin(),affectAllocatables.end()); - sortedAllocatables.sort(&RBAAllocatable::compareIndex); - if (parentRollbacker != nullptr) { - std::shared_ptr<RBARollbacker> rollbacker {std::make_shared<RBARollbacker>()}; - parentRollbacker->addChild(rollbacker); - rollbacker->backup(sortedAllocatables); - } - - for (auto& affect : sortedAllocatables) { - // Remove Allocatable which will be re-arbitration from Allocatable - // that influenced Allocable during arbitration. - allocatable->removeAffectAllocatable(affect); - } - static_cast<void>(revisited.insert(allocatable)); // Add to arbitrated Area - for (auto& affectAllocatable : sortedAllocatables) { - // @Deviation (EXP55-CPP,Rule-5_2_5,A5-2-3) - // [Contents that deviate from the rules] - // This is a 'const_cast' expression that strips away a 'const' or - // 'volatile' qualifier. - // [Why there is no problem if it deviate from the rules] - // Confirmed that there is no problem from the design point of view. - // We won't fix it now because we need to redesign the class, but - // no much effort as of now. - RBAAllocatable* allo {const_cast<RBAAllocatable*>(affectAllocatable)}; - - // Initialize the check flag of the Allocatable that performs the - // re-arbitration of the affetcted Allocatable - // If the affected Allocables are cleared in advance, a skip occurred in - // the constraint expression evaluation during the re-arbitration of - // the affected Allocatable that was carried out earlier, after that - // re-arbitration will work during re-arbitration of affected Allocatable. - // Therefore, clear check flag individually - // before re-arbitration of affected Allocable - allo->clearChecked(); - - LOG_arbitrateAreaLogLine( " " + - affectAllocatable->getSymbol() + "[" - + affectAllocatable->getElementName() - + "] affect allocatable check start"); - // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2) - // [Contents that deviate from the rules] - // Recursively calling arbitrateAllocatable() - // [Why there is no problem if it deviate from the rules] - // - This process is necessary for re-arbitration of the affected Area, - // - stack overflow will not occur becasue the infinite loop - // prevention process is imeplemented. - arbitrateAllocatable(allo, revisited, nest + 1, affectInfo, - parentRollbacker); - } - for(const RBAAllocatable* const revisitAllocatable : sortedAllocatables) { - static_cast<void>(revisited.erase(revisitAllocatable)); - } - } - - // -------------------------------------------------- - // Delete temporary affect information - // to prevent infinite loop during re-arbitration - // -------------------------------------------------- - affectInfo->removeAffectInfo(allocatable); -#ifdef RBA_USE_LOG - RBALogManager::setIndent(nest-1); -#endif + return impl_->evaluateValue(expression); } -/** - * @brief Sort content state based on arbitration policy - * @param allocatable - * @param contentStates - * @return success/failure of sort - */ -bool -RBAArbitrator:: -sortContentStates(const RBAAllocatable* const allocatable, - std::list<const RBAContentState*>& states) const +RBAArbitratorImpl* +RBAArbitrator::getImpl() const { - bool isResult {true}; - switch(allocatable->getAllocatableArbitrationPolicy()) { - case RBAArbitrationPolicy::FIRST_COME_FIRST: - states.sort(&RBAContentState::compareFirstComeFirst); - break; - case RBAArbitrationPolicy::LAST_COME_FIRST: - states.sort(&RBAContentState::compareLastComeFirst); - break; - case RBAArbitrationPolicy::PRIORITY_FIRST_COME_FIRST: - states.sort(&RBAContentState::comparePriorityFirstComeFirst); - break; - case RBAArbitrationPolicy::DEFAULT: - case RBAArbitrationPolicy::PRIORITY_LAST_COME_FIRST: - states.sort(&RBAContentState::comparePriorityLastComeFirst); - break; - default: - isResult = false; - break; - } - - return isResult; + return impl_->getImpl(); } -/** - * @brief Get re-arbitration list from judgment NG constraint - * @param totalRevisitAllocatables - * @param allocatable - * @param falseConstraints - * @param revisited - */ -void -RBAArbitrator:: -collectRevisitAllocatable(std::list<const RBAAllocatable*>* const totalRevisitAllocatables, - RBAAllocatable*& allocatable, - std::list<RBAConstraintImpl*>& falseConstraints, - std::set<const RBAAllocatable*>& revisited) -{ - std::set<const RBAAllocatable*> revisitAllocatablesSet; - - // Determine if re-arbitration should be done based on the constraint - // that the determination was NG - for(RBAConstraintImpl*& constraint : falseConstraints) { - // Get Contraint information - const RBAConstraintInfo* const info {constraint->getInfo()}; - // Allocatable, a candidate for re-arbitration - std::set<const RBAAllocatable*> rightFalseAllocatables; - - if (info->needsRearbitrationFor(allocatable)) { - info->collectRearbitrationTargetFor(allocatable, rightFalseAllocatables, false); - } - if (rightFalseAllocatables.empty()) { - // Non-implication constraint expression - // To ensure that "currently arbitrated allocable" does not lose to lower - // priority allocable, arbitration of low priority Allocable is performed - // if low priority Allocable is included in - // "re-arbitration candidate Allocable". - info->collectFalseAllocatables(rightFalseAllocatables); - bool isContainsLowPriorityAllocatable {false}; - for(const RBAAllocatable* const rightFalseAllocatable - : rightFalseAllocatables) { - if(RBAAllocatable::compareIndex(allocatable,rightFalseAllocatable)) { - // index is smaller for higher priority allocable - isContainsLowPriorityAllocatable = true; - break; - } - } - if(!isContainsLowPriorityAllocatable) { - continue; - } - } - - // Remove Allocable during arbitration from re-arbitration target - static_cast<void>(rightFalseAllocatables.erase(allocatable)); - - // If even one Allocable candidate for re-arbitration has been - // re-arbitrated, re-arbitration will not be performed again. - // Go to next content assignment - for(const RBAAllocatable* const rightFalseAllocatable : rightFalseAllocatables) { - if(revisited.find(rightFalseAllocatable) != revisited.end()) { - return; - } - } - - // Set re-arbitration Allocable - for(const RBAAllocatable* const alloc : rightFalseAllocatables) { - static_cast<void>(revisitAllocatablesSet.insert(alloc)); - } - } - - // Re-arbitration Allocatable exists - if(!(revisitAllocatablesSet.empty())) { - // copy std::set to std::list - static_cast<void>(totalRevisitAllocatables->insert(totalRevisitAllocatables->end(), - revisitAllocatablesSet.begin(), - revisitAllocatablesSet.end())); - // Sort re-arbitration Areas in ascending order based on priority - // It is necessary to sort by index comparison considering the order of models. - totalRevisitAllocatables->sort(&RBAAllocatable::compareIndex); - } -} - -/** - * Confirm cancellation of all content status - * to cancel Request which lost in arbitration - */ -void -RBAArbitrator:: -postArbitrate() -{ -#ifdef RBA_USE_LOG - RBALogManager::cancelRequestLogLine("----Cancel Request----"); -#endif - for(const RBAContentState* const state : model_->getContentStates()) { -#ifdef RBA_USE_LOG - RBALogManager::cancelRequestLogLine("Content["+ - state->getOwner()->getElementName()+"::"+ - state->getElementName()+ - "] check start"); -#endif - static_cast<void>(cancelChecked_.insert(state)); - if(!result_->isActive(state)) { -#ifdef RBA_USE_LOG - RBALogManager::cancelRequestLogLine(" Content["+ - state->getOwner()->getElementName()+"::"+ - state->getElementName()+ - "] is not Active skip"); -#endif - continue; - } - if(result_->isAlreadyOutputting(state)) { -#ifdef RBA_USE_LOG - std::string contTypeName; - if(state->isViewContentState()) { - contTypeName = "Visible"; - } - else { - contTypeName = "Sounding"; - } - RBALogManager::cancelRequestLogLine(" Content["+ - state->getOwner()->getElementName()+"::"+ - state->getElementName()+ - "] is "+contTypeName+" skip"); -#endif - continue; - } - - changeContentStateCancelWithPolicy(state); - } - -#ifdef RBA_USE_LOG - // Log output for coverage of request cancellation - for(const RBAContentState* state : model_->getContentStates()) { - std::string contentName = state->getOwner()->getElementName(); - std::string stateName = state->getElementName(); - std::string canceled = isCancel(state) ? "t" : "f"; - RBALogManager::coverageCanceledRequestLogLine( - contentName + "," + stateName + ',' +canceled); - } -#endif -} - -/** - * @brief Change the cancellation information of hidden Content status - based on arbitration results and cancellation policy - * @param state - */ -void -RBAArbitrator:: -changeContentStateCancelWithPolicy(const RBAContentState* const state) -{ - switch(dynamic_cast<RBAContent*>(state->getOwner())->getContentLoserType()) { - case RBAContentLoserType::GOOD_LOSER: -#ifdef RBA_USE_LOG - RBALogManager::cancelRequestLogLine(" Content["+ - state->getOwner()->getElementName()+"::"+ - state->getElementName()+ - "] is Canceled because GOOD_LOSER"); -#endif - setCancel(state, true); - break; - case RBAContentLoserType::NEVER_GIVEUP: -#ifdef RBA_USE_LOG - RBALogManager::cancelRequestLogLine(" Content["+ - state->getOwner()->getElementName()+"::"+ - state->getElementName()+ - "] is not Canceled because NEVER_GIVEUP"); -#endif - setCancel(state, false); - break; - case RBAContentLoserType::DO_NOT_GIVEUP_UNTIL_WIN: - if(state->isModelElementType(RBAModelElementType::ViewContentState)) { - if(result_->isPreVisible(dynamic_cast<const RBAViewContentStateImpl*>(state))) { -#ifdef RBA_USE_LOG - RBALogManager::cancelRequestLogLine(" Content["+ - state->getOwner()->getElementName()+"::"+ - state->getElementName()+ - "] is Canceled because DO_NOT_GIVEUP_UNTIL_WIN"); -#endif - setCancel(state, true); - } else { -#ifdef RBA_USE_LOG - RBALogManager::cancelRequestLogLine(" Content["+ - state->getOwner()->getElementName()+"::"+ - state->getElementName()+ - "] is not Canceled because DO_NOT_GIVEUP_UNTIL_WIN"); -#endif - setCancel(state, false); - } - } - else { - if(result_->isPreSounding(dynamic_cast<const RBASoundContentStateImpl*>(state))) { - setCancel(state, true); - } else { - setCancel(state, false); - } - } - break; - default: - break; - } -} - -#ifdef RBA_USE_LOG -void -RBAArbitrator:: -checkAllConstraints() -{ - std::string log; - LOG_arbitrateConstraintLogLine("----Check All Constraint----"); - - if(simulationMode_) { - for(const RBAConstraintImpl* constraint : model_->getConstraintImpls()) { - bool result = const_cast<RBAConstraintImpl*>(constraint)->execute(this); - if(result == false) { - result_->addFailedConstraint(constraint); - } - if (constraint->isRuntime() == true) { - log += "online "; - } else { - log += "offline "; - } - log += "constraint[" + constraint->getElementName() + "] "; - log += "result[" + RBALogManager::boolToString(result) + "]\n"; - } - if (log.empty() != true ) { - log.erase(log.end() - 1, log.end()); // Remove last line break - } - } - -} -#endif - -void -RBAArbitrator:: -checkCancelContent() const -{ - for(const RBAViewContentState* const viewState - : result_->getActiveViewContentStates()) { - if(result_->isCancel(viewState)) { - result_->cancelContentState(dynamic_cast<const RBAContentState*>(viewState)); - } - } - for(const RBASoundContentState* const soundState - : result_->getActiveSoundContentStates()) { - if(result_->isCancel(soundState)) { - result_->cancelContentState(dynamic_cast<const RBAContentState*>(soundState)); - } - } -} - -/** - * @brief Update display and non-dislay Allocatable List - */ -void -RBAArbitrator:: -updateResult() -{ - // Deactivate canceled Content - result_->updateActiveContentStates(); - - // Update coordinates of Area - for(auto& area : result_->getVisibleAreas()) { - const RBAAreaImpl* const areaImpl {dynamic_cast<const RBAAreaImpl*>(area)}; - const auto posCont = model_->findPositionContainerImpl(area->getName()); - const auto sizeObj = result_->getSize(area); - if((posCont != nullptr) && (sizeObj != nullptr)) { - const auto offset = posCont->getOffset(sizeObj->getName()); - const_cast<RBAAreaImpl*>(areaImpl)->setOffsetX(offset.first); - const_cast<RBAAreaImpl*>(areaImpl)->setOffsetY(offset.second); - } - } - - // Set output Content state list - std::set<const RBAContentState*> outputtingContentStateSet; - for(auto& alloc : result_->getOutputtingAllocatables()) { - const auto state = result_->getAllocatedContentState(alloc); - static_cast<void>(outputtingContentStateSet.insert(state)); - } - for(auto& state : outputtingContentStateSet) { - static_cast<void>(result_->addOutputtingContentState(state)); - } - - for(auto& state : result_->getActiveContentStates()) { - // If the Area allocated in the display request is not displayed, - // set it to "Stanby Content". - const auto allocs = result_->getAllocatable(state); - if(allocs.empty()) { - result_->addStandbyContent(dynamic_cast<RBAContent*>(state->getOwner())); - } - } -} - -/** - * ### Generate result information - * - * Generate animation information (RBAViewAction) and register it in the - * viewActions list of RBAResult. - * The animation information generation pattern is as follows. - * | Area A(pre) | Area B(pre) | Area A(cur) | Area B(cur) | type | - * |:-: |:-: |:-: |:-: |:---- | - * | (none) | - | **content** | - | TRANSITON_ADD | - * | **content** | - | (none) | - | TRANSITION_REMOVE | - * | **contentA** | - | **contentB** | - | TRANSITION_REPLACE | - * | **content** | (none) | (none) | **content** | MOVE | - */ -void -RBAArbitrator:: -createResultData() -{ - std::list<std::unique_ptr<RBAViewAction>> actions; - // Check the Areas that have not changed - std::set<const RBAArea*> stableAreas; - for(const RBAArea* const preArea : result_->getPreVisibleAreas()) { - if(result_->isVisible(preArea)) { - const RBAViewContent* const curContent {result_->getContentState(preArea)->getOwner()}; - const RBAViewContent* const preContent {result_->getPreContentState(preArea)->getOwner()}; - if(curContent == preContent) { - static_cast<void>(stableAreas.insert(preArea)); - } - } - } - // Check "MOVE" - std::set<const RBAViewContent*> movedContents; - for(const RBAArea* curArea : result_->getVisibleAreas()) { - // Current display Area - const RBAViewContentState* curState {result_->getContentState(curArea)}; - const RBAViewContent* const curContent {curState->getOwner()}; - // Skip stable Area - if(stableAreas.find(curArea) != stableAreas.end()) { - continue; - } - for(const RBAArea* preArea : result_->getPreVisibleAreas()) { - // Do not consider stable areas to have changed - if (stableAreas.find(preArea) != stableAreas.end()) { - continue; - } - // Previous display Area - const RBAViewContent* const preContent {result_->getPreContentState(preArea)->getOwner()}; - if(curContent == preContent) { - // "MOVE" if there is matching content - actions.push_back(std::make_unique<RBAViewMove>(preArea, curArea, - curState)); - // Check moved Content - static_cast<void>(movedContents.insert(curState->getOwner())); - } - } - } - // Check "REMOVE" - for(const RBAArea* preArea : result_->getPreVisibleAreas()) { - // Skip stable Area - if(stableAreas.find(preArea) != stableAreas.end()) { - continue; - } - const RBAViewContentState* preState {result_->getPreContentState(preArea)}; - // Skip if Content is "MOVE" - if(movedContents.find(preState->getOwner()) - != movedContents.end()) { - continue; - } - if(!result_->isVisible(preArea)) { - // If the previously displayed Area isn't displayed, it is REMOVE. - actions.push_back(std::make_unique<RBAViewTransition>( - RBAViewActionType::TRANSITION_REMOVE, preArea, preState)); - } - } - // Check Examine ADD/REMOVE and REPLACE related to MOVE - for(const RBAArea* curArea : result_->getVisibleAreas()) { - // Display Area at this time - // Skip stable Area - if(stableAreas.find(curArea) != stableAreas.end()) { - continue; - } - const RBAViewContentState* curState {result_->getContentState(curArea)}; - const RBAViewContent* const curContent {curState->getOwner()}; - const RBAViewContentState* preState {result_->getPreContentState(curArea)}; - - if(movedContents.find(curContent) != movedContents.end()) { - if((preState != nullptr) && (!result_->isVisible(preState))) { - // If the previously displayed content isn't displayed, it is REMOVE. - actions.push_back(std::make_unique<RBAViewTransition>( - RBAViewActionType::TRANSITION_REMOVE, - curArea, preState)); - } - else { - continue; - } - } - else if(result_->isPreVisible(curArea)) { - // It was the display Area last time - // If pre is MOVE content - const RBAViewContent* const preContent {preState->getOwner()}; - if(movedContents.find(preContent) != movedContents.end()) { - // Content at this time is ADD - actions.push_back(std::make_unique<RBAViewTransition>( - RBAViewActionType::TRANSITION_ADD, - curArea, curState)); - } - else if(curContent != preContent) { - // REPLACE because the content is different - actions.push_back(std::make_unique<RBAViewTransition>( - RBAViewActionType::TRANSITION_REPLACE, - curArea, preState, curState)); - } else { - ; - } - } - else { - // ADD because it was not the display Area last time - actions.push_back(std::make_unique<RBAViewTransition>( - RBAViewActionType::TRANSITION_ADD, - curArea, curState)); - } - } - - // Sort and register - actions.sort(&compareViewAction); - for(auto& action : actions) { - result_->addViewAction(action); - } -} - -void -RBAArbitrator::differenceArbitrate() -{ -#ifdef RBA_USE_LOG - // Set request information in log - RBALogManager::setType(RBALogManager::TYPE_REQUEST); - logRequestArbitration(); - RBALogManager::setType(RBALogManager::TYPE_PREVIOUS_RESULT); - logPreResultArbitration(); - logRequestForCoverage(); -#endif - - for (auto& a : model_->getSortedAllocatables()) { - a->clearStatus(); - } - - // ---------------------------------------------------------- - // Arbitration - // ---------------------------------------------------------- - // Priority and post-win arbitoration - // (Value arbitration is the same as priority arbitration) -#ifdef RBA_USE_LOG -RBALogManager::setType(RBALogManager::TYPE_ARBITRATE); -#endif - arbitrate(model_->getSortedAllocatables()); - - // ---------------------------------------------------------- - // Post processing of arbitration - // ---------------------------------------------------------- -#ifdef RBA_USE_LOG -RBALogManager::setType(RBALogManager::TYPE_CANCEL_REQUEST); -#endif - // when the constraint expression is evaluated by satisfiesConstraints(), - // if the cancel state is different from the time when execute() is executed, - // the result may be false. Therefore, it is necessary to store - // the state before cancellation processing. - // When performing the constraint expression evaluation in - // satisfiedConstraints(), restore to this value and evaluate. - resultSetForSatisfiesConstraints_ = std::make_unique<RBAResultSet>( - *result_->getCurResultSet()); - postArbitrate(); - - // Move offline Constraint -#ifdef RBA_USE_LOG -RBALogManager::setType(RBALogManager::TYPE_CHECK_ALL_CONSTRAINTS); - checkAllConstraints(); -#endif - - // ---------------------------------------------------------- - // Update Content state - // ---------------------------------------------------------- - for (auto& c : model_->getContents()){ - const_cast<RBAContent*>(c)->updateStatus(result_.get()); - } - - backupResultSet_ = result_->createBackupCurrentResultSet(); - nextResultSet_ = result_->createNextCurrentResultSet(); - -#ifdef RBA_USE_LOG - logResultForCoverage(); -#endif -} - -bool -RBAArbitrator:: -checkConstraints( std::list<RBAConstraintImpl*>& constraints, - std::list<RBAConstraintImpl*>& falseConstraints, - const RBAAllocatable* const allocatable) -{ - bool containsSkip {false}; - for (const auto& constraint : constraints) { - const bool isPassed {constraint->execute(this)}; - if (isPassed == false) { - falseConstraints.push_back(constraint); - } - if (constraint->getInfo()->isExceptionBeforeArbitrate()) { - if (constraint->getInfo()->needsReRearbitrationFor(allocatable)) { - containsSkip = true; - } - } - } - return containsSkip; -} - -bool -RBAArbitrator:: -checkConstraintAndReArbitrate(RBAAllocatable* allocatable, - std::set<const RBAAllocatable*>& revisited, - const std::int32_t nest, - RBAAffectInfo* const affectInfo, - RBARollbacker* const parentRollbacker, - std::list<RBAConstraintImpl*>& constraints, - bool * const isSkipped, - const bool isFinal) -{ - bool isPassed {false}; - std::list<RBAConstraintImpl*> falseConstraints; - const bool containsSkip {checkConstraints(constraints, falseConstraints, allocatable)}; - if(falseConstraints.empty()) { - *isSkipped = (*isSkipped || containsSkip); - if(!containsSkip && !*isSkipped && isFinal) { - static_cast<void>(revisited.insert(allocatable)); - } - isPassed = true; - } else { - std::list<const RBAAllocatable*> revisitAllocatables; - collectRevisitAllocatable(&revisitAllocatables, allocatable, falseConstraints, revisited); - if(!(revisitAllocatables.empty())) { - // There is re-arbitration Allocatable. - // Generates backup information for rollback when re-arbitration fails. - // For efficiency, instantiate only once when re-arbitration is needed - // for the first time. - // Since it is backed up after content allocation, - // it is necessary to set NULL to the allocated content after rollback. - - // Rollback information when arbitration fails - std::shared_ptr<RBARollbacker> rollbacker {std::make_shared<RBARollbacker>()}; - if (parentRollbacker != nullptr) { - parentRollbacker->addChild(rollbacker); - } - rollbacker->backup(revisitAllocatables); - // Initialize all re-arbitration Allocatable - for (auto& a : revisitAllocatables) { - const_cast<RBAAllocatable*>(a)->clearChecked(); - } - // -------------------------------------------------- - // Re-arbitrate "Allocatable" that has not been re-arbitrated - // in the re-arbitration candidate list - // -------------------------------------------------- - static_cast<void>(revisited.insert(allocatable)); - for(const RBAAllocatable* const revisitAllocatable : revisitAllocatables) { - LOG_arbitrateAreaLogLine( " " + - revisitAllocatable->getSymbol() + "[" - + revisitAllocatable->getElementName() - + "] revisit allocatable check start"); - arbitrateAllocatable(const_cast<RBAAllocatable*>(revisitAllocatable), - revisited, nest + 1, affectInfo, rollbacker.get()); - } - for(const RBAAllocatable* const revisitAllocatable : revisitAllocatables) { - static_cast<void>(revisited.erase(revisitAllocatable)); - } - // -------------------------------------------------- - // Check if content allocation succeeded as a result of re-arbitration - // -------------------------------------------------- - falseConstraints.clear(); - static_cast<void>(checkConstraints(constraints, falseConstraints, allocatable)); - if (falseConstraints.empty()) { - // The content of the allocatable allocation is fixed by re-arbitration, - // so exit the loop and proceed to the next allocatable. - // In some cases, "Allocatable" is re-arbitrated due to recursion and - // allocated Content is lost, but go to the next Allocable because - // all contents have been checked - isPassed = true; - } else { - // Roll back arbitration status and affected information - rollbacker->rollback(); - if (parentRollbacker != nullptr) { - parentRollbacker->removeChild(rollbacker); - } - } - } - } - if (isPassed == false) { - //Collect Areas that affected the area in arbitration status - std::set<const RBAAllocatable*> allocatablesWhichHaveAffectedToThisAllocatable; - - for (const RBAConstraintImpl* const constraint : falseConstraints) { - constraint->getInfo()->collectAffectedAllocatables( - false, allocatablesWhichHaveAffectedToThisAllocatable, false, - false); - } - static_cast<void>(allocatablesWhichHaveAffectedToThisAllocatable.erase(allocatable)); - - // Record fact that affected the area being arbitrated on Area that - // affected Area during arbitration. - // The re-arbitration of the affected area is recorded in AffectInfo, - // so it does not record the re-arbitrated area. - for (const RBAAllocatable* const a : allocatablesWhichHaveAffectedToThisAllocatable) { - if (!(affectInfo->alreadyKnowsThatFormerHasAffectedToLatter(a, - allocatable))) { - const_cast<RBAAllocatable*>(a)->addAllocatableWhichHasBeenAffectedByYou( - allocatable); - affectInfo->addInfoThatFormerAffectedToLatter(a, allocatable); - } - } - } - return isPassed; -} - -void -RBAArbitrator:: -setCancel(const RBAContentState* const state, const bool checked) -{ - result_->setCancel(state, checked); -} - -bool -RBAArbitrator:: -isCancel(const RBAContentState* const state) const -{ - if(state->isViewContentState()) { - return result_->isCancel(state); - } - else { - return result_->isCancel(state); - } -} - -void -RBAArbitrator:: -getSortedContentStates(const RBAAllocatable* const allocatable, - std::list<const RBAContentState*>& contentStates) const -{ - for (const RBAContent* const content : allocatable->getInternalContents()) { - const RBAContentState* const state {result_->getActiveState(content)}; - if (state != nullptr) { - contentStates.push_back(state); -#ifdef RBA_USE_LOG - } else { - RBALogManager::arbitrateContentLogLine( - " Content[" + content->getElementName() + "] is not Active skip"); -#endif - } - } - static_cast<void>(sortContentStates(allocatable, contentStates)); - // Add null at the end, to evaluate constraint expression when unassigned - contentStates.push_back(nullptr); -} - -std::int32_t -RBAArbitrator:: -getViewActionPriority(const RBAViewActionType viewActionType) -{ - std::int32_t result{0}; - - switch(viewActionType) { - case RBAViewActionType::TRANSITION_REMOVE: - result = 4; - break; - case RBAViewActionType::MOVE: - result = 3; - break; - case RBAViewActionType::TRANSITION_ADD: - result = 2; - break; - case RBAViewActionType::TRANSITION_REPLACE: - result = 1; - break; - default: - break; - } - - return result; -} - -bool -RBAArbitrator:: -compareViewAction(const std::unique_ptr<RBAViewAction>& lhs, - const std::unique_ptr<RBAViewAction>& rhs) -{ - const std::int32_t lval {getViewActionPriority(lhs->getViewActionType())}; - const std::int32_t rval {getViewActionPriority(rhs->getViewActionType())}; - - return lval > rval; -} - -RBAResultImpl* -RBAArbitrator::getResult() const -{ - return result_.get(); -} - -void RBAArbitrator::setResult(std::unique_ptr<RBAResultImpl> result) -{ - result_ = std::move(result); -} - -std::set<const RBAContentState*>& RBAArbitrator::getCancelChecked() -{ - return cancelChecked_; -} - -std::unique_ptr<RBAResultImpl>& RBAArbitrator::getResultRef() const -{ - return result_; -} - -std::unique_ptr<RBAResultSet>& RBAArbitrator::getNextResultSet() -{ - return nextResultSet_; -} - -void RBAArbitrator::setNextResultSet(std::unique_ptr<RBAResultSet> nextResultSet) -{ - nextResultSet_ = std::move(nextResultSet); -} - -std::unique_ptr<RBAResultSet>& RBAArbitrator::getBackupResultSet() -{ - return backupResultSet_; -} - -void RBAArbitrator::setBackupResultSet(std::unique_ptr<RBAResultSet> backupResultSet) -{ - backupResultSet_ = std::move(backupResultSet); -} - -std::unique_ptr<RBAResultSet>& RBAArbitrator::getReservedResultSet() -{ - return reservedResultSet_; -} - -void RBAArbitrator::setReservedResultSet(std::unique_ptr<RBAResultSet> reservedResultSet) -{ - reservedResultSet_ = std::move(reservedResultSet); -} - -std::recursive_mutex& RBAArbitrator::getMutex() const -{ - return mutex_; -} - -#ifdef RBA_USE_LOG -void RBAArbitrator::setSimulationMode(bool simulationMode) -{ - simulationMode_ = simulationMode; -} -#endif - -std::deque<std::unique_ptr<RBARequestQueMember>>& RBAArbitrator::getRequestQue() -{ - return requestQue_; -} - -#ifdef RBA_USE_LOG -/** - * Output request information for log view - */ -void -RBAArbitrator::logRequestArbitration() -{ - const std::list<const RBAAllocatable*> allocatables = - model_->getAllocatables(); - RBALogManager::requestLogLine("----Request Information----"); - RBALogManager::requestLogLine( - "Allocatable Count:" + std::to_string(allocatables.size())); - for (const RBAAllocatable* allocatable : allocatables) { - RBALogManager::requestLogLine( - " " + allocatable->getSymbol() + "[" + allocatable->getElementName() - + "] policy[" + allocatable->getArbitrationPolicyString() - + "] visibility[" + allocatable->getVisibilityString() + "]"); - } - - const std::list<const RBAContentState*> contentStates = model_ - ->getContentStates(); - RBALogManager::requestLogLine( - "ContentState Count:" + std::to_string(contentStates.size())); - for (const RBAContentState* contentState : contentStates) { - std::string active; - if (contentState->getModelElementType() == RBAModelElementType::ViewContentState) { - active = RBALogManager::boolToString( - result_->isActive( - dynamic_cast<const RBAViewContentState*>(contentState))); - } else { - active = RBALogManager::boolToString( - result_->isActive( - dynamic_cast<const RBASoundContentState*>(contentState))); - } - RBALogManager::requestLogLine( - " " + dynamic_cast<RBAContent*>(contentState->getOwner())->getSymbol() + "[" - + contentState->getOwner()->getElementName() + "::" - + contentState->getElementName() + "] priority[" - + contentState->getPriorityString() + "] isActive[" + active - + "] order[" + contentState->getOrderString() + "]"); - } - - const std::list<const RBAScene*> scenes = model_->getScenes(); - RBALogManager::requestLogLine("Scene Count:" + std::to_string(scenes.size())); - for (const RBAScene* scene : scenes) { - RBALogManager::requestLogLine( - " Scene[" + scene->getName() + "] isActive[" - + RBALogManager::boolToString(result_->isActive(scene)) - + "]"); - } - - std::list<RBAConstraint*> constraints = model_->getConstraints(); - RBALogManager::requestLogLine( - "Constraint Count:" + std::to_string(constraints.size())); - for (RBAConstraint* constraint : constraints) { - RBAConstraintImpl* impl = dynamic_cast<RBAConstraintImpl*>(constraint); - RBALogManager::requestLogLine( - " Constraint[" + impl->getName() + "] Expression[" - + impl->getExpression()->getExpressionText() + "] runtime[" - + RBALogManager::boolToString(impl->isRuntime()) + "]"); - } - -} - -/** - * Output previous arbitration result for log view - */ -void -RBAArbitrator::logPreResultArbitration() -{ - RBALogManager::resultLogLine("----Previous Result Information----"); - - auto allocs = model_->getAllocatables(); - RBALogManager::resultLogLine("Allocatable TotalCount:" - + std::to_string(allocs.size())); - for (auto& alloc : allocs) { - auto contentState = result_->getPreContentState(alloc); - auto hidden = result_->isPreHidden(alloc); - std::string str = " " + alloc->getSymbol() - + "[" + alloc->getElementName() + "] Content["; - if (contentState == nullptr) { - str += "null"; - } else { - str += contentState->getOwner()->getElementName() - + "::" + contentState->getElementName(); - } - str += "] " + alloc->getHiddenSymbol() - + "[" + RBALogManager::boolToString(hidden) + "]"; - if (alloc->isZone() == true) { - str += " attenuated["; - str += RBALogManager::boolToString( - result_->isPreAttenuated(dynamic_cast<const RBAZone*>(alloc))); - str += "]"; - } - RBALogManager::resultLogLine(str); - if (contentState && !hidden) { - RBALogManager::coveragePrevResultLogLine( - "A," + alloc->getElementName() + "," - + contentState->getOwner()->getElementName() + "," - + contentState->getElementName()); - } - } - - auto contents = model_->getContents(); - RBALogManager::resultLogLine("Content TotalCount:" - + std::to_string(contents.size())); - for (auto& content : contents) { - auto state = result_->getPreActiveState(content); - bool isOutputting = false; - bool isActive = false; - if (state != nullptr) { - isActive = true; - isOutputting = result_->isPreOutputting(state); - } - RBALogManager::resultLogLine( - " " + content->getSymbol() + "[" + content->getElementName() + "] " - + content->getVisibleSymbol() + "[" - + RBALogManager::boolToString(isOutputting) + "] active[" - + RBALogManager::boolToString(isActive) + "]"); - for (auto alloc : content->getAllocatables()) { - auto allocatedState = result_->getPreContentState(alloc); - if ((allocatedState != nullptr) - && (allocatedState->getOwner() == content)) { - RBALogManager::resultLogLine( - " allocated " + alloc->getSymbol() + "[" - + alloc->getElementName() + "]"); - } - } - } -} - -/** - * Output current arbitration result for log view - */ -void -RBAArbitrator::logResultArbitration() -{ - RBALogManager::resultLogLine("----Result Information----"); - - const std::list<const RBAAllocatable*> allocatables - = model_->getAllocatables(); - RBALogManager::resultLogLine("Allocatable TotalCount:" + std::to_string(allocatables.size())); - for(const RBAAllocatable* allocatable : allocatables) { - const RBAContentState* contentState = result_->getContentState(allocatable); - std::string str = " "; - str += allocatable->getSymbol(); - str += "["; - str += allocatable->getElementName(); - str += "] Content["; - if (contentState == nullptr) { - str += "null"; - } else { - str += contentState->getOwner()->getElementName() + "::" - + contentState->getElementName(); - } - str += "] "; - str += allocatable->getHiddenSymbol(); - str += "["; - str += RBALogManager::boolToString(result_->isHidden(allocatable)); - str += "]"; - if (allocatable->isZone() == true) { - str += " attenuated["; - str += RBALogManager::boolToString(result_->isAttenuated(dynamic_cast<const RBAZone*>(allocatable))); - str += "]"; - } - RBALogManager::resultLogLine(str); - } - - const std::list<const RBAContent*> contents = model_->getContents(); - RBALogManager::resultLogLine("Content TotalCount:" + std::to_string(contents.size())); - for(const RBAContent* content : contents) { - bool isOutputting = false; - bool isCancel = false; - const RBAContentState* state = result_->getActiveState(content); - if(state != nullptr) { - isOutputting = result_->isOutputting(state); - } else { - for(const RBAContentState* state : content->getStates()) { - isCancel |= result_->isCancel(state); - } - } - RBALogManager::resultLogLine(" " - + content->getSymbol() - + "[" - + content->getElementName() - + "] " - + content->getVisibleSymbol() - + "[" - + RBALogManager::boolToString(isOutputting) - + "] cancel[" - + RBALogManager::boolToString(isCancel) - + "]"); - for(const RBAAllocatable* allocatable : content->getAllocatables()) { - const RBAContentState* allocatedState - = result_->getContentState(allocatable); - if((allocatedState != nullptr) && (allocatedState->getOwner() == content)) { - RBALogManager::resultLogLine(" allocated " - + allocatable->getSymbol() + "[" - + allocatable->getElementName() + "]"); - } - } - } -} - -/** - * For coverage: Output request information - */ -void -RBAArbitrator::logRequestForCoverage() -{ - for(const RBAContentState* contentState : model_->getContentStates()) { - std::ostringstream oss; - oss << "C,"; - if(result_->isActive(contentState)) { - oss << "on,"; - } - else { - oss << "off,"; - } - oss << contentState->getOwner()->getElementName() << ","; - oss << contentState->getElementName() << ","; - oss << contentState->getContentStateOrder(); - RBALogManager::coverageRequestLogLine(oss.str()); - } - for(const RBAScene* scene : model_->getScenes()) { - std::ostringstream oss; - oss << "S,"; - if(result_->isActive(scene)) { - oss << "on,"; - } - else { - oss << "off,"; - } - oss << scene->getName(); - for(const auto& name : scene->getPropertyNames()) { - std::int32_t value {result_->getSceneProperty(scene, name)}; - oss << ","; - oss << name; - oss << ":"; - oss << value; - } - RBALogManager::coverageRequestLogLine(oss.str()); - } -} - -/** - * For coverage: Output result information - */ -void -RBAArbitrator::logResultForCoverage() -{ - for(const RBAAllocatable* allocatable : model_->getAllocatables()) { - std::ostringstream oss; - oss << "A,"; - oss << allocatable->getElementName() + ","; - const RBAContentState* contentState = result_->getContentState(allocatable); - if((contentState != nullptr) && (!result_->isHidden(allocatable))) { - oss << contentState->getOwner()->getElementName(); - } - RBALogManager::coverageResultLogLine(oss.str()); - } -} - -void -RBAArbitrator::setLogToResult() -{ - std::ostringstream oss; - oss << RBALogManager::getAllConstraintLog(); - oss << RBALogManager::getRequestLog(); - oss << RBALogManager::getPreviousResultLog(); - oss << RBALogManager::getArbitrateLog(); - oss << RBALogManager::getCancelRequestLog(); - oss << RBALogManager::getCheckAllConstraintLog(); - oss << RBALogManager::getResultLog(); - result_->setLog(oss.str()); -} -#endif - -} +}
\ No newline at end of file |