From faee1dfeeeeec169f023b314448de27e9703c3dc Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Mon, 21 Nov 2016 22:05:10 +0100 Subject: [PATCH 01/47] updated dft->gspn translation to now have basis support for spares --- src/storm-dft-cli/storm-dyftee.cpp | 6 + .../dft/DftToGspnTransformator.cpp | 923 ++++++++++++++++++ .../dft/DftToGspnTransformator.h | 174 ++++ 3 files changed, 1103 insertions(+) create mode 100644 src/storm/transformations/dft/DftToGspnTransformator.cpp create mode 100644 src/storm/transformations/dft/DftToGspnTransformator.h diff --git a/src/storm-dft-cli/storm-dyftee.cpp b/src/storm-dft-cli/storm-dyftee.cpp index 6ed375d79..71f5cea86 100644 --- a/src/storm-dft-cli/storm-dyftee.cpp +++ b/src/storm-dft-cli/storm-dyftee.cpp @@ -4,6 +4,7 @@ #include "storm/cli/cli.h" #include "storm/exceptions/BaseException.h" #include "storm/utility/macros.h" +#include "storm/transformations/dft/DftToGspnTransformator.h" #include "storm/settings/modules/GeneralSettings.h" #include "storm/settings/modules/CoreSettings.h" @@ -78,6 +79,11 @@ template storm::gspn::GSPN transformDFT(std::string filename) { storm::parser::DFTGalileoParser parser; storm::storage::DFT dft = parser.parseDFT(filename); +<<<<<<< f8986fe6139bddaf5068477b0f70ac1f806f8576:src/storm-dft-cli/storm-dyftee.cpp +======= + storm::transformations::dft::DftToGspnTransformator gspnTransformator(dft); + gspnTransformator.transform(); +>>>>>>> updated dft->gspn translation to now have basis support for spares:src/storm/storm-dyftee.cpp } /*! diff --git a/src/storm/transformations/dft/DftToGspnTransformator.cpp b/src/storm/transformations/dft/DftToGspnTransformator.cpp new file mode 100644 index 000000000..4331e0c62 --- /dev/null +++ b/src/storm/transformations/dft/DftToGspnTransformator.cpp @@ -0,0 +1,923 @@ +#include "DftToGspnTransformator.h" +#include "storm/exceptions/NotImplementedException.h" +#include + +namespace storm { + namespace transformations { + namespace dft { + + // Prevent some magic constants + static constexpr const uint64_t defaultPriority = 0; + static constexpr const uint64_t defaultCapacity = 0; + + template + DftToGspnTransformator::DftToGspnTransformator(storm::storage::DFT const& dft) : mDft(dft) { + // Intentionally left empty. + } + + template + void DftToGspnTransformator::transform() { + + builder.setGspnName("DftToGspnTransformation"); + + // Loop through every DFT element and draw them as a GSPN. + drawGSPNElements(); + + // When all DFT elements are drawn, draw the connections between them. + drawGSPNConnections(); + + // Draw functional/probability dependencies into the GSPN. + drawGSPNDependencies(); + + // Draw restrictions into the GSPN (i.e. SEQ or MUTEX). + drawGSPNRestrictions(); + + // Write GSPN to file. + writeGspn(true); + } + + template + void DftToGspnTransformator::drawGSPNElements() { + + + // Loop through every DFT element and draw them as a GSPN. + for (std::size_t i = 0; i < mDft.nrElements(); i++) { + auto dftElement = mDft.getElement(i); + bool isRepresentative = mDft.isRepresentative(i); + + // Check which type the element is and call the corresponding drawing-function. + switch (dftElement->type()) { + case storm::storage::DFTElementType::AND: + drawAND(std::static_pointer_cast const>(dftElement), isRepresentative); + break; + case storm::storage::DFTElementType::OR: + drawOR(std::static_pointer_cast const>(dftElement), isRepresentative); + break; + case storm::storage::DFTElementType::VOT: + drawVOT(std::static_pointer_cast const>(dftElement), isRepresentative); + break; + case storm::storage::DFTElementType::PAND: + drawPAND(std::static_pointer_cast const>(dftElement), isRepresentative); + break; + case storm::storage::DFTElementType::SPARE: + drawSPARE(std::static_pointer_cast const>(dftElement), isRepresentative); + break; + case storm::storage::DFTElementType::POR: + drawPOR(std::static_pointer_cast const>(dftElement), isRepresentative); + break; + case storm::storage::DFTElementType::SEQ: + // No method call needed here. SEQ only consists of restrictions, which are handled later. + break; + case storm::storage::DFTElementType::MUTEX: + // No method call needed here. MUTEX only consists of restrictions, which are handled later. + break; + case storm::storage::DFTElementType::BE: + drawBE(std::static_pointer_cast const>(dftElement), isRepresentative); + break; + case storm::storage::DFTElementType::CONSTF: + drawCONSTF(dftElement, isRepresentative); + break; + case storm::storage::DFTElementType::CONSTS: + drawCONSTS(dftElement, isRepresentative); + break; + case storm::storage::DFTElementType::PDEP: + drawPDEP(std::static_pointer_cast const>(dftElement), isRepresentative); + break; + default: + STORM_LOG_ASSERT(false, "DFT type unknown."); + break; + } + } + + } + + template + void DftToGspnTransformator::drawBE(std::shared_ptr const> dftBE, bool isRepresentative) { + + uint64_t beActive = builder.addPlace(defaultCapacity, isBEActive(dftBE) ? 1 : 0, dftBE->name() + STR_ACTIVATED); + activeNodes.emplace(dftBE->id(), beActive); + uint64_t beFailed = builder.addPlace(defaultCapacity, 0, dftBE->name() + STR_FAILED); + + uint64_t unavailableNode = 0; + if (isRepresentative) { + unavailableNode = addUnavailableNode(dftBE); + } + + assert(failedNodes.size() == dftBE->id()); + failedNodes.push_back(beFailed); + uint64_t tActive = builder.addTimedTransition(defaultPriority, dftBE->activeFailureRate(), dftBE->name() + "_activeFailing"); + builder.addInputArc(beActive, tActive); + builder.addInhibitionArc(beFailed, tActive); + builder.addOutputArc(tActive, beActive); + builder.addOutputArc(tActive, beFailed); + uint64_t tPassive = builder.addTimedTransition(defaultPriority, dftBE->passiveFailureRate(), dftBE->name() + "_passiveFailing"); + builder.addInhibitionArc(beActive, tPassive); + builder.addInhibitionArc(beFailed, tPassive); + builder.addOutputArc(tPassive, beFailed); + + if (isRepresentative) { + builder.addOutputArc(tActive, unavailableNode); + builder.addOutputArc(tPassive, unavailableNode); + } + } + + template + void DftToGspnTransformator::drawAND(std::shared_ptr const> dftAnd, bool isRepresentative) { + uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftAnd->name() + STR_FAILED); + assert(failedNodes.size() == dftAnd->id()); + failedNodes.push_back(nodeFailed); + + uint64_t unavailableNode = 0; + if (isRepresentative) { + unavailableNode = addUnavailableNode(dftAnd); + } + + + uint64_t tAndFailed = builder.addImmediateTransition( getFailPriority(dftAnd) , 0.0, dftAnd->name() + STR_FAILING ); + builder.addInhibitionArc(nodeFailed, tAndFailed); + builder.addOutputArc(tAndFailed, nodeFailed); + if (isRepresentative) { + builder.addOutputArc(tAndFailed, unavailableNode); + } + for(auto const& child : dftAnd->children()) { + assert(failedNodes.size() > child->id()); + builder.addInputArc(failedNodes[child->id()], tAndFailed); + } + + } + + template + void DftToGspnTransformator::drawOR(std::shared_ptr const> dftOr, bool isRepresentative) { + uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftOr->name() + STR_FAILED); + assert(failedNodes.size() == dftOr->id()); + failedNodes.push_back(nodeFailed); + uint64_t unavailableNode = 0; + if (isRepresentative) { + unavailableNode = addUnavailableNode(dftOr); + } + + uint64_t i = 0; + for (auto const& child : dftOr->children()) { + uint64_t tNodeFailed = builder.addImmediateTransition( getFailPriority(dftOr) , 0.0, dftOr->name() + STR_FAILING + std::to_string(i) ); + builder.addInhibitionArc(nodeFailed, tNodeFailed); + builder.addOutputArc(tNodeFailed, nodeFailed); + if (isRepresentative) { + builder.addOutputArc(tNodeFailed, unavailableNode); + } + assert(failedNodes.size() > child->id()); + builder.addInputArc(failedNodes[child->id()], tNodeFailed); + ++i; + } + } + + template + void DftToGspnTransformator::drawVOT(std::shared_ptr const> dftVot, bool isRepresentative) { + uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftVot->name() + STR_FAILED); + assert(failedNodes.size() == dftVot->id()); + failedNodes.push_back(nodeFailed); + uint64_t unavailableNode = 0; + if (isRepresentative) { + unavailableNode = addUnavailableNode(dftVot); + } + + uint64_t nodeCollector = builder.addPlace(dftVot->nrChildren(), 0, dftVot->name() + "_collector"); + uint64_t tNodeFailed = builder.addImmediateTransition(getFailPriority(dftVot), 0.0, dftVot->name() + STR_FAILING); + builder.addOutputArc(tNodeFailed, nodeFailed); + if (isRepresentative) { + builder.addOutputArc(tNodeFailed, unavailableNode); + } + builder.addInhibitionArc(nodeFailed, tNodeFailed); + builder.addInputArc(nodeCollector, tNodeFailed, dftVot->threshold()); + builder.addOutputArc(tNodeFailed, nodeCollector, dftVot->threshold()); + uint64_t i = 0; + for (auto const& child : dftVot->children()) { + uint64_t childInhibPlace = builder.addPlace(1, 0, dftVot->name() + "_child_fail_inhib" + std::to_string(i)); + uint64_t tCollect = builder.addImmediateTransition(getFailPriority(dftVot), 0.0, dftVot->name() + "_child_collect" + std::to_string(i)); + builder.addOutputArc(tCollect, nodeCollector); + builder.addOutputArc(tCollect, childInhibPlace); + builder.addInhibitionArc(childInhibPlace, tCollect); + builder.addInputArc(failedNodes[child->id()], tCollect); + ++i; + } + } + + template + void DftToGspnTransformator::drawPAND(std::shared_ptr const> dftPand, bool isRepresentative) { + uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftPand->name() + STR_FAILED); + assert(failedNodes.size() == dftPand->id()); + failedNodes.push_back(nodeFailed); + uint64_t unavailableNode = 0; + if (isRepresentative) { + unavailableNode = addUnavailableNode(dftPand); + } + + uint64_t nodeFS = builder.addPlace(defaultCapacity, 0, dftPand->name() + STR_FAILSAVE); + uint64_t tNodeFailed = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILING); + builder.addInhibitionArc(nodeFailed, tNodeFailed); + builder.addInhibitionArc(nodeFS, tNodeFailed); + builder.addOutputArc(tNodeFailed, nodeFailed); + if (isRepresentative) { + builder.addOutputArc(tNodeFailed, nodeFailed); + } + for(auto const& child : dftPand->children()) { + builder.addInputArc(failedNodes[child->id()], tNodeFailed); + } + for (uint64_t j = 1; j < dftPand->nrChildren(); ++j) { + uint64_t tfs = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILSAVING + std::to_string(j)); + builder.addInputArc(failedNodes[dftPand->children().at(j)->id()], tfs); + builder.addInhibitionArc(failedNodes[dftPand->children().at(j-1)->id()], tfs); + builder.addOutputArc(tfs, nodeFS); + + } + } +// + template + void DftToGspnTransformator::drawSPARE(std::shared_ptr const> dftSpare, bool isRepresentative) { + + uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftSpare->name() + STR_FAILED); + failedNodes.push_back(nodeFailed); + uint64_t unavailableNode = 0; + if (isRepresentative) { + unavailableNode = addUnavailableNode(dftSpare); + } + uint64_t spareActive = builder.addPlace(defaultCapacity, 0, dftSpare->name() + STR_ACTIVATED); + activeNodes.emplace(dftBE->id(), beActive); + + + std::vector cucNodes; + std::vector nextClaimNodes; + std::vector nextclTransitions; + std::vector nextconsiderTransitions; + uint64_t j = 0; + for(auto const& child : dftSpare->children()) { + if (j > 0) { + nextClaimNodes.push_back(builder.addPlace(defaultCapacity, 0, dftSpare->name()+ "_consider_" + child->name())); + + builder.addOutputArc(nextclTransitions.back(), nextClaimNodes.back(), 1); + if (j > 1) { + builder.addOutputArc(nextconsiderTransitions.back(), nextClaimNodes.back()); + } + + uint64_t tnextconsider = builder.addImmediateTransition(getFailPriority(dftSpare), 0.0, dftSpare->name() + "_cannot_claim_" + child->name()); + builder.addInputArc(nextClaimNodes.back(), tnextconsider); + builder.addInputArc(unavailableNodes.at(child->id()), tnextconsider); + nextconsiderTransitions.push_back(tnextconsider); + + } + cucNodes.push_back(builder.addPlace(defaultCapacity, j == 0 ? 1 : 0, dftSpare->name() + "_claimed_" + child->name())); + if (j > 0) { + uint64 tclaim = builder.addImmediateTransition(getFailPriority(dftSpare), 0.0, dftSpare->name() + "_claim_" + child->name()); + builder.addInhibitionArc(unavailableNodes.at(child->id()), tclaim); + builder.addInputArc(nextClaimNodes.back(), tclaim); + builder.addOutputArc(tclaim, cucNodes.back()); + } + uint64_t tnextcl = builder.addImmediateTransition(getFailPriority(dftSpare), 0.0, dftSpare->name() + "_next_claim_" + std::to_string(j)); + builder.addInputArc(cucNodes.back(), tnextcl); + builder.addOutputArc(tnextcl, cucNodes.back()); + builder.addInputArc(failedNodes.at(child->id()), tnextcl); + builder.addOutputArc(tnextcl, failedNodes.at(child->id())); + nextclTransitions.push_back(tnextcl); + + + ++j; + } + builder.addOutputArc(nextconsiderTransitions.back(), nodeFailed); + builder.addOutputArc(nextclTransitions.back(), nodeFailed); + + if (isRepresentative) { + builder.addOutputArc(nextconsiderTransitions.back(), unavailableNode); + builder.addOutputArc(nextclTransitions.back(), unavailableNode); + } + + +// uint_fast64_t priority = getPriority(0, dftSpare); +// +// // This codeblock can be removed later, when I am 100% sure it is not needed anymore. +// /* +// storm::gspn::Place placeSPAREActivated; +// placeSPAREActivated.setName(dftSpare->name() + STR_ACTIVATED); +// placeSPAREActivated.setNumberOfInitialTokens(isBEActive(dftSpare)); +// mGspn.addPlace(placeSPAREActivated); +// +// storm::gspn::ImmediateTransition immediateTransitionPCActivating; +// immediateTransitionPCActivating.setName(dftSpare->children()[0]->name() + STR_ACTIVATING); +// immediateTransitionPCActivating.setPriority(priority); +// immediateTransitionPCActivating.setWeight(0.0); +// immediateTransitionPCActivating.setInputArcMultiplicity(placeSPAREActivated, 1); +// immediateTransitionPCActivating.setOutputArcMultiplicity(placeSPAREActivated, 1); +// mGspn.addImmediateTransition(immediateTransitionPCActivating); +// */ +// +// auto children = dftSpare->children(); +// +// // Draw places and transitions that belong to each spare child. +// for (std::size_t i = 1; i < children.size(); i++) { +// auto placeChildClaimedPreexist = mGspn.getPlace(children[i]->name() + "_claimed"); +// +// if (!placeChildClaimedPreexist.first) { // Only draw this place if it doesn't exist jet. +// storm::gspn::Place placeChildClaimed; +// placeChildClaimed.setName(children[i]->name() + "_claimed"); +// placeChildClaimed.setNumberOfInitialTokens(0); +// mGspn.addPlace(placeChildClaimed); +// +// storm::gspn::ImmediateTransition immediateTransitionSpareChildActivating; +// immediateTransitionSpareChildActivating.setName(children[i]->name() + STR_ACTIVATING); +// immediateTransitionSpareChildActivating.setPriority(priority); +// immediateTransitionSpareChildActivating.setWeight(0.0); +// immediateTransitionSpareChildActivating.setInputArcMultiplicity(placeChildClaimed, 1); +// immediateTransitionSpareChildActivating.setOutputArcMultiplicity(placeChildClaimed, 1); +// mGspn.addImmediateTransition(immediateTransitionSpareChildActivating); +// } +// +// auto placeChildClaimedExist = mGspn.getPlace(children[i]->name() + "_claimed"); +// +// storm::gspn::Place placeSPAREClaimedChild; +// placeSPAREClaimedChild.setName(dftSpare->name() + "_claimed_" + children[i]->name()); +// placeSPAREClaimedChild.setNumberOfInitialTokens(0); +// mGspn.addPlace(placeSPAREClaimedChild); +// +// storm::gspn::ImmediateTransition immediateTransitionChildClaiming; +// immediateTransitionChildClaiming.setName(dftSpare->name() + "_claiming_" + children[i]->name()); +// immediateTransitionChildClaiming.setPriority(priority + 1); // Higher priority needed! +// immediateTransitionChildClaiming.setWeight(0.0); +// immediateTransitionChildClaiming.setInhibitionArcMultiplicity(placeChildClaimedExist.second, 1); +// immediateTransitionChildClaiming.setOutputArcMultiplicity(placeChildClaimedExist.second, 1); +// immediateTransitionChildClaiming.setOutputArcMultiplicity(placeSPAREClaimedChild, 1); +// mGspn.addImmediateTransition(immediateTransitionChildClaiming); +// +// storm::gspn::Place placeSPAREChildConsumed; +// if (i < children.size() - 1) { +// placeSPAREChildConsumed.setName(dftSpare->name() + "_" + children[i]->name() + "_consumed"); +// } +// else { +// placeSPAREChildConsumed.setName(dftSpare->name() + STR_FAILED); +// } +// placeSPAREChildConsumed.setNumberOfInitialTokens(0); +// mGspn.addPlace(placeSPAREChildConsumed); +// +// storm::gspn::ImmediateTransition immediateTransitionChildConsuming1; +// immediateTransitionChildConsuming1.setName(dftSpare->name() + "_" + children[i]->name() + "_consuming1"); +// immediateTransitionChildConsuming1.setPriority(priority); +// immediateTransitionChildConsuming1.setWeight(0.0); +// immediateTransitionChildConsuming1.setOutputArcMultiplicity(placeSPAREChildConsumed, 1); +// immediateTransitionChildConsuming1.setInhibitionArcMultiplicity(placeSPAREChildConsumed, 1); +// immediateTransitionChildConsuming1.setInhibitionArcMultiplicity(placeSPAREClaimedChild, 1); +// mGspn.addImmediateTransition(immediateTransitionChildConsuming1); +// +// storm::gspn::ImmediateTransition immediateTransitionChildConsuming2; +// immediateTransitionChildConsuming2.setName(dftSpare->name() + "_" + children[i]->name() + "_consuming2"); +// immediateTransitionChildConsuming2.setPriority(priority); +// immediateTransitionChildConsuming2.setWeight(0.0); +// immediateTransitionChildConsuming2.setOutputArcMultiplicity(placeSPAREChildConsumed, 1); +// immediateTransitionChildConsuming2.setInhibitionArcMultiplicity(placeSPAREChildConsumed, 1); +// immediateTransitionChildConsuming2.setOutputArcMultiplicity(placeSPAREClaimedChild, 1); +// immediateTransitionChildConsuming2.setInputArcMultiplicity(placeSPAREClaimedChild, 1); +// mGspn.addImmediateTransition(immediateTransitionChildConsuming2); +// } +// +// // Draw connections between all spare childs. +// for (std::size_t i = 1; i < children.size() - 1; i++) { +// auto placeSPAREChildConsumed = mGspn.getPlace(dftSpare->name() + "_" + children[i]->name() + "_consumed"); +// auto immediateTransitionChildClaiming = mGspn.getImmediateTransition(dftSpare->name() + "_claiming_" + children[i + 1]->name()); +// auto immediateTransitionChildConsuming1 = mGspn.getImmediateTransition(dftSpare->name() + "_" + children[i + 1]->name() + "_consuming1"); +// +// immediateTransitionChildClaiming.second->setOutputArcMultiplicity(placeSPAREChildConsumed.second, 1); +// immediateTransitionChildClaiming.second->setInputArcMultiplicity(placeSPAREChildConsumed.second, 1); +// +// immediateTransitionChildConsuming1.second->setOutputArcMultiplicity(placeSPAREChildConsumed.second, 1); +// immediateTransitionChildConsuming1.second->setInputArcMultiplicity(placeSPAREChildConsumed.second, 1); +// } + } +// + template + void DftToGspnTransformator::drawPOR(std::shared_ptr const> dftPor, bool isRepresentative) { + uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftPor->name() + STR_FAILED); + uint64_t nodeFS = builder.addPlace(defaultCapacity, 0, dftPor->name() + STR_FAILSAVE); + + + uint64_t tfail = builder.addImmediateTransition(getFailPriority(dftPor), 0.0, dftPor->name() + STR_FAILING); + builder.addInhibitionArc(nodeFS, tfail); + builder.addInputArc(failedNodes.at(dftPor->children().front()->id()), tfail); + builder.addOutputArc(tfail, failedNodes.at(dftPor->children().front()->id())); + builder.addOutputArc(tfail, nodeFailed); + builder.addInhibitionArc(nodeFailed, tfail); + uint64_t j = 0; + for (auto const& child : dftPor->children()) { + uint64_t tfailsf = builder.addImmediateTransition(getFailPriority(dftPor), 0.0, dftPor->name() + STR_FAILSAVING + std::to_string(j)); + builder.addInputArc(failedNodes.at(child->id()), tfailsf); + builder.addOutputArc(tfailsf, failedNodes.at(child->id())); + // TODO +// builder.addInhibitionArc(<#const uint_fast64_t &from#>, <#const uint_fast64_t &to#>) + ++j; + } + } + +// + template + void DftToGspnTransformator::drawCONSTF(std::shared_ptr const> dftConstF, bool isRepresentative) { +// storm::gspn::Place placeCONSTFFailed; +// placeCONSTFFailed.setName(dftConstF->name() + STR_FAILED); +// placeCONSTFFailed.setNumberOfInitialTokens(1); +// mGspn.addPlace(placeCONSTFFailed); + } +// + template + void DftToGspnTransformator::drawCONSTS(std::shared_ptr const> dftConstS, bool isRepresentative) { +// storm::gspn::Place placeCONSTSFailed; +// placeCONSTSFailed.setName(dftConstS->name() + STR_FAILED); +// placeCONSTSFailed.setNumberOfInitialTokens(0); +// placeCONSTSFailed.setCapacity(0); // It cannot contain a token, because it cannot fail. +// mGspn.addPlace(placeCONSTSFailed); + } +// + template + void DftToGspnTransformator::drawPDEP(std::shared_ptr const> dftDependency, bool isRepresentative) { +// // Only draw dependency, if it wasn't drawn before. +// std::string gateName = dftDependency->name().substr(0, dftDependency->name().find("_")); +// auto exists = mGspn.getPlace(gateName + STR_FAILED); +// if (!exists.first) { +// storm::gspn::Place placeDEPFailed; +// placeDEPFailed.setName(gateName + STR_FAILED); +// placeDEPFailed.setNumberOfInitialTokens(0); +// mGspn.addPlace(placeDEPFailed); +// +// storm::gspn::TimedTransition timedTransitionDEPFailure; +// timedTransitionDEPFailure.setName(gateName + STR_FAILING); +// timedTransitionDEPFailure.setPriority(getPriority(0, dftDependency)); +// timedTransitionDEPFailure.setRate(dftDependency->probability()); +// timedTransitionDEPFailure.setOutputArcMultiplicity(placeDEPFailed, 1); +// timedTransitionDEPFailure.setInhibitionArcMultiplicity(placeDEPFailed, 1); +// mGspn.addTimedTransition(timedTransitionDEPFailure); +// } + } + + template + uint64_t DftToGspnTransformator::addUnavailableNode(std::shared_ptr const> dftElement) { + uint64_t unavailableNode = builder.addPlace(defaultCapacity, 1, dftElement->name() + "_unavailable"); + assert(unavailableNode != 0); + unavailableNodes.emplace(dftElement->id(), unavailableNode); + return unavailableNode; + } +// + template + void DftToGspnTransformator::drawGSPNConnections() { +// // Check for every element, if they have parents (all will have at least 1, except the top event). +// for (std::size_t i = 0; i < mDft.nrElements(); i++) { +// auto child = mDft.getElement(i); +// auto parents = child->parentIds(); +// +// // Draw a connection to every parent. +// for (std::size_t j = 0; j < parents.size(); j++) { +// // Check the type of the parent and act accordingly (every parent gate has different entry points...). +// switch (mDft.getElement(parents[j])->type()) { +// case storm::storage::DFTElementType::AND: +// { +// auto andEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILING); +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// if (andEntry.first && childExit.first) { // Only add arcs if the objects have been found. +// andEntry.second->setInputArcMultiplicity(childExit.second, 1); +// andEntry.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// break; +// } +// case storm::storage::DFTElementType::OR: +// { +// auto orEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + child->name() + STR_FAILING); +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// if (orEntry.first && childExit.first) { // Only add arcs if the objects have been found. +// orEntry.second->setInputArcMultiplicity(childExit.second, 1); +// orEntry.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// break; +// } +// case storm::storage::DFTElementType::VOT: +// { +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// auto parentEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + child->name() + "_collecting"); +// +// if (childExit.first && parentEntry.first) { // Only add arcs if the objects have been found. +// parentEntry.second->setInputArcMultiplicity(childExit.second, 1); +// parentEntry.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// +// break; +// } +// case storm::storage::DFTElementType::PAND: +// { +// auto children = std::static_pointer_cast const>(mDft.getElement(parents[j]))->children(); +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// auto pandEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILING); +// +// if (childExit.first && pandEntry.first) { // Only add arcs if the objects have been found. +// pandEntry.second->setInputArcMultiplicity(childExit.second, 1); +// pandEntry.second->setOutputArcMultiplicity(childExit.second, 1); +// +// if (children[0] == child) { // Current element is primary child. +// auto pandEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_0" + STR_FAILSAVING); +// +// if (pandEntry2.first) { +// pandEntry2.second->setInhibitionArcMultiplicity(childExit.second, 1); +// } +// } +// else { // Current element is not the primary child. +// for (std::size_t k = 1; k < children.size(); k++) { +// if (children[k] == child) { +// auto pandEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + std::to_string((k - 1)) + STR_FAILSAVING); +// auto pandEntry3 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + std::to_string((k)) + STR_FAILSAVING); +// +// if (pandEntry2.first) { +// pandEntry2.second->setInputArcMultiplicity(childExit.second, 1); +// pandEntry2.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// +// if (pandEntry3.first) { +// pandEntry3.second->setInhibitionArcMultiplicity(childExit.second, 1); +// } +// +// continue; +// } +// } +// } +// } +// +// break; +// } +// case storm::storage::DFTElementType::SPARE: +// { +// // Check if current child is a primary or spare child. +// auto children = std::static_pointer_cast const>(mDft.getElement(parents[j]))->children(); +// +// if (child == children[0]) { // Primary child. +// auto spareExit = mGspn.getImmediateTransition(child->name() + STR_ACTIVATING); +// +// std::vector ids = getAllBEIDsOfElement(child); +// for (std::size_t k = 0; k < ids.size(); k++) { +// auto childEntry = mGspn.getPlace(mDft.getElement(ids[k])->name() + STR_ACTIVATED); +// +// if (spareExit.first && childEntry.first) { // Only add arcs if the objects have been found. +// spareExit.second->setInhibitionArcMultiplicity(childEntry.second, 1); +// spareExit.second->setOutputArcMultiplicity(childEntry.second, 1); +// } +// } +// +// // Draw lines from "primary child_failed" to SPARE. +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// auto spareEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_claiming_" + children[1]->name()); +// auto spareEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + children[1]->name() + "_consuming1"); +// +// if (childExit.first && spareEntry.first && spareEntry2.first) { // Only add arcs if the objects have been found. +// spareEntry.second->setInputArcMultiplicity(childExit.second, 1); +// spareEntry.second->setOutputArcMultiplicity(childExit.second, 1); +// +// spareEntry2.second->setInputArcMultiplicity(childExit.second, 1); +// spareEntry2.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// } +// else { // A spare child. +// auto spareExit = mGspn.getImmediateTransition(child->name() + STR_ACTIVATING); +// auto spareExit2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_claiming_" + child->name()); +// +// std::vector ids = getAllBEIDsOfElement(child); +// for (std::size_t k = 0; k < ids.size(); k++) { +// auto childEntry = mGspn.getPlace(mDft.getElement(ids[k])->name() + STR_ACTIVATED); +// +// if (spareExit.first && spareExit2.first && childEntry.first) { // Only add arcs if the objects have been found. +// if (!spareExit.second->existsInhibitionArc(childEntry.second)) { +// spareExit.second->setInhibitionArcMultiplicity(childEntry.second, 1); +// } +// if (!spareExit.second->existsOutputArc(childEntry.second)) { +// spareExit.second->setOutputArcMultiplicity(childEntry.second, 1); +// } +// if (!spareExit2.second->existsInhibitionArc(childEntry.second)) { +// spareExit2.second->setInhibitionArcMultiplicity(childEntry.second, 1); +// } +// } +// } +// +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// auto spareEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_claiming_" + child->name()); +// auto spareEntry2 = mGspn.getImmediateTransition(child->name() + STR_ACTIVATING); +// auto spareEntry3 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + child->name() + "_consuming2"); +// +// if (childExit.first && spareEntry.first && spareEntry2.first && spareEntry3.first) { // Only add arcs if the objects have been found. +// spareEntry.second->setInhibitionArcMultiplicity(childExit.second, 1); +// +// if (!spareEntry2.second->existsInhibitionArc(childExit.second)) { +// spareEntry2.second->setInhibitionArcMultiplicity(childExit.second, 1); +// } +// +// spareEntry3.second->setInputArcMultiplicity(childExit.second, 1); +// spareEntry3.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// } +// +// break; +// } +// case storm::storage::DFTElementType::POR: +// { +// auto children = std::static_pointer_cast const>(mDft.getElement(parents[j]))->children(); +// auto porEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILING); +// auto porEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILSAVING); +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// +// if (porEntry.first && porEntry2.first && childExit.first) { // Only add arcs if the objects have been found. +// if (children[0] == child) { // Current element is primary child. +// porEntry.second->setInputArcMultiplicity(childExit.second, 1); +// porEntry.second->setOutputArcMultiplicity(childExit.second, 1); +// porEntry2.second->setInhibitionArcMultiplicity(childExit.second, 1); +// +// } +// else { // Current element is not the primary child. +// porEntry2.second->setInputArcMultiplicity(childExit.second, 1); +// porEntry2.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// } +// +// break; +// } +// case storm::storage::DFTElementType::SEQ: +// { +// // Sequences are realized with restrictions. Nothing to do here. +// break; +// } +// case storm::storage::DFTElementType::MUTEX: +// { +// // MUTEX are realized with restrictions. Nothing to do here. +// break; +// } +// case storm::storage::DFTElementType::BE: +// { +// // The parent is never a Basic Event. +// break; +// } +// case storm::storage::DFTElementType::CONSTF: +// { +// // The parent is never a Basic Event. +// break; +// } +// case storm::storage::DFTElementType::CONSTS: +// { +// // The parent is never a Basic Event. +// break; +// } +// case storm::storage::DFTElementType::PDEP: +// { +// // The parent is never a DEP. Hence the connections must be drawn somewhere else. +// break; +// } +// default: +// { +// STORM_LOG_ASSERT(false, "DFT type unknown."); +// break; +// } +// } +// } +// } + } + + template + bool DftToGspnTransformator::isBEActive(std::shared_ptr const> dftElement) + { + // If element is the top element, return true. + if (dftElement->id() == mDft.getTopLevelIndex()) { + return true; + } + else { // Else look at all parents. + auto parents = dftElement->parents(); + std::vector pathValidities; + + for (std::size_t i = 0; i < parents.size(); i++) { + // Add all parents to the vector, except if the parent is a SPARE and the current element is an inactive child of the SPARE. + if (parents[i]->type() == storm::storage::DFTElementType::SPARE) { + auto children = std::static_pointer_cast const>(parents[i])->children(); + if (children[0]->id() != dftElement->id()) { + continue; + } + } + + pathValidities.push_back(isBEActive(parents[i])); + } + + // Check all vector entries. If one is true, a "valid" path has been found. + for (std::size_t i = 0; i < pathValidities.size(); i++) { + if (pathValidities[i]) { + return true; + } + } + } + + // No "valid" path found. BE is inactive. + return false; + } + + template + uint64_t DftToGspnTransformator::getFailPriority(std::shared_ptr const> dftElement) + { + return mDft.maxRank() - dftElement->rank(); + } + + template + void DftToGspnTransformator::drawGSPNDependencies() { +// for (std::size_t i = 0; i < mDft.nrElements(); i++) { +// auto dftElement = mDft.getElement(i); +// +// if (dftElement->isDependency()) { +// std::string gateName = dftElement->name().substr(0, dftElement->name().find("_")); +// auto depEntry = mGspn.getTimedTransition(gateName + STR_FAILING); +// auto trigger = mGspn.getPlace(std::static_pointer_cast const>(dftElement)->nameTrigger() + STR_FAILED); +// +// if (depEntry.first && trigger.first) { // Only add arcs if the objects have been found. +// if (!depEntry.second->existsInputArc(trigger.second)) { +// depEntry.second->setInputArcMultiplicity(trigger.second, 1); +// } +// if (!depEntry.second->existsOutputArc(trigger.second)){ +// depEntry.second->setOutputArcMultiplicity(trigger.second, 1); +// } +// } +// +// auto dependent = mGspn.getPlace(std::static_pointer_cast const>(dftElement)->nameDependent() + STR_FAILED); +// +// if (dependent.first) { // Only add arcs if the objects have been found. +// depEntry.second->setOutputArcMultiplicity(dependent.second, 1); +// } +// } +// } + } + + template + void DftToGspnTransformator::drawGSPNRestrictions() { +// for (std::size_t i = 0; i < mDft.nrElements(); i++) { +// auto dftElement = mDft.getElement(i); +// +// if (dftElement->isRestriction()) { +// switch (dftElement->type()) { +// case storm::storage::DFTElementType::SEQ: +// { +// auto children = mDft.getRestriction(i)->children(); +// +// for (std::size_t j = 0; j < children.size() - 1; j++) { +// auto suppressor = mGspn.getPlace(children[j]->name() + STR_FAILED); +// +// switch (children[j + 1]->type()) { +// case storm::storage::DFTElementType::BE: // If suppressed is a BE, add 2 arcs to timed transitions. +// { +// auto suppressedActive = mGspn.getTimedTransition(children[j + 1]->name() + "_activeFailing"); +// auto suppressedPassive = mGspn.getTimedTransition(children[j + 1]->name() + "_passiveFailing"); +// +// if (suppressor.first && suppressedActive.first && suppressedPassive.first) { // Only add arcs if the objects have been found. +// suppressedActive.second->setInputArcMultiplicity(suppressor.second, 1); +// suppressedActive.second->setOutputArcMultiplicity(suppressor.second, 1); +// suppressedPassive.second->setInputArcMultiplicity(suppressor.second, 1); +// suppressedPassive.second->setOutputArcMultiplicity(suppressor.second, 1); +// } +// break; +// } +// default: // If supressed is not a BE, add single arc to immediate transition. +// { +// auto suppressed = mGspn.getImmediateTransition(children[j + 1]->name() + STR_FAILING); +// +// if (suppressor.first && suppressed.first) { // Only add arcs if the objects have been found. +// suppressed.second->setInputArcMultiplicity(suppressor.second, 1); +// suppressed.second->setOutputArcMultiplicity(suppressor.second, 1); +// } +// break; +// } +// } +// } +// break; +// } +// case storm::storage::DFTElementType::MUTEX: +// { +// // MUTEX is not implemented by the DFTGalileoParser yet. Nothing to do here. +// STORM_LOG_ASSERT(false, "MUTEX is not supported by DftToGspnTransformator."); +// break; +// } +// default: +// { +// break; +// } +// } +// } +// } + } + + template + std::vector DftToGspnTransformator::getAllBEIDsOfElement(std::shared_ptr const> dftElement) { +// std::vector ids; +// +// switch (dftElement->type()) { +// case storm::storage::DFTElementType::AND: +// { +// auto children = std::static_pointer_cast const>(dftElement)->children(); +// +// for (std::size_t i = 0; i < children.size(); i++) { +// std::vector newIds = getAllBEIDsOfElement(children[i]); +// ids.insert(ids.end(), newIds.begin(), newIds.end()); +// } +// break; +// } +// case storm::storage::DFTElementType::OR: +// { +// auto children = std::static_pointer_cast const>(dftElement)->children(); +// +// for (std::size_t i = 0; i < children.size(); i++) { +// std::vector newIds = getAllBEIDsOfElement(children[i]); +// ids.insert(ids.end(), newIds.begin(), newIds.end()); +// } +// break; +// } +// case storm::storage::DFTElementType::VOT: +// { +// auto children = std::static_pointer_cast const>(dftElement)->children(); +// +// for (std::size_t i = 0; i < children.size(); i++) { +// std::vector newIds = getAllBEIDsOfElement(children[i]); +// ids.insert(ids.end(), newIds.begin(), newIds.end()); +// } +// break; +// } +// case storm::storage::DFTElementType::PAND: +// { +// auto children = std::static_pointer_cast const>(dftElement)->children(); +// +// for (std::size_t i = 0; i < children.size(); i++) { +// std::vector newIds = getAllBEIDsOfElement(children[i]); +// ids.insert(ids.end(), newIds.begin(), newIds.end()); +// } +// break; +// } +// case storm::storage::DFTElementType::SPARE: +// { +// auto children = std::static_pointer_cast const>(dftElement)->children(); +// +// // Only regard the primary child of a SPARE. The spare childs are not allowed to be listed here. +// for (std::size_t i = 0; i < 1; i++) { +// std::vector newIds = getAllBEIDsOfElement(children[i]); +// ids.insert(ids.end(), newIds.begin(), newIds.end()); +// } +// break; +// } +// case storm::storage::DFTElementType::POR: +// { +// auto children = std::static_pointer_cast const>(dftElement)->children(); +// +// for (std::size_t i = 0; i < children.size(); i++) { +// std::vector newIds = getAllBEIDsOfElement(children[i]); +// ids.insert(ids.end(), newIds.begin(), newIds.end()); +// } +// break; +// } +// case storm::storage::DFTElementType::BE: +// case storm::storage::DFTElementType::CONSTF: +// case storm::storage::DFTElementType::CONSTS: +// { +// ids.push_back(dftElement->id()); +// break; +// } +// case storm::storage::DFTElementType::SEQ: +// case storm::storage::DFTElementType::MUTEX: +// case storm::storage::DFTElementType::PDEP: +// { +// break; +// } +// default: +// { +// STORM_LOG_ASSERT(false, "DFT type unknown."); +// break; +// } +// } +// +// return ids; + } + + template + void DftToGspnTransformator::writeGspn(bool toFile) { + if (toFile) { + // Writing to file + std::ofstream file; + file.open("gspn.dot"); + storm::gspn::GSPN* gspn = builder.buildGspn(); + gspn->writeDotToStream(file); + delete gspn; + file.close(); + } else { + // Writing to console + storm::gspn::GSPN* gspn = builder.buildGspn(); + gspn->writeDotToStream(std::cout); + delete gspn; + } + } + + // Explicitly instantiate the class. + template class DftToGspnTransformator; + + + #ifdef STORM_HAVE_CARL + // template class DftToGspnTransformator; + #endif + + } // namespace dft + } // namespace transformations +} // namespace storm + + diff --git a/src/storm/transformations/dft/DftToGspnTransformator.h b/src/storm/transformations/dft/DftToGspnTransformator.h new file mode 100644 index 000000000..76250bfbf --- /dev/null +++ b/src/storm/transformations/dft/DftToGspnTransformator.h @@ -0,0 +1,174 @@ +#pragma once + +#include "storm/storage/dft/DFT.h" +#include "storm/storage/gspn/GSPN.h" +#include "storm/storage/gspn/GspnBuilder.h" + +namespace storm { + namespace transformations { + namespace dft { + + /*! + * Transformator for DFT -> GSPN. + */ + template + class DftToGspnTransformator { + + public: + /*! + * Constructor. + * + * @param dft DFT + */ + DftToGspnTransformator(storm::storage::DFT const& dft); + + /*! + * Transform the DFT to a GSPN. + */ + void transform(); + + private: + /*! + * Write Gspn to file or console. + * + * @param toFile If true, the GSPN will be written to a file, otherwise it will + be written to the console. + */ + void writeGspn(bool toFile); + + /* + * Draw all elements of the GSPN. + */ + void drawGSPNElements(); + + /* + * Draw the connections between the elements of the GSPN. + */ + void drawGSPNConnections(); + + /* + * Draw functional/probability dependencies into the GSPN. + */ + void drawGSPNDependencies(); + + /* + * Draw restrictions between the elements of the GSPN (i.e. SEQ or MUTEX). + */ + void drawGSPNRestrictions(); + + /* + * Draw a Petri net Basic Event. + * + * @param dftBE The Basic Event. + */ + void drawBE(std::shared_ptr const> dftBE, bool isRepresentative); + + /* + * Draw a Petri net AND. + * + * @param dftAnd The AND gate. + */ + void drawAND(std::shared_ptr const> dftAnd, bool isRepresentative); + + /* + * Draw a Petri net OR. + * + * @param dftOr The OR gate. + */ + void drawOR(std::shared_ptr const> dftOr, bool isRepresentative); + + /* + * Draw a Petri net VOT. + * + * @param dftVot The VOT gate. + */ + void drawVOT(std::shared_ptr const> dftVot, bool isRepresentative); + + /* + * Draw a Petri net PAND. + * This PAND is inklusive (children are allowed to fail simultaneously and the PAND will fail nevertheless). + * + * @param dftPand The PAND gate. + */ + void drawPAND(std::shared_ptr const> dftPand, bool isRepresentative); + + /* + * Draw a Petri net SPARE. + * + * @param dftSpare The SPARE gate. + */ + void drawSPARE(std::shared_ptr const> dftSpare, bool isRepresentative); + + /* + * Draw a Petri net POR. + * This POR is inklusive (children are allowed to fail simultaneously and the POR will fail nevertheless). + * + * @param dftPor The POR gate. + */ + void drawPOR(std::shared_ptr const> dftPor, bool isRepresentative); + + /* + * Draw a Petri net CONSTF (Constant Failure, a Basic Event that has already failed). + * + * @param dftPor The CONSTF Basic Event. + */ + void drawCONSTF(std::shared_ptr const> dftConstF, bool isRepresentative); + + /* + * Draw a Petri net CONSTS (Constant Save, a Basic Event that cannot fail). + * + * @param dftPor The CONSTS Basic Event. + */ + void drawCONSTS(std::shared_ptr const> dftConstS, bool isRepresentative); + + /* + * Draw a Petri net PDEP (FDEP is included with a firerate of 1). + */ + void drawPDEP(std::shared_ptr const> dftDependency, bool isRepresentative); + + /* + * Return true if BE is active (corresponding place contains one initial token) or false if BE is inactive (corresponding place contains no initial token). + * + * @param dFTElement DFT element. + */ + bool isBEActive(std::shared_ptr const> dFTElement); + + /* + * Get the priority of the element. + * The priority is two times the length of the shortest path to the top event. + * + * @param priority The priority of the gate. Top Event has priority 0, its children 2, its grandchildren 4, ... + * + * @param dftElement The element whose priority shall be determined. + */ + uint64_t getFailPriority(std::shared_ptr const> dFTElement); + + /* + * Return all ids of BEs, that are successors of the given element and that are not the spare childs of a SPARE. + * + * @param dftElement The element which + */ + std::vector getAllBEIDsOfElement(std::shared_ptr const> dftElement); + + + uint64_t addUnavailableNode(std::shared_ptr const> dftElement); + + storm::storage::DFT const& mDft; + storm::gspn::GspnBuilder builder; + std::vector failedNodes; + std::map unavailableNodes; + std::map activeNodes; + + static constexpr const char* STR_FAILING = "_failing"; // Name standard for transitions that point towards a place, which in turn indicates the failure of a gate. + static constexpr const char* STR_FAILED = "_failed"; // Name standard for place which indicates the failure of a gate. + static constexpr const char* STR_FAILSAVING = "_failsaving"; // Name standard for transition that point towards a place, which in turn indicates the failsave state of a gate. + static constexpr const char* STR_FAILSAVE = "_failsave"; // Name standard for place which indicates the failsave state of a gate. + static constexpr const char* STR_ACTIVATED = "_activated"; // Name standard for place which indicates the activity. + static constexpr const char* STR_ACTIVATING = "_activating"; // Name standard for transition that point towards a place, which in turn indicates its activity. + + + }; + } + } +} + From 297f3ff48076dbf9b67056c82bc97409ef9fd445 Mon Sep 17 00:00:00 2001 From: sjunges Date: Tue, 22 Nov 2016 09:56:00 +0100 Subject: [PATCH 02/47] some cleaning and minor additions to dft->gspn translation --- .../dft/DftToGspnTransformator.cpp | 468 +----------------- .../dft/DftToGspnTransformator.h | 22 +- 2 files changed, 18 insertions(+), 472 deletions(-) diff --git a/src/storm/transformations/dft/DftToGspnTransformator.cpp b/src/storm/transformations/dft/DftToGspnTransformator.cpp index 4331e0c62..730656b35 100644 --- a/src/storm/transformations/dft/DftToGspnTransformator.cpp +++ b/src/storm/transformations/dft/DftToGspnTransformator.cpp @@ -22,16 +22,10 @@ namespace storm { // Loop through every DFT element and draw them as a GSPN. drawGSPNElements(); - - // When all DFT elements are drawn, draw the connections between them. - drawGSPNConnections(); - - // Draw functional/probability dependencies into the GSPN. - drawGSPNDependencies(); - + // Draw restrictions into the GSPN (i.e. SEQ or MUTEX). - drawGSPNRestrictions(); - + //drawGSPNRestrictions(); + // Write GSPN to file. writeGspn(true); } @@ -227,7 +221,6 @@ namespace storm { builder.addInputArc(failedNodes[dftPand->children().at(j)->id()], tfs); builder.addInhibitionArc(failedNodes[dftPand->children().at(j-1)->id()], tfs); builder.addOutputArc(tfs, nodeFS); - } } // @@ -241,7 +234,7 @@ namespace storm { unavailableNode = addUnavailableNode(dftSpare); } uint64_t spareActive = builder.addPlace(defaultCapacity, 0, dftSpare->name() + STR_ACTIVATED); - activeNodes.emplace(dftBE->id(), beActive); + activeNodes.emplace(dftSpare->id(), spareActive); std::vector cucNodes; @@ -277,116 +270,16 @@ namespace storm { builder.addInputArc(failedNodes.at(child->id()), tnextcl); builder.addOutputArc(tnextcl, failedNodes.at(child->id())); nextclTransitions.push_back(tnextcl); - - + ++j; } builder.addOutputArc(nextconsiderTransitions.back(), nodeFailed); builder.addOutputArc(nextclTransitions.back(), nodeFailed); - + if (isRepresentative) { builder.addOutputArc(nextconsiderTransitions.back(), unavailableNode); builder.addOutputArc(nextclTransitions.back(), unavailableNode); } - - -// uint_fast64_t priority = getPriority(0, dftSpare); -// -// // This codeblock can be removed later, when I am 100% sure it is not needed anymore. -// /* -// storm::gspn::Place placeSPAREActivated; -// placeSPAREActivated.setName(dftSpare->name() + STR_ACTIVATED); -// placeSPAREActivated.setNumberOfInitialTokens(isBEActive(dftSpare)); -// mGspn.addPlace(placeSPAREActivated); -// -// storm::gspn::ImmediateTransition immediateTransitionPCActivating; -// immediateTransitionPCActivating.setName(dftSpare->children()[0]->name() + STR_ACTIVATING); -// immediateTransitionPCActivating.setPriority(priority); -// immediateTransitionPCActivating.setWeight(0.0); -// immediateTransitionPCActivating.setInputArcMultiplicity(placeSPAREActivated, 1); -// immediateTransitionPCActivating.setOutputArcMultiplicity(placeSPAREActivated, 1); -// mGspn.addImmediateTransition(immediateTransitionPCActivating); -// */ -// -// auto children = dftSpare->children(); -// -// // Draw places and transitions that belong to each spare child. -// for (std::size_t i = 1; i < children.size(); i++) { -// auto placeChildClaimedPreexist = mGspn.getPlace(children[i]->name() + "_claimed"); -// -// if (!placeChildClaimedPreexist.first) { // Only draw this place if it doesn't exist jet. -// storm::gspn::Place placeChildClaimed; -// placeChildClaimed.setName(children[i]->name() + "_claimed"); -// placeChildClaimed.setNumberOfInitialTokens(0); -// mGspn.addPlace(placeChildClaimed); -// -// storm::gspn::ImmediateTransition immediateTransitionSpareChildActivating; -// immediateTransitionSpareChildActivating.setName(children[i]->name() + STR_ACTIVATING); -// immediateTransitionSpareChildActivating.setPriority(priority); -// immediateTransitionSpareChildActivating.setWeight(0.0); -// immediateTransitionSpareChildActivating.setInputArcMultiplicity(placeChildClaimed, 1); -// immediateTransitionSpareChildActivating.setOutputArcMultiplicity(placeChildClaimed, 1); -// mGspn.addImmediateTransition(immediateTransitionSpareChildActivating); -// } -// -// auto placeChildClaimedExist = mGspn.getPlace(children[i]->name() + "_claimed"); -// -// storm::gspn::Place placeSPAREClaimedChild; -// placeSPAREClaimedChild.setName(dftSpare->name() + "_claimed_" + children[i]->name()); -// placeSPAREClaimedChild.setNumberOfInitialTokens(0); -// mGspn.addPlace(placeSPAREClaimedChild); -// -// storm::gspn::ImmediateTransition immediateTransitionChildClaiming; -// immediateTransitionChildClaiming.setName(dftSpare->name() + "_claiming_" + children[i]->name()); -// immediateTransitionChildClaiming.setPriority(priority + 1); // Higher priority needed! -// immediateTransitionChildClaiming.setWeight(0.0); -// immediateTransitionChildClaiming.setInhibitionArcMultiplicity(placeChildClaimedExist.second, 1); -// immediateTransitionChildClaiming.setOutputArcMultiplicity(placeChildClaimedExist.second, 1); -// immediateTransitionChildClaiming.setOutputArcMultiplicity(placeSPAREClaimedChild, 1); -// mGspn.addImmediateTransition(immediateTransitionChildClaiming); -// -// storm::gspn::Place placeSPAREChildConsumed; -// if (i < children.size() - 1) { -// placeSPAREChildConsumed.setName(dftSpare->name() + "_" + children[i]->name() + "_consumed"); -// } -// else { -// placeSPAREChildConsumed.setName(dftSpare->name() + STR_FAILED); -// } -// placeSPAREChildConsumed.setNumberOfInitialTokens(0); -// mGspn.addPlace(placeSPAREChildConsumed); -// -// storm::gspn::ImmediateTransition immediateTransitionChildConsuming1; -// immediateTransitionChildConsuming1.setName(dftSpare->name() + "_" + children[i]->name() + "_consuming1"); -// immediateTransitionChildConsuming1.setPriority(priority); -// immediateTransitionChildConsuming1.setWeight(0.0); -// immediateTransitionChildConsuming1.setOutputArcMultiplicity(placeSPAREChildConsumed, 1); -// immediateTransitionChildConsuming1.setInhibitionArcMultiplicity(placeSPAREChildConsumed, 1); -// immediateTransitionChildConsuming1.setInhibitionArcMultiplicity(placeSPAREClaimedChild, 1); -// mGspn.addImmediateTransition(immediateTransitionChildConsuming1); -// -// storm::gspn::ImmediateTransition immediateTransitionChildConsuming2; -// immediateTransitionChildConsuming2.setName(dftSpare->name() + "_" + children[i]->name() + "_consuming2"); -// immediateTransitionChildConsuming2.setPriority(priority); -// immediateTransitionChildConsuming2.setWeight(0.0); -// immediateTransitionChildConsuming2.setOutputArcMultiplicity(placeSPAREChildConsumed, 1); -// immediateTransitionChildConsuming2.setInhibitionArcMultiplicity(placeSPAREChildConsumed, 1); -// immediateTransitionChildConsuming2.setOutputArcMultiplicity(placeSPAREClaimedChild, 1); -// immediateTransitionChildConsuming2.setInputArcMultiplicity(placeSPAREClaimedChild, 1); -// mGspn.addImmediateTransition(immediateTransitionChildConsuming2); -// } -// -// // Draw connections between all spare childs. -// for (std::size_t i = 1; i < children.size() - 1; i++) { -// auto placeSPAREChildConsumed = mGspn.getPlace(dftSpare->name() + "_" + children[i]->name() + "_consumed"); -// auto immediateTransitionChildClaiming = mGspn.getImmediateTransition(dftSpare->name() + "_claiming_" + children[i + 1]->name()); -// auto immediateTransitionChildConsuming1 = mGspn.getImmediateTransition(dftSpare->name() + "_" + children[i + 1]->name() + "_consuming1"); -// -// immediateTransitionChildClaiming.second->setOutputArcMultiplicity(placeSPAREChildConsumed.second, 1); -// immediateTransitionChildClaiming.second->setInputArcMultiplicity(placeSPAREChildConsumed.second, 1); -// -// immediateTransitionChildConsuming1.second->setOutputArcMultiplicity(placeSPAREChildConsumed.second, 1); -// immediateTransitionChildConsuming1.second->setInputArcMultiplicity(placeSPAREChildConsumed.second, 1); -// } } // template @@ -415,10 +308,11 @@ namespace storm { // template void DftToGspnTransformator::drawCONSTF(std::shared_ptr const> dftConstF, bool isRepresentative) { -// storm::gspn::Place placeCONSTFFailed; -// placeCONSTFFailed.setName(dftConstF->name() + STR_FAILED); -// placeCONSTFFailed.setNumberOfInitialTokens(1); -// mGspn.addPlace(placeCONSTFFailed); + failedNodes.push_back(builder.addPlace(defaultCapacity, 1, dftConstF->name() + STR_FAILED)); + uint64_t unavailableNode = 0; + if (isRepresentative) { + unavailableNode = addUnavailableNode(dftConstF, false); + } } // template @@ -452,228 +346,14 @@ namespace storm { } template - uint64_t DftToGspnTransformator::addUnavailableNode(std::shared_ptr const> dftElement) { - uint64_t unavailableNode = builder.addPlace(defaultCapacity, 1, dftElement->name() + "_unavailable"); + uint64_t DftToGspnTransformator::addUnavailableNode(std::shared_ptr const> dftElement, bool initialAvailable) { + uint64_t unavailableNode = builder.addPlace(defaultCapacity, initialAvailable ? 0 : 1, dftElement->name() + "_unavailable"); assert(unavailableNode != 0); unavailableNodes.emplace(dftElement->id(), unavailableNode); return unavailableNode; } // - template - void DftToGspnTransformator::drawGSPNConnections() { -// // Check for every element, if they have parents (all will have at least 1, except the top event). -// for (std::size_t i = 0; i < mDft.nrElements(); i++) { -// auto child = mDft.getElement(i); -// auto parents = child->parentIds(); -// -// // Draw a connection to every parent. -// for (std::size_t j = 0; j < parents.size(); j++) { -// // Check the type of the parent and act accordingly (every parent gate has different entry points...). -// switch (mDft.getElement(parents[j])->type()) { -// case storm::storage::DFTElementType::AND: -// { -// auto andEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILING); -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// if (andEntry.first && childExit.first) { // Only add arcs if the objects have been found. -// andEntry.second->setInputArcMultiplicity(childExit.second, 1); -// andEntry.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// break; -// } -// case storm::storage::DFTElementType::OR: -// { -// auto orEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + child->name() + STR_FAILING); -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// if (orEntry.first && childExit.first) { // Only add arcs if the objects have been found. -// orEntry.second->setInputArcMultiplicity(childExit.second, 1); -// orEntry.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// break; -// } -// case storm::storage::DFTElementType::VOT: -// { -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// auto parentEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + child->name() + "_collecting"); -// -// if (childExit.first && parentEntry.first) { // Only add arcs if the objects have been found. -// parentEntry.second->setInputArcMultiplicity(childExit.second, 1); -// parentEntry.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// -// break; -// } -// case storm::storage::DFTElementType::PAND: -// { -// auto children = std::static_pointer_cast const>(mDft.getElement(parents[j]))->children(); -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// auto pandEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILING); -// -// if (childExit.first && pandEntry.first) { // Only add arcs if the objects have been found. -// pandEntry.second->setInputArcMultiplicity(childExit.second, 1); -// pandEntry.second->setOutputArcMultiplicity(childExit.second, 1); -// -// if (children[0] == child) { // Current element is primary child. -// auto pandEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_0" + STR_FAILSAVING); -// -// if (pandEntry2.first) { -// pandEntry2.second->setInhibitionArcMultiplicity(childExit.second, 1); -// } -// } -// else { // Current element is not the primary child. -// for (std::size_t k = 1; k < children.size(); k++) { -// if (children[k] == child) { -// auto pandEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + std::to_string((k - 1)) + STR_FAILSAVING); -// auto pandEntry3 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + std::to_string((k)) + STR_FAILSAVING); -// -// if (pandEntry2.first) { -// pandEntry2.second->setInputArcMultiplicity(childExit.second, 1); -// pandEntry2.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// -// if (pandEntry3.first) { -// pandEntry3.second->setInhibitionArcMultiplicity(childExit.second, 1); -// } -// -// continue; -// } -// } -// } -// } -// -// break; -// } -// case storm::storage::DFTElementType::SPARE: -// { -// // Check if current child is a primary or spare child. -// auto children = std::static_pointer_cast const>(mDft.getElement(parents[j]))->children(); -// -// if (child == children[0]) { // Primary child. -// auto spareExit = mGspn.getImmediateTransition(child->name() + STR_ACTIVATING); -// -// std::vector ids = getAllBEIDsOfElement(child); -// for (std::size_t k = 0; k < ids.size(); k++) { -// auto childEntry = mGspn.getPlace(mDft.getElement(ids[k])->name() + STR_ACTIVATED); -// -// if (spareExit.first && childEntry.first) { // Only add arcs if the objects have been found. -// spareExit.second->setInhibitionArcMultiplicity(childEntry.second, 1); -// spareExit.second->setOutputArcMultiplicity(childEntry.second, 1); -// } -// } -// -// // Draw lines from "primary child_failed" to SPARE. -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// auto spareEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_claiming_" + children[1]->name()); -// auto spareEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + children[1]->name() + "_consuming1"); -// -// if (childExit.first && spareEntry.first && spareEntry2.first) { // Only add arcs if the objects have been found. -// spareEntry.second->setInputArcMultiplicity(childExit.second, 1); -// spareEntry.second->setOutputArcMultiplicity(childExit.second, 1); -// -// spareEntry2.second->setInputArcMultiplicity(childExit.second, 1); -// spareEntry2.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// } -// else { // A spare child. -// auto spareExit = mGspn.getImmediateTransition(child->name() + STR_ACTIVATING); -// auto spareExit2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_claiming_" + child->name()); -// -// std::vector ids = getAllBEIDsOfElement(child); -// for (std::size_t k = 0; k < ids.size(); k++) { -// auto childEntry = mGspn.getPlace(mDft.getElement(ids[k])->name() + STR_ACTIVATED); -// -// if (spareExit.first && spareExit2.first && childEntry.first) { // Only add arcs if the objects have been found. -// if (!spareExit.second->existsInhibitionArc(childEntry.second)) { -// spareExit.second->setInhibitionArcMultiplicity(childEntry.second, 1); -// } -// if (!spareExit.second->existsOutputArc(childEntry.second)) { -// spareExit.second->setOutputArcMultiplicity(childEntry.second, 1); -// } -// if (!spareExit2.second->existsInhibitionArc(childEntry.second)) { -// spareExit2.second->setInhibitionArcMultiplicity(childEntry.second, 1); -// } -// } -// } -// -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// auto spareEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_claiming_" + child->name()); -// auto spareEntry2 = mGspn.getImmediateTransition(child->name() + STR_ACTIVATING); -// auto spareEntry3 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + child->name() + "_consuming2"); -// -// if (childExit.first && spareEntry.first && spareEntry2.first && spareEntry3.first) { // Only add arcs if the objects have been found. -// spareEntry.second->setInhibitionArcMultiplicity(childExit.second, 1); -// -// if (!spareEntry2.second->existsInhibitionArc(childExit.second)) { -// spareEntry2.second->setInhibitionArcMultiplicity(childExit.second, 1); -// } -// -// spareEntry3.second->setInputArcMultiplicity(childExit.second, 1); -// spareEntry3.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// } -// -// break; -// } -// case storm::storage::DFTElementType::POR: -// { -// auto children = std::static_pointer_cast const>(mDft.getElement(parents[j]))->children(); -// auto porEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILING); -// auto porEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILSAVING); -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// -// if (porEntry.first && porEntry2.first && childExit.first) { // Only add arcs if the objects have been found. -// if (children[0] == child) { // Current element is primary child. -// porEntry.second->setInputArcMultiplicity(childExit.second, 1); -// porEntry.second->setOutputArcMultiplicity(childExit.second, 1); -// porEntry2.second->setInhibitionArcMultiplicity(childExit.second, 1); -// -// } -// else { // Current element is not the primary child. -// porEntry2.second->setInputArcMultiplicity(childExit.second, 1); -// porEntry2.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// } -// -// break; -// } -// case storm::storage::DFTElementType::SEQ: -// { -// // Sequences are realized with restrictions. Nothing to do here. -// break; -// } -// case storm::storage::DFTElementType::MUTEX: -// { -// // MUTEX are realized with restrictions. Nothing to do here. -// break; -// } -// case storm::storage::DFTElementType::BE: -// { -// // The parent is never a Basic Event. -// break; -// } -// case storm::storage::DFTElementType::CONSTF: -// { -// // The parent is never a Basic Event. -// break; -// } -// case storm::storage::DFTElementType::CONSTS: -// { -// // The parent is never a Basic Event. -// break; -// } -// case storm::storage::DFTElementType::PDEP: -// { -// // The parent is never a DEP. Hence the connections must be drawn somewhere else. -// break; -// } -// default: -// { -// STORM_LOG_ASSERT(false, "DFT type unknown."); -// break; -// } -// } -// } -// } - } + template bool DftToGspnTransformator::isBEActive(std::shared_ptr const> dftElement) @@ -715,34 +395,7 @@ namespace storm { { return mDft.maxRank() - dftElement->rank(); } - - template - void DftToGspnTransformator::drawGSPNDependencies() { -// for (std::size_t i = 0; i < mDft.nrElements(); i++) { -// auto dftElement = mDft.getElement(i); -// -// if (dftElement->isDependency()) { -// std::string gateName = dftElement->name().substr(0, dftElement->name().find("_")); -// auto depEntry = mGspn.getTimedTransition(gateName + STR_FAILING); -// auto trigger = mGspn.getPlace(std::static_pointer_cast const>(dftElement)->nameTrigger() + STR_FAILED); -// -// if (depEntry.first && trigger.first) { // Only add arcs if the objects have been found. -// if (!depEntry.second->existsInputArc(trigger.second)) { -// depEntry.second->setInputArcMultiplicity(trigger.second, 1); -// } -// if (!depEntry.second->existsOutputArc(trigger.second)){ -// depEntry.second->setOutputArcMultiplicity(trigger.second, 1); -// } -// } -// -// auto dependent = mGspn.getPlace(std::static_pointer_cast const>(dftElement)->nameDependent() + STR_FAILED); -// -// if (dependent.first) { // Only add arcs if the objects have been found. -// depEntry.second->setOutputArcMultiplicity(dependent.second, 1); -// } -// } -// } - } + template void DftToGspnTransformator::drawGSPNRestrictions() { @@ -800,96 +453,7 @@ namespace storm { // } // } } - - template - std::vector DftToGspnTransformator::getAllBEIDsOfElement(std::shared_ptr const> dftElement) { -// std::vector ids; -// -// switch (dftElement->type()) { -// case storm::storage::DFTElementType::AND: -// { -// auto children = std::static_pointer_cast const>(dftElement)->children(); -// -// for (std::size_t i = 0; i < children.size(); i++) { -// std::vector newIds = getAllBEIDsOfElement(children[i]); -// ids.insert(ids.end(), newIds.begin(), newIds.end()); -// } -// break; -// } -// case storm::storage::DFTElementType::OR: -// { -// auto children = std::static_pointer_cast const>(dftElement)->children(); -// -// for (std::size_t i = 0; i < children.size(); i++) { -// std::vector newIds = getAllBEIDsOfElement(children[i]); -// ids.insert(ids.end(), newIds.begin(), newIds.end()); -// } -// break; -// } -// case storm::storage::DFTElementType::VOT: -// { -// auto children = std::static_pointer_cast const>(dftElement)->children(); -// -// for (std::size_t i = 0; i < children.size(); i++) { -// std::vector newIds = getAllBEIDsOfElement(children[i]); -// ids.insert(ids.end(), newIds.begin(), newIds.end()); -// } -// break; -// } -// case storm::storage::DFTElementType::PAND: -// { -// auto children = std::static_pointer_cast const>(dftElement)->children(); -// -// for (std::size_t i = 0; i < children.size(); i++) { -// std::vector newIds = getAllBEIDsOfElement(children[i]); -// ids.insert(ids.end(), newIds.begin(), newIds.end()); -// } -// break; -// } -// case storm::storage::DFTElementType::SPARE: -// { -// auto children = std::static_pointer_cast const>(dftElement)->children(); -// -// // Only regard the primary child of a SPARE. The spare childs are not allowed to be listed here. -// for (std::size_t i = 0; i < 1; i++) { -// std::vector newIds = getAllBEIDsOfElement(children[i]); -// ids.insert(ids.end(), newIds.begin(), newIds.end()); -// } -// break; -// } -// case storm::storage::DFTElementType::POR: -// { -// auto children = std::static_pointer_cast const>(dftElement)->children(); -// -// for (std::size_t i = 0; i < children.size(); i++) { -// std::vector newIds = getAllBEIDsOfElement(children[i]); -// ids.insert(ids.end(), newIds.begin(), newIds.end()); -// } -// break; -// } -// case storm::storage::DFTElementType::BE: -// case storm::storage::DFTElementType::CONSTF: -// case storm::storage::DFTElementType::CONSTS: -// { -// ids.push_back(dftElement->id()); -// break; -// } -// case storm::storage::DFTElementType::SEQ: -// case storm::storage::DFTElementType::MUTEX: -// case storm::storage::DFTElementType::PDEP: -// { -// break; -// } -// default: -// { -// STORM_LOG_ASSERT(false, "DFT type unknown."); -// break; -// } -// } -// -// return ids; - } - + template void DftToGspnTransformator::writeGspn(bool toFile) { if (toFile) { diff --git a/src/storm/transformations/dft/DftToGspnTransformator.h b/src/storm/transformations/dft/DftToGspnTransformator.h index 76250bfbf..1e0d3eb69 100644 --- a/src/storm/transformations/dft/DftToGspnTransformator.h +++ b/src/storm/transformations/dft/DftToGspnTransformator.h @@ -40,17 +40,6 @@ namespace storm { * Draw all elements of the GSPN. */ void drawGSPNElements(); - - /* - * Draw the connections between the elements of the GSPN. - */ - void drawGSPNConnections(); - - /* - * Draw functional/probability dependencies into the GSPN. - */ - void drawGSPNDependencies(); - /* * Draw restrictions between the elements of the GSPN (i.e. SEQ or MUTEX). */ @@ -142,16 +131,9 @@ namespace storm { * @param dftElement The element whose priority shall be determined. */ uint64_t getFailPriority(std::shared_ptr const> dFTElement); - - /* - * Return all ids of BEs, that are successors of the given element and that are not the spare childs of a SPARE. - * - * @param dftElement The element which - */ - std::vector getAllBEIDsOfElement(std::shared_ptr const> dftElement); - + - uint64_t addUnavailableNode(std::shared_ptr const> dftElement); + uint64_t addUnavailableNode(std::shared_ptr const> dftElement, bool initialAvailable = true); storm::storage::DFT const& mDft; storm::gspn::GspnBuilder builder; From b2b04fa76bc2715842670f082974f38d97be5d88 Mon Sep 17 00:00:00 2001 From: sjunges Date: Fri, 25 Nov 2016 00:35:25 +0100 Subject: [PATCH 03/47] moving dfts to their own lib and cli --- src/storm-dft-cli/storm-dyftee.cpp | 5 ++--- src/storm-dft/modelchecker/dft/DFTModelChecker.cpp | 7 +++++++ 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/src/storm-dft-cli/storm-dyftee.cpp b/src/storm-dft-cli/storm-dyftee.cpp index 71f5cea86..c0b0b58b2 100644 --- a/src/storm-dft-cli/storm-dyftee.cpp +++ b/src/storm-dft-cli/storm-dyftee.cpp @@ -6,6 +6,7 @@ #include "storm/utility/macros.h" #include "storm/transformations/dft/DftToGspnTransformator.h" + #include "storm/settings/modules/GeneralSettings.h" #include "storm/settings/modules/CoreSettings.h" #include "storm/settings/modules/DebugSettings.h" @@ -17,6 +18,7 @@ #include "storm-dft/parser/DFTGalileoParser.h" #include "storm-dft/modelchecker/dft/DFTModelChecker.h" #include "storm-dft/modelchecker/dft/DFTASFChecker.h" +#include "storm-dft/transformations/dft/DftToGspnTransformator.h" #include "storm-dft/settings/modules/DFTSettings.h" @@ -79,11 +81,8 @@ template storm::gspn::GSPN transformDFT(std::string filename) { storm::parser::DFTGalileoParser parser; storm::storage::DFT dft = parser.parseDFT(filename); -<<<<<<< f8986fe6139bddaf5068477b0f70ac1f806f8576:src/storm-dft-cli/storm-dyftee.cpp -======= storm::transformations::dft::DftToGspnTransformator gspnTransformator(dft); gspnTransformator.transform(); ->>>>>>> updated dft->gspn translation to now have basis support for spares:src/storm/storm-dyftee.cpp } /*! diff --git a/src/storm-dft/modelchecker/dft/DFTModelChecker.cpp b/src/storm-dft/modelchecker/dft/DFTModelChecker.cpp index ae4144ee7..6c1834d78 100644 --- a/src/storm-dft/modelchecker/dft/DFTModelChecker.cpp +++ b/src/storm-dft/modelchecker/dft/DFTModelChecker.cpp @@ -1,12 +1,19 @@ #include "DFTModelChecker.h" #include "storm/builder/ParallelCompositionBuilder.h" +<<<<<<< 297f3ff48076dbf9b67056c82bc97409ef9fd445:src/storm-dft/modelchecker/dft/DFTModelChecker.cpp +======= +#include "storm/settings/modules/DFTSettings.h" +>>>>>>> moving dfts to their own lib and cli:src/storm-dft/modelchecker/dft/DFTModelChecker.cpp #include "storm/utility/bitoperations.h" #include "storm-dft/builder/ExplicitDFTModelBuilder.h" #include "storm-dft/builder/ExplicitDFTModelBuilderApprox.h" #include "storm-dft/storage/dft/DFTIsomorphism.h" +<<<<<<< 297f3ff48076dbf9b67056c82bc97409ef9fd445:src/storm-dft/modelchecker/dft/DFTModelChecker.cpp #include "storm-dft/settings/modules/DFTSettings.h" +======= +>>>>>>> moving dfts to their own lib and cli:src/storm-dft/modelchecker/dft/DFTModelChecker.cpp namespace storm { namespace modelchecker { From 2b7610244d759ecb4742361e5d1de801f4315b9a Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Fri, 25 Nov 2016 11:27:25 +0100 Subject: [PATCH 04/47] storm-dft running again --- src/storm-dft/modelchecker/dft/DFTModelChecker.cpp | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/src/storm-dft/modelchecker/dft/DFTModelChecker.cpp b/src/storm-dft/modelchecker/dft/DFTModelChecker.cpp index 6c1834d78..2de46e599 100644 --- a/src/storm-dft/modelchecker/dft/DFTModelChecker.cpp +++ b/src/storm-dft/modelchecker/dft/DFTModelChecker.cpp @@ -1,19 +1,13 @@ #include "DFTModelChecker.h" #include "storm/builder/ParallelCompositionBuilder.h" -<<<<<<< 297f3ff48076dbf9b67056c82bc97409ef9fd445:src/storm-dft/modelchecker/dft/DFTModelChecker.cpp -======= -#include "storm/settings/modules/DFTSettings.h" ->>>>>>> moving dfts to their own lib and cli:src/storm-dft/modelchecker/dft/DFTModelChecker.cpp #include "storm/utility/bitoperations.h" #include "storm-dft/builder/ExplicitDFTModelBuilder.h" #include "storm-dft/builder/ExplicitDFTModelBuilderApprox.h" #include "storm-dft/storage/dft/DFTIsomorphism.h" -<<<<<<< 297f3ff48076dbf9b67056c82bc97409ef9fd445:src/storm-dft/modelchecker/dft/DFTModelChecker.cpp #include "storm-dft/settings/modules/DFTSettings.h" -======= ->>>>>>> moving dfts to their own lib and cli:src/storm-dft/modelchecker/dft/DFTModelChecker.cpp + namespace storm { namespace modelchecker { From 0fa736d4588650eee8d3cddd597a427682d760bd Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Mon, 21 Nov 2016 22:05:10 +0100 Subject: [PATCH 05/47] updated dft->gspn translation to now have basis support for spares --- .../dft/DftToGspnTransformator.cpp | 473 ++++++++++++++++++ 1 file changed, 473 insertions(+) diff --git a/src/storm/transformations/dft/DftToGspnTransformator.cpp b/src/storm/transformations/dft/DftToGspnTransformator.cpp index 730656b35..f63e80f0a 100644 --- a/src/storm/transformations/dft/DftToGspnTransformator.cpp +++ b/src/storm/transformations/dft/DftToGspnTransformator.cpp @@ -221,6 +221,10 @@ namespace storm { builder.addInputArc(failedNodes[dftPand->children().at(j)->id()], tfs); builder.addInhibitionArc(failedNodes[dftPand->children().at(j-1)->id()], tfs); builder.addOutputArc(tfs, nodeFS); +<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 +======= + +>>>>>>> updated dft->gspn translation to now have basis support for spares } } // @@ -234,7 +238,11 @@ namespace storm { unavailableNode = addUnavailableNode(dftSpare); } uint64_t spareActive = builder.addPlace(defaultCapacity, 0, dftSpare->name() + STR_ACTIVATED); +<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 activeNodes.emplace(dftSpare->id(), spareActive); +======= + activeNodes.emplace(dftBE->id(), beActive); +>>>>>>> updated dft->gspn translation to now have basis support for spares std::vector cucNodes; @@ -270,16 +278,127 @@ namespace storm { builder.addInputArc(failedNodes.at(child->id()), tnextcl); builder.addOutputArc(tnextcl, failedNodes.at(child->id())); nextclTransitions.push_back(tnextcl); +<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 +======= + + +>>>>>>> updated dft->gspn translation to now have basis support for spares ++j; } builder.addOutputArc(nextconsiderTransitions.back(), nodeFailed); builder.addOutputArc(nextclTransitions.back(), nodeFailed); +<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 +======= + +>>>>>>> updated dft->gspn translation to now have basis support for spares if (isRepresentative) { builder.addOutputArc(nextconsiderTransitions.back(), unavailableNode); builder.addOutputArc(nextclTransitions.back(), unavailableNode); } +<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 +======= + + +// uint_fast64_t priority = getPriority(0, dftSpare); +// +// // This codeblock can be removed later, when I am 100% sure it is not needed anymore. +// /* +// storm::gspn::Place placeSPAREActivated; +// placeSPAREActivated.setName(dftSpare->name() + STR_ACTIVATED); +// placeSPAREActivated.setNumberOfInitialTokens(isBEActive(dftSpare)); +// mGspn.addPlace(placeSPAREActivated); +// +// storm::gspn::ImmediateTransition immediateTransitionPCActivating; +// immediateTransitionPCActivating.setName(dftSpare->children()[0]->name() + STR_ACTIVATING); +// immediateTransitionPCActivating.setPriority(priority); +// immediateTransitionPCActivating.setWeight(0.0); +// immediateTransitionPCActivating.setInputArcMultiplicity(placeSPAREActivated, 1); +// immediateTransitionPCActivating.setOutputArcMultiplicity(placeSPAREActivated, 1); +// mGspn.addImmediateTransition(immediateTransitionPCActivating); +// */ +// +// auto children = dftSpare->children(); +// +// // Draw places and transitions that belong to each spare child. +// for (std::size_t i = 1; i < children.size(); i++) { +// auto placeChildClaimedPreexist = mGspn.getPlace(children[i]->name() + "_claimed"); +// +// if (!placeChildClaimedPreexist.first) { // Only draw this place if it doesn't exist jet. +// storm::gspn::Place placeChildClaimed; +// placeChildClaimed.setName(children[i]->name() + "_claimed"); +// placeChildClaimed.setNumberOfInitialTokens(0); +// mGspn.addPlace(placeChildClaimed); +// +// storm::gspn::ImmediateTransition immediateTransitionSpareChildActivating; +// immediateTransitionSpareChildActivating.setName(children[i]->name() + STR_ACTIVATING); +// immediateTransitionSpareChildActivating.setPriority(priority); +// immediateTransitionSpareChildActivating.setWeight(0.0); +// immediateTransitionSpareChildActivating.setInputArcMultiplicity(placeChildClaimed, 1); +// immediateTransitionSpareChildActivating.setOutputArcMultiplicity(placeChildClaimed, 1); +// mGspn.addImmediateTransition(immediateTransitionSpareChildActivating); +// } +// +// auto placeChildClaimedExist = mGspn.getPlace(children[i]->name() + "_claimed"); +// +// storm::gspn::Place placeSPAREClaimedChild; +// placeSPAREClaimedChild.setName(dftSpare->name() + "_claimed_" + children[i]->name()); +// placeSPAREClaimedChild.setNumberOfInitialTokens(0); +// mGspn.addPlace(placeSPAREClaimedChild); +// +// storm::gspn::ImmediateTransition immediateTransitionChildClaiming; +// immediateTransitionChildClaiming.setName(dftSpare->name() + "_claiming_" + children[i]->name()); +// immediateTransitionChildClaiming.setPriority(priority + 1); // Higher priority needed! +// immediateTransitionChildClaiming.setWeight(0.0); +// immediateTransitionChildClaiming.setInhibitionArcMultiplicity(placeChildClaimedExist.second, 1); +// immediateTransitionChildClaiming.setOutputArcMultiplicity(placeChildClaimedExist.second, 1); +// immediateTransitionChildClaiming.setOutputArcMultiplicity(placeSPAREClaimedChild, 1); +// mGspn.addImmediateTransition(immediateTransitionChildClaiming); +// +// storm::gspn::Place placeSPAREChildConsumed; +// if (i < children.size() - 1) { +// placeSPAREChildConsumed.setName(dftSpare->name() + "_" + children[i]->name() + "_consumed"); +// } +// else { +// placeSPAREChildConsumed.setName(dftSpare->name() + STR_FAILED); +// } +// placeSPAREChildConsumed.setNumberOfInitialTokens(0); +// mGspn.addPlace(placeSPAREChildConsumed); +// +// storm::gspn::ImmediateTransition immediateTransitionChildConsuming1; +// immediateTransitionChildConsuming1.setName(dftSpare->name() + "_" + children[i]->name() + "_consuming1"); +// immediateTransitionChildConsuming1.setPriority(priority); +// immediateTransitionChildConsuming1.setWeight(0.0); +// immediateTransitionChildConsuming1.setOutputArcMultiplicity(placeSPAREChildConsumed, 1); +// immediateTransitionChildConsuming1.setInhibitionArcMultiplicity(placeSPAREChildConsumed, 1); +// immediateTransitionChildConsuming1.setInhibitionArcMultiplicity(placeSPAREClaimedChild, 1); +// mGspn.addImmediateTransition(immediateTransitionChildConsuming1); +// +// storm::gspn::ImmediateTransition immediateTransitionChildConsuming2; +// immediateTransitionChildConsuming2.setName(dftSpare->name() + "_" + children[i]->name() + "_consuming2"); +// immediateTransitionChildConsuming2.setPriority(priority); +// immediateTransitionChildConsuming2.setWeight(0.0); +// immediateTransitionChildConsuming2.setOutputArcMultiplicity(placeSPAREChildConsumed, 1); +// immediateTransitionChildConsuming2.setInhibitionArcMultiplicity(placeSPAREChildConsumed, 1); +// immediateTransitionChildConsuming2.setOutputArcMultiplicity(placeSPAREClaimedChild, 1); +// immediateTransitionChildConsuming2.setInputArcMultiplicity(placeSPAREClaimedChild, 1); +// mGspn.addImmediateTransition(immediateTransitionChildConsuming2); +// } +// +// // Draw connections between all spare childs. +// for (std::size_t i = 1; i < children.size() - 1; i++) { +// auto placeSPAREChildConsumed = mGspn.getPlace(dftSpare->name() + "_" + children[i]->name() + "_consumed"); +// auto immediateTransitionChildClaiming = mGspn.getImmediateTransition(dftSpare->name() + "_claiming_" + children[i + 1]->name()); +// auto immediateTransitionChildConsuming1 = mGspn.getImmediateTransition(dftSpare->name() + "_" + children[i + 1]->name() + "_consuming1"); +// +// immediateTransitionChildClaiming.second->setOutputArcMultiplicity(placeSPAREChildConsumed.second, 1); +// immediateTransitionChildClaiming.second->setInputArcMultiplicity(placeSPAREChildConsumed.second, 1); +// +// immediateTransitionChildConsuming1.second->setOutputArcMultiplicity(placeSPAREChildConsumed.second, 1); +// immediateTransitionChildConsuming1.second->setInputArcMultiplicity(placeSPAREChildConsumed.second, 1); +// } +>>>>>>> updated dft->gspn translation to now have basis support for spares } // template @@ -308,11 +427,18 @@ namespace storm { // template void DftToGspnTransformator::drawCONSTF(std::shared_ptr const> dftConstF, bool isRepresentative) { +<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 failedNodes.push_back(builder.addPlace(defaultCapacity, 1, dftConstF->name() + STR_FAILED)); uint64_t unavailableNode = 0; if (isRepresentative) { unavailableNode = addUnavailableNode(dftConstF, false); } +======= +// storm::gspn::Place placeCONSTFFailed; +// placeCONSTFFailed.setName(dftConstF->name() + STR_FAILED); +// placeCONSTFFailed.setNumberOfInitialTokens(1); +// mGspn.addPlace(placeCONSTFFailed); +>>>>>>> updated dft->gspn translation to now have basis support for spares } // template @@ -346,14 +472,237 @@ namespace storm { } template +<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 uint64_t DftToGspnTransformator::addUnavailableNode(std::shared_ptr const> dftElement, bool initialAvailable) { uint64_t unavailableNode = builder.addPlace(defaultCapacity, initialAvailable ? 0 : 1, dftElement->name() + "_unavailable"); +======= + uint64_t DftToGspnTransformator::addUnavailableNode(std::shared_ptr const> dftElement) { + uint64_t unavailableNode = builder.addPlace(defaultCapacity, 1, dftElement->name() + "_unavailable"); +>>>>>>> updated dft->gspn translation to now have basis support for spares assert(unavailableNode != 0); unavailableNodes.emplace(dftElement->id(), unavailableNode); return unavailableNode; } // +<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 +======= + template + void DftToGspnTransformator::drawGSPNConnections() { +// // Check for every element, if they have parents (all will have at least 1, except the top event). +// for (std::size_t i = 0; i < mDft.nrElements(); i++) { +// auto child = mDft.getElement(i); +// auto parents = child->parentIds(); +// +// // Draw a connection to every parent. +// for (std::size_t j = 0; j < parents.size(); j++) { +// // Check the type of the parent and act accordingly (every parent gate has different entry points...). +// switch (mDft.getElement(parents[j])->type()) { +// case storm::storage::DFTElementType::AND: +// { +// auto andEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILING); +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// if (andEntry.first && childExit.first) { // Only add arcs if the objects have been found. +// andEntry.second->setInputArcMultiplicity(childExit.second, 1); +// andEntry.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// break; +// } +// case storm::storage::DFTElementType::OR: +// { +// auto orEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + child->name() + STR_FAILING); +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// if (orEntry.first && childExit.first) { // Only add arcs if the objects have been found. +// orEntry.second->setInputArcMultiplicity(childExit.second, 1); +// orEntry.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// break; +// } +// case storm::storage::DFTElementType::VOT: +// { +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// auto parentEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + child->name() + "_collecting"); +// +// if (childExit.first && parentEntry.first) { // Only add arcs if the objects have been found. +// parentEntry.second->setInputArcMultiplicity(childExit.second, 1); +// parentEntry.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// +// break; +// } +// case storm::storage::DFTElementType::PAND: +// { +// auto children = std::static_pointer_cast const>(mDft.getElement(parents[j]))->children(); +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// auto pandEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILING); +// +// if (childExit.first && pandEntry.first) { // Only add arcs if the objects have been found. +// pandEntry.second->setInputArcMultiplicity(childExit.second, 1); +// pandEntry.second->setOutputArcMultiplicity(childExit.second, 1); +// +// if (children[0] == child) { // Current element is primary child. +// auto pandEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_0" + STR_FAILSAVING); +// +// if (pandEntry2.first) { +// pandEntry2.second->setInhibitionArcMultiplicity(childExit.second, 1); +// } +// } +// else { // Current element is not the primary child. +// for (std::size_t k = 1; k < children.size(); k++) { +// if (children[k] == child) { +// auto pandEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + std::to_string((k - 1)) + STR_FAILSAVING); +// auto pandEntry3 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + std::to_string((k)) + STR_FAILSAVING); +// +// if (pandEntry2.first) { +// pandEntry2.second->setInputArcMultiplicity(childExit.second, 1); +// pandEntry2.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// +// if (pandEntry3.first) { +// pandEntry3.second->setInhibitionArcMultiplicity(childExit.second, 1); +// } +// +// continue; +// } +// } +// } +// } +// +// break; +// } +// case storm::storage::DFTElementType::SPARE: +// { +// // Check if current child is a primary or spare child. +// auto children = std::static_pointer_cast const>(mDft.getElement(parents[j]))->children(); +// +// if (child == children[0]) { // Primary child. +// auto spareExit = mGspn.getImmediateTransition(child->name() + STR_ACTIVATING); +// +// std::vector ids = getAllBEIDsOfElement(child); +// for (std::size_t k = 0; k < ids.size(); k++) { +// auto childEntry = mGspn.getPlace(mDft.getElement(ids[k])->name() + STR_ACTIVATED); +// +// if (spareExit.first && childEntry.first) { // Only add arcs if the objects have been found. +// spareExit.second->setInhibitionArcMultiplicity(childEntry.second, 1); +// spareExit.second->setOutputArcMultiplicity(childEntry.second, 1); +// } +// } +// +// // Draw lines from "primary child_failed" to SPARE. +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// auto spareEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_claiming_" + children[1]->name()); +// auto spareEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + children[1]->name() + "_consuming1"); +// +// if (childExit.first && spareEntry.first && spareEntry2.first) { // Only add arcs if the objects have been found. +// spareEntry.second->setInputArcMultiplicity(childExit.second, 1); +// spareEntry.second->setOutputArcMultiplicity(childExit.second, 1); +// +// spareEntry2.second->setInputArcMultiplicity(childExit.second, 1); +// spareEntry2.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// } +// else { // A spare child. +// auto spareExit = mGspn.getImmediateTransition(child->name() + STR_ACTIVATING); +// auto spareExit2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_claiming_" + child->name()); +// +// std::vector ids = getAllBEIDsOfElement(child); +// for (std::size_t k = 0; k < ids.size(); k++) { +// auto childEntry = mGspn.getPlace(mDft.getElement(ids[k])->name() + STR_ACTIVATED); +// +// if (spareExit.first && spareExit2.first && childEntry.first) { // Only add arcs if the objects have been found. +// if (!spareExit.second->existsInhibitionArc(childEntry.second)) { +// spareExit.second->setInhibitionArcMultiplicity(childEntry.second, 1); +// } +// if (!spareExit.second->existsOutputArc(childEntry.second)) { +// spareExit.second->setOutputArcMultiplicity(childEntry.second, 1); +// } +// if (!spareExit2.second->existsInhibitionArc(childEntry.second)) { +// spareExit2.second->setInhibitionArcMultiplicity(childEntry.second, 1); +// } +// } +// } +// +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// auto spareEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_claiming_" + child->name()); +// auto spareEntry2 = mGspn.getImmediateTransition(child->name() + STR_ACTIVATING); +// auto spareEntry3 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + child->name() + "_consuming2"); +// +// if (childExit.first && spareEntry.first && spareEntry2.first && spareEntry3.first) { // Only add arcs if the objects have been found. +// spareEntry.second->setInhibitionArcMultiplicity(childExit.second, 1); +// +// if (!spareEntry2.second->existsInhibitionArc(childExit.second)) { +// spareEntry2.second->setInhibitionArcMultiplicity(childExit.second, 1); +// } +// +// spareEntry3.second->setInputArcMultiplicity(childExit.second, 1); +// spareEntry3.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// } +// +// break; +// } +// case storm::storage::DFTElementType::POR: +// { +// auto children = std::static_pointer_cast const>(mDft.getElement(parents[j]))->children(); +// auto porEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILING); +// auto porEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILSAVING); +// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); +// +// if (porEntry.first && porEntry2.first && childExit.first) { // Only add arcs if the objects have been found. +// if (children[0] == child) { // Current element is primary child. +// porEntry.second->setInputArcMultiplicity(childExit.second, 1); +// porEntry.second->setOutputArcMultiplicity(childExit.second, 1); +// porEntry2.second->setInhibitionArcMultiplicity(childExit.second, 1); +// +// } +// else { // Current element is not the primary child. +// porEntry2.second->setInputArcMultiplicity(childExit.second, 1); +// porEntry2.second->setOutputArcMultiplicity(childExit.second, 1); +// } +// } +// +// break; +// } +// case storm::storage::DFTElementType::SEQ: +// { +// // Sequences are realized with restrictions. Nothing to do here. +// break; +// } +// case storm::storage::DFTElementType::MUTEX: +// { +// // MUTEX are realized with restrictions. Nothing to do here. +// break; +// } +// case storm::storage::DFTElementType::BE: +// { +// // The parent is never a Basic Event. +// break; +// } +// case storm::storage::DFTElementType::CONSTF: +// { +// // The parent is never a Basic Event. +// break; +// } +// case storm::storage::DFTElementType::CONSTS: +// { +// // The parent is never a Basic Event. +// break; +// } +// case storm::storage::DFTElementType::PDEP: +// { +// // The parent is never a DEP. Hence the connections must be drawn somewhere else. +// break; +// } +// default: +// { +// STORM_LOG_ASSERT(false, "DFT type unknown."); +// break; +// } +// } +// } +// } + } +>>>>>>> updated dft->gspn translation to now have basis support for spares template bool DftToGspnTransformator::isBEActive(std::shared_ptr const> dftElement) @@ -395,7 +744,38 @@ namespace storm { { return mDft.maxRank() - dftElement->rank(); } +<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 +======= + + template + void DftToGspnTransformator::drawGSPNDependencies() { +// for (std::size_t i = 0; i < mDft.nrElements(); i++) { +// auto dftElement = mDft.getElement(i); +// +// if (dftElement->isDependency()) { +// std::string gateName = dftElement->name().substr(0, dftElement->name().find("_")); +// auto depEntry = mGspn.getTimedTransition(gateName + STR_FAILING); +// auto trigger = mGspn.getPlace(std::static_pointer_cast const>(dftElement)->nameTrigger() + STR_FAILED); +// +// if (depEntry.first && trigger.first) { // Only add arcs if the objects have been found. +// if (!depEntry.second->existsInputArc(trigger.second)) { +// depEntry.second->setInputArcMultiplicity(trigger.second, 1); +// } +// if (!depEntry.second->existsOutputArc(trigger.second)){ +// depEntry.second->setOutputArcMultiplicity(trigger.second, 1); +// } +// } +// +// auto dependent = mGspn.getPlace(std::static_pointer_cast const>(dftElement)->nameDependent() + STR_FAILED); +// +// if (dependent.first) { // Only add arcs if the objects have been found. +// depEntry.second->setOutputArcMultiplicity(dependent.second, 1); +// } +// } +// } + } +>>>>>>> updated dft->gspn translation to now have basis support for spares template void DftToGspnTransformator::drawGSPNRestrictions() { @@ -453,7 +833,100 @@ namespace storm { // } // } } +<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 +======= + + template + std::vector DftToGspnTransformator::getAllBEIDsOfElement(std::shared_ptr const> dftElement) { +// std::vector ids; +// +// switch (dftElement->type()) { +// case storm::storage::DFTElementType::AND: +// { +// auto children = std::static_pointer_cast const>(dftElement)->children(); +// +// for (std::size_t i = 0; i < children.size(); i++) { +// std::vector newIds = getAllBEIDsOfElement(children[i]); +// ids.insert(ids.end(), newIds.begin(), newIds.end()); +// } +// break; +// } +// case storm::storage::DFTElementType::OR: +// { +// auto children = std::static_pointer_cast const>(dftElement)->children(); +// +// for (std::size_t i = 0; i < children.size(); i++) { +// std::vector newIds = getAllBEIDsOfElement(children[i]); +// ids.insert(ids.end(), newIds.begin(), newIds.end()); +// } +// break; +// } +// case storm::storage::DFTElementType::VOT: +// { +// auto children = std::static_pointer_cast const>(dftElement)->children(); +// +// for (std::size_t i = 0; i < children.size(); i++) { +// std::vector newIds = getAllBEIDsOfElement(children[i]); +// ids.insert(ids.end(), newIds.begin(), newIds.end()); +// } +// break; +// } +// case storm::storage::DFTElementType::PAND: +// { +// auto children = std::static_pointer_cast const>(dftElement)->children(); +// +// for (std::size_t i = 0; i < children.size(); i++) { +// std::vector newIds = getAllBEIDsOfElement(children[i]); +// ids.insert(ids.end(), newIds.begin(), newIds.end()); +// } +// break; +// } +// case storm::storage::DFTElementType::SPARE: +// { +// auto children = std::static_pointer_cast const>(dftElement)->children(); +// +// // Only regard the primary child of a SPARE. The spare childs are not allowed to be listed here. +// for (std::size_t i = 0; i < 1; i++) { +// std::vector newIds = getAllBEIDsOfElement(children[i]); +// ids.insert(ids.end(), newIds.begin(), newIds.end()); +// } +// break; +// } +// case storm::storage::DFTElementType::POR: +// { +// auto children = std::static_pointer_cast const>(dftElement)->children(); +// +// for (std::size_t i = 0; i < children.size(); i++) { +// std::vector newIds = getAllBEIDsOfElement(children[i]); +// ids.insert(ids.end(), newIds.begin(), newIds.end()); +// } +// break; +// } +// case storm::storage::DFTElementType::BE: +// case storm::storage::DFTElementType::CONSTF: +// case storm::storage::DFTElementType::CONSTS: +// { +// ids.push_back(dftElement->id()); +// break; +// } +// case storm::storage::DFTElementType::SEQ: +// case storm::storage::DFTElementType::MUTEX: +// case storm::storage::DFTElementType::PDEP: +// { +// break; +// } +// default: +// { +// STORM_LOG_ASSERT(false, "DFT type unknown."); +// break; +// } +// } +// +// return ids; + } + +>>>>>>> updated dft->gspn translation to now have basis support for spares template void DftToGspnTransformator::writeGspn(bool toFile) { if (toFile) { From d4f7088cfd7d7dc07dea605e783690ebd619f599 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Fri, 2 Dec 2016 13:58:59 +0100 Subject: [PATCH 06/47] updates to dft->gspn --- src/storm-dft-cli/storm-dyftee.cpp | 5 ++--- src/storm-dft/CMakeLists.txt | 2 +- .../transformations}/DftToGspnTransformator.cpp | 0 .../transformations}/DftToGspnTransformator.h | 6 +++--- 4 files changed, 6 insertions(+), 7 deletions(-) rename src/{storm/transformations/dft => storm-dft/transformations}/DftToGspnTransformator.cpp (100%) rename src/{storm/transformations/dft => storm-dft/transformations}/DftToGspnTransformator.h (97%) diff --git a/src/storm-dft-cli/storm-dyftee.cpp b/src/storm-dft-cli/storm-dyftee.cpp index c0b0b58b2..3056cbdf1 100644 --- a/src/storm-dft-cli/storm-dyftee.cpp +++ b/src/storm-dft-cli/storm-dyftee.cpp @@ -3,8 +3,6 @@ #include "storm/utility/storm.h" #include "storm/cli/cli.h" #include "storm/exceptions/BaseException.h" -#include "storm/utility/macros.h" -#include "storm/transformations/dft/DftToGspnTransformator.h" #include "storm/settings/modules/GeneralSettings.h" @@ -18,7 +16,8 @@ #include "storm-dft/parser/DFTGalileoParser.h" #include "storm-dft/modelchecker/dft/DFTModelChecker.h" #include "storm-dft/modelchecker/dft/DFTASFChecker.h" -#include "storm-dft/transformations/dft/DftToGspnTransformator.h" +#include "storm-dft/transformations/DftToGspnTransformator.h" + #include "storm-dft/settings/modules/DFTSettings.h" diff --git a/src/storm-dft/CMakeLists.txt b/src/storm-dft/CMakeLists.txt index df0c067e0..10d9b8508 100644 --- a/src/storm-dft/CMakeLists.txt +++ b/src/storm-dft/CMakeLists.txt @@ -10,4 +10,4 @@ file(GLOB_RECURSE STORM_DFT_HEADERS ${PROJECT_SOURCE_DIR}/src/storm-dft/*/*.h) # Create storm-pgcl. add_library(storm-dft SHARED ${STORM_DFT_SOURCES} ${STORM_DFT_HEADERS}) -target_link_libraries(storm-dft storm ${STORM_DFT_LINK_LIBRARIES}) +target_link_libraries(storm-dft storm storm-gspn ${STORM_DFT_LINK_LIBRARIES}) diff --git a/src/storm/transformations/dft/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp similarity index 100% rename from src/storm/transformations/dft/DftToGspnTransformator.cpp rename to src/storm-dft/transformations/DftToGspnTransformator.cpp diff --git a/src/storm/transformations/dft/DftToGspnTransformator.h b/src/storm-dft/transformations/DftToGspnTransformator.h similarity index 97% rename from src/storm/transformations/dft/DftToGspnTransformator.h rename to src/storm-dft/transformations/DftToGspnTransformator.h index 1e0d3eb69..4d827e44b 100644 --- a/src/storm/transformations/dft/DftToGspnTransformator.h +++ b/src/storm-dft/transformations/DftToGspnTransformator.h @@ -1,8 +1,8 @@ #pragma once -#include "storm/storage/dft/DFT.h" -#include "storm/storage/gspn/GSPN.h" -#include "storm/storage/gspn/GspnBuilder.h" +#include "storm-dft/storage/dft/DFT.h" +#include "storm-gspn/storage/gspn/GSPN.h" +#include "storm-gspn/storage/gspn/GspnBuilder.h" namespace storm { namespace transformations { From f2a8c1be401c0e9a934f597e90220a02b57fd4bc Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Fri, 2 Dec 2016 14:12:19 +0100 Subject: [PATCH 07/47] post-rebase fix --- .../DftToGspnTransformator.cpp | 477 +----------------- 1 file changed, 3 insertions(+), 474 deletions(-) diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index f63e80f0a..49f58707f 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -221,10 +221,7 @@ namespace storm { builder.addInputArc(failedNodes[dftPand->children().at(j)->id()], tfs); builder.addInhibitionArc(failedNodes[dftPand->children().at(j-1)->id()], tfs); builder.addOutputArc(tfs, nodeFS); -<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 -======= - ->>>>>>> updated dft->gspn translation to now have basis support for spares + } } // @@ -238,11 +235,7 @@ namespace storm { unavailableNode = addUnavailableNode(dftSpare); } uint64_t spareActive = builder.addPlace(defaultCapacity, 0, dftSpare->name() + STR_ACTIVATED); -<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 activeNodes.emplace(dftSpare->id(), spareActive); -======= - activeNodes.emplace(dftBE->id(), beActive); ->>>>>>> updated dft->gspn translation to now have basis support for spares std::vector cucNodes; @@ -278,127 +271,17 @@ namespace storm { builder.addInputArc(failedNodes.at(child->id()), tnextcl); builder.addOutputArc(tnextcl, failedNodes.at(child->id())); nextclTransitions.push_back(tnextcl); -<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 - -======= - - ->>>>>>> updated dft->gspn translation to now have basis support for spares ++j; } builder.addOutputArc(nextconsiderTransitions.back(), nodeFailed); builder.addOutputArc(nextclTransitions.back(), nodeFailed); -<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 -======= - ->>>>>>> updated dft->gspn translation to now have basis support for spares if (isRepresentative) { builder.addOutputArc(nextconsiderTransitions.back(), unavailableNode); builder.addOutputArc(nextclTransitions.back(), unavailableNode); } -<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 -======= - -// uint_fast64_t priority = getPriority(0, dftSpare); -// -// // This codeblock can be removed later, when I am 100% sure it is not needed anymore. -// /* -// storm::gspn::Place placeSPAREActivated; -// placeSPAREActivated.setName(dftSpare->name() + STR_ACTIVATED); -// placeSPAREActivated.setNumberOfInitialTokens(isBEActive(dftSpare)); -// mGspn.addPlace(placeSPAREActivated); -// -// storm::gspn::ImmediateTransition immediateTransitionPCActivating; -// immediateTransitionPCActivating.setName(dftSpare->children()[0]->name() + STR_ACTIVATING); -// immediateTransitionPCActivating.setPriority(priority); -// immediateTransitionPCActivating.setWeight(0.0); -// immediateTransitionPCActivating.setInputArcMultiplicity(placeSPAREActivated, 1); -// immediateTransitionPCActivating.setOutputArcMultiplicity(placeSPAREActivated, 1); -// mGspn.addImmediateTransition(immediateTransitionPCActivating); -// */ -// -// auto children = dftSpare->children(); -// -// // Draw places and transitions that belong to each spare child. -// for (std::size_t i = 1; i < children.size(); i++) { -// auto placeChildClaimedPreexist = mGspn.getPlace(children[i]->name() + "_claimed"); -// -// if (!placeChildClaimedPreexist.first) { // Only draw this place if it doesn't exist jet. -// storm::gspn::Place placeChildClaimed; -// placeChildClaimed.setName(children[i]->name() + "_claimed"); -// placeChildClaimed.setNumberOfInitialTokens(0); -// mGspn.addPlace(placeChildClaimed); -// -// storm::gspn::ImmediateTransition immediateTransitionSpareChildActivating; -// immediateTransitionSpareChildActivating.setName(children[i]->name() + STR_ACTIVATING); -// immediateTransitionSpareChildActivating.setPriority(priority); -// immediateTransitionSpareChildActivating.setWeight(0.0); -// immediateTransitionSpareChildActivating.setInputArcMultiplicity(placeChildClaimed, 1); -// immediateTransitionSpareChildActivating.setOutputArcMultiplicity(placeChildClaimed, 1); -// mGspn.addImmediateTransition(immediateTransitionSpareChildActivating); -// } -// -// auto placeChildClaimedExist = mGspn.getPlace(children[i]->name() + "_claimed"); -// -// storm::gspn::Place placeSPAREClaimedChild; -// placeSPAREClaimedChild.setName(dftSpare->name() + "_claimed_" + children[i]->name()); -// placeSPAREClaimedChild.setNumberOfInitialTokens(0); -// mGspn.addPlace(placeSPAREClaimedChild); -// -// storm::gspn::ImmediateTransition immediateTransitionChildClaiming; -// immediateTransitionChildClaiming.setName(dftSpare->name() + "_claiming_" + children[i]->name()); -// immediateTransitionChildClaiming.setPriority(priority + 1); // Higher priority needed! -// immediateTransitionChildClaiming.setWeight(0.0); -// immediateTransitionChildClaiming.setInhibitionArcMultiplicity(placeChildClaimedExist.second, 1); -// immediateTransitionChildClaiming.setOutputArcMultiplicity(placeChildClaimedExist.second, 1); -// immediateTransitionChildClaiming.setOutputArcMultiplicity(placeSPAREClaimedChild, 1); -// mGspn.addImmediateTransition(immediateTransitionChildClaiming); -// -// storm::gspn::Place placeSPAREChildConsumed; -// if (i < children.size() - 1) { -// placeSPAREChildConsumed.setName(dftSpare->name() + "_" + children[i]->name() + "_consumed"); -// } -// else { -// placeSPAREChildConsumed.setName(dftSpare->name() + STR_FAILED); -// } -// placeSPAREChildConsumed.setNumberOfInitialTokens(0); -// mGspn.addPlace(placeSPAREChildConsumed); -// -// storm::gspn::ImmediateTransition immediateTransitionChildConsuming1; -// immediateTransitionChildConsuming1.setName(dftSpare->name() + "_" + children[i]->name() + "_consuming1"); -// immediateTransitionChildConsuming1.setPriority(priority); -// immediateTransitionChildConsuming1.setWeight(0.0); -// immediateTransitionChildConsuming1.setOutputArcMultiplicity(placeSPAREChildConsumed, 1); -// immediateTransitionChildConsuming1.setInhibitionArcMultiplicity(placeSPAREChildConsumed, 1); -// immediateTransitionChildConsuming1.setInhibitionArcMultiplicity(placeSPAREClaimedChild, 1); -// mGspn.addImmediateTransition(immediateTransitionChildConsuming1); -// -// storm::gspn::ImmediateTransition immediateTransitionChildConsuming2; -// immediateTransitionChildConsuming2.setName(dftSpare->name() + "_" + children[i]->name() + "_consuming2"); -// immediateTransitionChildConsuming2.setPriority(priority); -// immediateTransitionChildConsuming2.setWeight(0.0); -// immediateTransitionChildConsuming2.setOutputArcMultiplicity(placeSPAREChildConsumed, 1); -// immediateTransitionChildConsuming2.setInhibitionArcMultiplicity(placeSPAREChildConsumed, 1); -// immediateTransitionChildConsuming2.setOutputArcMultiplicity(placeSPAREClaimedChild, 1); -// immediateTransitionChildConsuming2.setInputArcMultiplicity(placeSPAREClaimedChild, 1); -// mGspn.addImmediateTransition(immediateTransitionChildConsuming2); -// } -// -// // Draw connections between all spare childs. -// for (std::size_t i = 1; i < children.size() - 1; i++) { -// auto placeSPAREChildConsumed = mGspn.getPlace(dftSpare->name() + "_" + children[i]->name() + "_consumed"); -// auto immediateTransitionChildClaiming = mGspn.getImmediateTransition(dftSpare->name() + "_claiming_" + children[i + 1]->name()); -// auto immediateTransitionChildConsuming1 = mGspn.getImmediateTransition(dftSpare->name() + "_" + children[i + 1]->name() + "_consuming1"); -// -// immediateTransitionChildClaiming.second->setOutputArcMultiplicity(placeSPAREChildConsumed.second, 1); -// immediateTransitionChildClaiming.second->setInputArcMultiplicity(placeSPAREChildConsumed.second, 1); -// -// immediateTransitionChildConsuming1.second->setOutputArcMultiplicity(placeSPAREChildConsumed.second, 1); -// immediateTransitionChildConsuming1.second->setInputArcMultiplicity(placeSPAREChildConsumed.second, 1); -// } ->>>>>>> updated dft->gspn translation to now have basis support for spares + } // template @@ -427,18 +310,12 @@ namespace storm { // template void DftToGspnTransformator::drawCONSTF(std::shared_ptr const> dftConstF, bool isRepresentative) { -<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 failedNodes.push_back(builder.addPlace(defaultCapacity, 1, dftConstF->name() + STR_FAILED)); uint64_t unavailableNode = 0; if (isRepresentative) { unavailableNode = addUnavailableNode(dftConstF, false); } -======= -// storm::gspn::Place placeCONSTFFailed; -// placeCONSTFFailed.setName(dftConstF->name() + STR_FAILED); -// placeCONSTFFailed.setNumberOfInitialTokens(1); -// mGspn.addPlace(placeCONSTFFailed); ->>>>>>> updated dft->gspn translation to now have basis support for spares + } // template @@ -472,237 +349,13 @@ namespace storm { } template -<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 uint64_t DftToGspnTransformator::addUnavailableNode(std::shared_ptr const> dftElement, bool initialAvailable) { uint64_t unavailableNode = builder.addPlace(defaultCapacity, initialAvailable ? 0 : 1, dftElement->name() + "_unavailable"); -======= - uint64_t DftToGspnTransformator::addUnavailableNode(std::shared_ptr const> dftElement) { - uint64_t unavailableNode = builder.addPlace(defaultCapacity, 1, dftElement->name() + "_unavailable"); ->>>>>>> updated dft->gspn translation to now have basis support for spares assert(unavailableNode != 0); unavailableNodes.emplace(dftElement->id(), unavailableNode); return unavailableNode; } // -<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 - -======= - template - void DftToGspnTransformator::drawGSPNConnections() { -// // Check for every element, if they have parents (all will have at least 1, except the top event). -// for (std::size_t i = 0; i < mDft.nrElements(); i++) { -// auto child = mDft.getElement(i); -// auto parents = child->parentIds(); -// -// // Draw a connection to every parent. -// for (std::size_t j = 0; j < parents.size(); j++) { -// // Check the type of the parent and act accordingly (every parent gate has different entry points...). -// switch (mDft.getElement(parents[j])->type()) { -// case storm::storage::DFTElementType::AND: -// { -// auto andEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILING); -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// if (andEntry.first && childExit.first) { // Only add arcs if the objects have been found. -// andEntry.second->setInputArcMultiplicity(childExit.second, 1); -// andEntry.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// break; -// } -// case storm::storage::DFTElementType::OR: -// { -// auto orEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + child->name() + STR_FAILING); -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// if (orEntry.first && childExit.first) { // Only add arcs if the objects have been found. -// orEntry.second->setInputArcMultiplicity(childExit.second, 1); -// orEntry.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// break; -// } -// case storm::storage::DFTElementType::VOT: -// { -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// auto parentEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + child->name() + "_collecting"); -// -// if (childExit.first && parentEntry.first) { // Only add arcs if the objects have been found. -// parentEntry.second->setInputArcMultiplicity(childExit.second, 1); -// parentEntry.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// -// break; -// } -// case storm::storage::DFTElementType::PAND: -// { -// auto children = std::static_pointer_cast const>(mDft.getElement(parents[j]))->children(); -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// auto pandEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILING); -// -// if (childExit.first && pandEntry.first) { // Only add arcs if the objects have been found. -// pandEntry.second->setInputArcMultiplicity(childExit.second, 1); -// pandEntry.second->setOutputArcMultiplicity(childExit.second, 1); -// -// if (children[0] == child) { // Current element is primary child. -// auto pandEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_0" + STR_FAILSAVING); -// -// if (pandEntry2.first) { -// pandEntry2.second->setInhibitionArcMultiplicity(childExit.second, 1); -// } -// } -// else { // Current element is not the primary child. -// for (std::size_t k = 1; k < children.size(); k++) { -// if (children[k] == child) { -// auto pandEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + std::to_string((k - 1)) + STR_FAILSAVING); -// auto pandEntry3 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + std::to_string((k)) + STR_FAILSAVING); -// -// if (pandEntry2.first) { -// pandEntry2.second->setInputArcMultiplicity(childExit.second, 1); -// pandEntry2.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// -// if (pandEntry3.first) { -// pandEntry3.second->setInhibitionArcMultiplicity(childExit.second, 1); -// } -// -// continue; -// } -// } -// } -// } -// -// break; -// } -// case storm::storage::DFTElementType::SPARE: -// { -// // Check if current child is a primary or spare child. -// auto children = std::static_pointer_cast const>(mDft.getElement(parents[j]))->children(); -// -// if (child == children[0]) { // Primary child. -// auto spareExit = mGspn.getImmediateTransition(child->name() + STR_ACTIVATING); -// -// std::vector ids = getAllBEIDsOfElement(child); -// for (std::size_t k = 0; k < ids.size(); k++) { -// auto childEntry = mGspn.getPlace(mDft.getElement(ids[k])->name() + STR_ACTIVATED); -// -// if (spareExit.first && childEntry.first) { // Only add arcs if the objects have been found. -// spareExit.second->setInhibitionArcMultiplicity(childEntry.second, 1); -// spareExit.second->setOutputArcMultiplicity(childEntry.second, 1); -// } -// } -// -// // Draw lines from "primary child_failed" to SPARE. -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// auto spareEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_claiming_" + children[1]->name()); -// auto spareEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + children[1]->name() + "_consuming1"); -// -// if (childExit.first && spareEntry.first && spareEntry2.first) { // Only add arcs if the objects have been found. -// spareEntry.second->setInputArcMultiplicity(childExit.second, 1); -// spareEntry.second->setOutputArcMultiplicity(childExit.second, 1); -// -// spareEntry2.second->setInputArcMultiplicity(childExit.second, 1); -// spareEntry2.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// } -// else { // A spare child. -// auto spareExit = mGspn.getImmediateTransition(child->name() + STR_ACTIVATING); -// auto spareExit2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_claiming_" + child->name()); -// -// std::vector ids = getAllBEIDsOfElement(child); -// for (std::size_t k = 0; k < ids.size(); k++) { -// auto childEntry = mGspn.getPlace(mDft.getElement(ids[k])->name() + STR_ACTIVATED); -// -// if (spareExit.first && spareExit2.first && childEntry.first) { // Only add arcs if the objects have been found. -// if (!spareExit.second->existsInhibitionArc(childEntry.second)) { -// spareExit.second->setInhibitionArcMultiplicity(childEntry.second, 1); -// } -// if (!spareExit.second->existsOutputArc(childEntry.second)) { -// spareExit.second->setOutputArcMultiplicity(childEntry.second, 1); -// } -// if (!spareExit2.second->existsInhibitionArc(childEntry.second)) { -// spareExit2.second->setInhibitionArcMultiplicity(childEntry.second, 1); -// } -// } -// } -// -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// auto spareEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_claiming_" + child->name()); -// auto spareEntry2 = mGspn.getImmediateTransition(child->name() + STR_ACTIVATING); -// auto spareEntry3 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + "_" + child->name() + "_consuming2"); -// -// if (childExit.first && spareEntry.first && spareEntry2.first && spareEntry3.first) { // Only add arcs if the objects have been found. -// spareEntry.second->setInhibitionArcMultiplicity(childExit.second, 1); -// -// if (!spareEntry2.second->existsInhibitionArc(childExit.second)) { -// spareEntry2.second->setInhibitionArcMultiplicity(childExit.second, 1); -// } -// -// spareEntry3.second->setInputArcMultiplicity(childExit.second, 1); -// spareEntry3.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// } -// -// break; -// } -// case storm::storage::DFTElementType::POR: -// { -// auto children = std::static_pointer_cast const>(mDft.getElement(parents[j]))->children(); -// auto porEntry = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILING); -// auto porEntry2 = mGspn.getImmediateTransition(mDft.getElement(parents[j])->name() + STR_FAILSAVING); -// auto childExit = mGspn.getPlace(child->name() + STR_FAILED); -// -// if (porEntry.first && porEntry2.first && childExit.first) { // Only add arcs if the objects have been found. -// if (children[0] == child) { // Current element is primary child. -// porEntry.second->setInputArcMultiplicity(childExit.second, 1); -// porEntry.second->setOutputArcMultiplicity(childExit.second, 1); -// porEntry2.second->setInhibitionArcMultiplicity(childExit.second, 1); -// -// } -// else { // Current element is not the primary child. -// porEntry2.second->setInputArcMultiplicity(childExit.second, 1); -// porEntry2.second->setOutputArcMultiplicity(childExit.second, 1); -// } -// } -// -// break; -// } -// case storm::storage::DFTElementType::SEQ: -// { -// // Sequences are realized with restrictions. Nothing to do here. -// break; -// } -// case storm::storage::DFTElementType::MUTEX: -// { -// // MUTEX are realized with restrictions. Nothing to do here. -// break; -// } -// case storm::storage::DFTElementType::BE: -// { -// // The parent is never a Basic Event. -// break; -// } -// case storm::storage::DFTElementType::CONSTF: -// { -// // The parent is never a Basic Event. -// break; -// } -// case storm::storage::DFTElementType::CONSTS: -// { -// // The parent is never a Basic Event. -// break; -// } -// case storm::storage::DFTElementType::PDEP: -// { -// // The parent is never a DEP. Hence the connections must be drawn somewhere else. -// break; -// } -// default: -// { -// STORM_LOG_ASSERT(false, "DFT type unknown."); -// break; -// } -// } -// } -// } - } ->>>>>>> updated dft->gspn translation to now have basis support for spares template bool DftToGspnTransformator::isBEActive(std::shared_ptr const> dftElement) @@ -744,38 +397,7 @@ namespace storm { { return mDft.maxRank() - dftElement->rank(); } -<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 -======= - - template - void DftToGspnTransformator::drawGSPNDependencies() { -// for (std::size_t i = 0; i < mDft.nrElements(); i++) { -// auto dftElement = mDft.getElement(i); -// -// if (dftElement->isDependency()) { -// std::string gateName = dftElement->name().substr(0, dftElement->name().find("_")); -// auto depEntry = mGspn.getTimedTransition(gateName + STR_FAILING); -// auto trigger = mGspn.getPlace(std::static_pointer_cast const>(dftElement)->nameTrigger() + STR_FAILED); -// -// if (depEntry.first && trigger.first) { // Only add arcs if the objects have been found. -// if (!depEntry.second->existsInputArc(trigger.second)) { -// depEntry.second->setInputArcMultiplicity(trigger.second, 1); -// } -// if (!depEntry.second->existsOutputArc(trigger.second)){ -// depEntry.second->setOutputArcMultiplicity(trigger.second, 1); -// } -// } -// -// auto dependent = mGspn.getPlace(std::static_pointer_cast const>(dftElement)->nameDependent() + STR_FAILED); -// -// if (dependent.first) { // Only add arcs if the objects have been found. -// depEntry.second->setOutputArcMultiplicity(dependent.second, 1); -// } -// } -// } - } ->>>>>>> updated dft->gspn translation to now have basis support for spares template void DftToGspnTransformator::drawGSPNRestrictions() { @@ -833,100 +455,7 @@ namespace storm { // } // } } -<<<<<<< fcc5d69a44cb202290c4db3c5b2062ff35da5791 -======= - - template - std::vector DftToGspnTransformator::getAllBEIDsOfElement(std::shared_ptr const> dftElement) { -// std::vector ids; -// -// switch (dftElement->type()) { -// case storm::storage::DFTElementType::AND: -// { -// auto children = std::static_pointer_cast const>(dftElement)->children(); -// -// for (std::size_t i = 0; i < children.size(); i++) { -// std::vector newIds = getAllBEIDsOfElement(children[i]); -// ids.insert(ids.end(), newIds.begin(), newIds.end()); -// } -// break; -// } -// case storm::storage::DFTElementType::OR: -// { -// auto children = std::static_pointer_cast const>(dftElement)->children(); -// -// for (std::size_t i = 0; i < children.size(); i++) { -// std::vector newIds = getAllBEIDsOfElement(children[i]); -// ids.insert(ids.end(), newIds.begin(), newIds.end()); -// } -// break; -// } -// case storm::storage::DFTElementType::VOT: -// { -// auto children = std::static_pointer_cast const>(dftElement)->children(); -// -// for (std::size_t i = 0; i < children.size(); i++) { -// std::vector newIds = getAllBEIDsOfElement(children[i]); -// ids.insert(ids.end(), newIds.begin(), newIds.end()); -// } -// break; -// } -// case storm::storage::DFTElementType::PAND: -// { -// auto children = std::static_pointer_cast const>(dftElement)->children(); -// -// for (std::size_t i = 0; i < children.size(); i++) { -// std::vector newIds = getAllBEIDsOfElement(children[i]); -// ids.insert(ids.end(), newIds.begin(), newIds.end()); -// } -// break; -// } -// case storm::storage::DFTElementType::SPARE: -// { -// auto children = std::static_pointer_cast const>(dftElement)->children(); -// -// // Only regard the primary child of a SPARE. The spare childs are not allowed to be listed here. -// for (std::size_t i = 0; i < 1; i++) { -// std::vector newIds = getAllBEIDsOfElement(children[i]); -// ids.insert(ids.end(), newIds.begin(), newIds.end()); -// } -// break; -// } -// case storm::storage::DFTElementType::POR: -// { -// auto children = std::static_pointer_cast const>(dftElement)->children(); -// -// for (std::size_t i = 0; i < children.size(); i++) { -// std::vector newIds = getAllBEIDsOfElement(children[i]); -// ids.insert(ids.end(), newIds.begin(), newIds.end()); -// } -// break; -// } -// case storm::storage::DFTElementType::BE: -// case storm::storage::DFTElementType::CONSTF: -// case storm::storage::DFTElementType::CONSTS: -// { -// ids.push_back(dftElement->id()); -// break; -// } -// case storm::storage::DFTElementType::SEQ: -// case storm::storage::DFTElementType::MUTEX: -// case storm::storage::DFTElementType::PDEP: -// { -// break; -// } -// default: -// { -// STORM_LOG_ASSERT(false, "DFT type unknown."); -// break; -// } -// } -// -// return ids; - } - ->>>>>>> updated dft->gspn translation to now have basis support for spares template void DftToGspnTransformator::writeGspn(bool toFile) { if (toFile) { From b9e46cf8c1cda810e488f2b1136d8ea7ef7024bb Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Mon, 12 Dec 2016 15:47:56 +0100 Subject: [PATCH 08/47] gspn transformation related changes --- src/storm-dft-cli/storm-dyftee.cpp | 7 ++++--- .../DftToGspnTransformator.cpp | 20 ++----------------- .../transformations/DftToGspnTransformator.h | 12 +++++------ src/storm-gspn/storage/gspn/GspnBuilder.cpp | 2 +- 4 files changed, 12 insertions(+), 29 deletions(-) diff --git a/src/storm-dft-cli/storm-dyftee.cpp b/src/storm-dft-cli/storm-dyftee.cpp index 3056cbdf1..b785be6c3 100644 --- a/src/storm-dft-cli/storm-dyftee.cpp +++ b/src/storm-dft-cli/storm-dyftee.cpp @@ -77,11 +77,12 @@ void analyzeWithSMT(std::string filename) { * */ template -storm::gspn::GSPN transformDFT(std::string filename) { +storm::gspn::GSPN* transformDFT(std::string filename) { storm::parser::DFTGalileoParser parser; storm::storage::DFT dft = parser.parseDFT(filename); storm::transformations::dft::DftToGspnTransformator gspnTransformator(dft); gspnTransformator.transform(); + return gspnTransformator.obtainGSPN(); } /*! @@ -138,9 +139,9 @@ int main(const int argc, const char** argv) { } if (dftSettings.isTransformToGspn()) { - // For now we only transform the DFT to a GSPN and then exit - transformDFT(dftSettings.getDftFilename()); + storm::gspn::GSPN* gspn = transformDFT(dftSettings.getDftFilename()); + delete gspn; storm::utility::cleanUp(); return 0; } diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index 49f58707f..5649754cd 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -25,9 +25,6 @@ namespace storm { // Draw restrictions into the GSPN (i.e. SEQ or MUTEX). //drawGSPNRestrictions(); - - // Write GSPN to file. - writeGspn(true); } template @@ -457,21 +454,8 @@ namespace storm { } template - void DftToGspnTransformator::writeGspn(bool toFile) { - if (toFile) { - // Writing to file - std::ofstream file; - file.open("gspn.dot"); - storm::gspn::GSPN* gspn = builder.buildGspn(); - gspn->writeDotToStream(file); - delete gspn; - file.close(); - } else { - // Writing to console - storm::gspn::GSPN* gspn = builder.buildGspn(); - gspn->writeDotToStream(std::cout); - delete gspn; - } + gspn::GSPN* DftToGspnTransformator::obtainGSPN() { + return builder.buildGspn(); } // Explicitly instantiate the class. diff --git a/src/storm-dft/transformations/DftToGspnTransformator.h b/src/storm-dft/transformations/DftToGspnTransformator.h index 4d827e44b..e2812f738 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.h +++ b/src/storm-dft/transformations/DftToGspnTransformator.h @@ -27,16 +27,14 @@ namespace storm { */ void transform(); - private: /*! - * Write Gspn to file or console. + * Extract Gspn by building * - * @param toFile If true, the GSPN will be written to a file, otherwise it will - be written to the console. */ - void writeGspn(bool toFile); - - /* + gspn::GSPN* obtainGSPN(); + + private: + /* * Draw all elements of the GSPN. */ void drawGSPNElements(); diff --git a/src/storm-gspn/storage/gspn/GspnBuilder.cpp b/src/storm-gspn/storage/gspn/GspnBuilder.cpp index 9cb662eb7..fa81444c3 100644 --- a/src/storm-gspn/storage/gspn/GspnBuilder.cpp +++ b/src/storm-gspn/storage/gspn/GspnBuilder.cpp @@ -35,7 +35,7 @@ namespace storm { if(partitions.count(priority) == 0) { TransitionPartition newPart; newPart.priority = priority; - partitions.at(priority).push_back(newPart); + partitions[priority].push_back(newPart); } if(storm::utility::isZero(weight)) { From 88e17d423a8cf8073357d817b7a0d0cd62a4a6ae Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 01:03:42 +0100 Subject: [PATCH 09/47] updated dft->gspn->jani workflow --- src/storm-dft-cli/storm-dyftee.cpp | 11 ++ src/storm-gspn/builder/JaniGSPNBuilder.h | 163 ++++++++---------- src/storm-gspn/storm-gspn.h | 32 ++++ src/storm/cli/cli.cpp | 11 +- .../settings/modules/GSPNExportSettings.h | 2 +- src/storm/storage/jani/OrderedAssignments.cpp | 9 + src/storm/storage/jani/OrderedAssignments.h | 2 + src/storm/utility/storm.cpp | 11 ++ src/storm/utility/storm.h | 10 +- 9 files changed, 151 insertions(+), 100 deletions(-) create mode 100644 src/storm-gspn/storm-gspn.h diff --git a/src/storm-dft-cli/storm-dyftee.cpp b/src/storm-dft-cli/storm-dyftee.cpp index b785be6c3..8ccdc12be 100644 --- a/src/storm-dft-cli/storm-dyftee.cpp +++ b/src/storm-dft-cli/storm-dyftee.cpp @@ -22,6 +22,7 @@ #include "storm-dft/settings/modules/DFTSettings.h" #include "storm-gspn/storage/gspn/GSPN.h" +#include "storm-gspn/storm-gspn.h" #include "storm/settings/modules/GSPNSettings.h" #include "storm/settings/modules/GSPNExportSettings.h" @@ -112,6 +113,7 @@ void initializeSettings() { // For translation into JANI via GSPN. storm::settings::addModule(); storm::settings::addModule(); + storm::settings::addModule(); } /*! @@ -140,7 +142,16 @@ int main(const int argc, const char** argv) { if (dftSettings.isTransformToGspn()) { storm::gspn::GSPN* gspn = transformDFT(dftSettings.getDftFilename()); + storm::handleGSPNExportSettings(*gspn); + storm::jani::Model* model = storm::buildJani(*gspn); + + storm::settings::modules::JaniExportSettings const& janiSettings = storm::settings::getModule(); + if (janiSettings.isJaniFileSet()) { + storm::exportJaniModel(*model, {}, janiSettings.getJaniFilename()); + } + + delete model; delete gspn; storm::utility::cleanUp(); return 0; diff --git a/src/storm-gspn/builder/JaniGSPNBuilder.h b/src/storm-gspn/builder/JaniGSPNBuilder.h index 76517a3a1..305fa0129 100644 --- a/src/storm-gspn/builder/JaniGSPNBuilder.h +++ b/src/storm-gspn/builder/JaniGSPNBuilder.h @@ -9,17 +9,15 @@ namespace storm { class JaniGSPNBuilder { public: JaniGSPNBuilder(storm::gspn::GSPN const& gspn, std::shared_ptr const& expManager) : gspn(gspn), expressionManager(expManager) { - gspn.writeDotToStream(std::cout); + } virtual ~JaniGSPNBuilder() { - for (auto const& varEntry : vars) { - delete varEntry.second; - } + } void setIgnoreWeights(bool ignore = true) { - ignoreWeights = ignore; + //ignoreWeights = ignore; } @@ -46,8 +44,8 @@ namespace storm { } assert(janiVar != nullptr); assert(vars.count(place.getID()) == 0); - vars[place.getID()] = janiVar; - model->addVariable(*janiVar); + vars[place.getID()] = &model->addVariable(*janiVar); + delete janiVar; } } @@ -59,95 +57,76 @@ namespace storm { void addEdges(storm::jani::Automaton& automaton, uint64_t locId) { - storm::expressions::Expression guard = expressionManager->boolean(true); - for (auto const& trans : gspn.getImmediateTransitions()) { - if (ignoreWeights || trans.noWeightAttached()) { - std::vector assignments; + uint64_t lastPriority = -1; + storm::expressions::Expression lastPriorityGuard = expressionManager->boolean(false); + storm::expressions::Expression priorityGuard = expressionManager->boolean(true); + // TODO here there is something to fix if we add transition partitions. + + for (auto const& partition : gspn.getPartitions()) { + storm::expressions::Expression guard = expressionManager->boolean(false); + std::vector weightedDestinations; + + assert(lastPriority >= partition.priority); + if (lastPriority > partition.priority) { + priorityGuard = priorityGuard && !lastPriorityGuard; + lastPriority = partition.priority; + } else { + assert(lastPriority == partition.priority); + } + + // Compute enabled weight expression. + storm::expressions::Expression totalWeight = expressionManager->rational(0.0); + for (auto const& transId : partition.transitions) { + auto const& trans = gspn.getImmediateTransitions()[transId]; + if (trans.noWeightAttached()) { + continue; + } + storm::expressions::Expression destguard = expressionManager->boolean(true); for (auto const& inPlaceEntry : trans.getInputPlaces()) { - guard = guard && (vars[inPlaceEntry.first]->getExpressionVariable() > inPlaceEntry.second); - assignments.emplace_back( *vars[inPlaceEntry.first], (vars[inPlaceEntry.first])->getExpressionVariable() - inPlaceEntry.second); + destguard = destguard && (vars[inPlaceEntry.first]->getExpressionVariable() >= inPlaceEntry.second); } for (auto const& inhibPlaceEntry : trans.getInhibitionPlaces()) { - guard = guard && (vars[inhibPlaceEntry.first]->getExpressionVariable() > inhibPlaceEntry.second); + destguard = destguard && (vars[inhibPlaceEntry.first]->getExpressionVariable() >= inhibPlaceEntry.second); } - for (auto const& outputPlaceEntry : trans.getOutputPlaces()) { - assignments.emplace_back( *vars[outputPlaceEntry.first], (vars[outputPlaceEntry.first])->getExpressionVariable() + outputPlaceEntry.second ); - } - storm::jani::OrderedAssignments oa(assignments); - storm::jani::EdgeDestination dest(locId, expressionManager->integer(1), oa); - storm::jani::Edge e(locId, storm::jani::Model::SILENT_ACTION_INDEX, boost::none, guard, {dest}); - automaton.addEdge(e); + totalWeight = totalWeight + storm::expressions::ite(destguard, expressionManager->rational(trans.getWeight()), expressionManager->rational(0.0)); + } + totalWeight = totalWeight.simplify(); - } - if(!ignoreWeights) { - uint64_t lastPriority; - storm::expressions::Expression lastPriorityGuard = expressionManager->boolean(false); - storm::expressions::Expression priorityGuard = expressionManager->boolean(true); - // TODO here there is something to fix if we add transition partitions. - for (auto const& partition : gspn.getPartitions()) { - storm::expressions::Expression guard = expressionManager->boolean(false); - std::vector weightedDestinations; - - - assert(lastPriority <= partition.priority); - if (lastPriority < partition.priority) { - priorityGuard = priorityGuard && !lastPriorityGuard; - lastPriority = partition.priority; - } else { - assert(lastPriority == partition.priority); + for (auto const& transId : partition.transitions) { + auto const& trans = gspn.getImmediateTransitions()[transId]; + if (trans.noWeightAttached()) { + std::cout << "ERROR -- no weights attached at transition" << std::endl; + continue; } - - // Compute enabled weight expression. - storm::expressions::Expression totalWeight = expressionManager->rational(0.0); - for (auto const& transId : partition.transitions) { - auto const& trans = gspn.getImmediateTransitions()[transId]; - if (trans.noWeightAttached()) { - continue; - } - storm::expressions::Expression destguard = expressionManager->boolean(true); - for (auto const& inPlaceEntry : trans.getInputPlaces()) { - destguard = destguard && (vars[inPlaceEntry.first]->getExpressionVariable() > inPlaceEntry.second); - } - for (auto const& inhibPlaceEntry : trans.getInhibitionPlaces()) { - destguard = destguard && (vars[inhibPlaceEntry.first]->getExpressionVariable() > inhibPlaceEntry.second); + storm::expressions::Expression destguard = expressionManager->boolean(true); + std::vector assignments; + for (auto const& inPlaceEntry : trans.getInputPlaces()) { + destguard = destguard && (vars[inPlaceEntry.first]->getExpressionVariable() > inPlaceEntry.second); + if (trans.getOutputPlaces().count(inPlaceEntry.first) == 0) { + assignments.emplace_back( *vars[inPlaceEntry.first], (vars[inPlaceEntry.first])->getExpressionVariable() - inPlaceEntry.second); } - totalWeight = totalWeight + storm::expressions::ite(destguard, expressionManager->rational(trans.getWeight()), expressionManager->rational(0.0)); - } - totalWeight = totalWeight.simplify(); - - - for (auto const& transId : partition.transitions) { - auto const& trans = gspn.getImmediateTransitions()[transId]; - if (trans.noWeightAttached()) { - continue; - } - storm::expressions::Expression destguard = expressionManager->boolean(true); - std::vector assignments; - for (auto const& inPlaceEntry : trans.getInputPlaces()) { - destguard = destguard && (vars[inPlaceEntry.first]->getExpressionVariable() > inPlaceEntry.second); - assignments.emplace_back( *vars[inPlaceEntry.first], (vars[inPlaceEntry.first]->getExpressionVariable() - inPlaceEntry.second) ); - } - for (auto const& inhibPlaceEntry : trans.getInhibitionPlaces()) { - destguard = destguard && (vars[inhibPlaceEntry.first]->getExpressionVariable() > inhibPlaceEntry.second); - } - for (auto const& outputPlaceEntry : trans.getOutputPlaces()) { - assignments.emplace_back( *vars[outputPlaceEntry.first], (vars[outputPlaceEntry.first]->getExpressionVariable() + outputPlaceEntry.second) ); + for (auto const& inhibPlaceEntry : trans.getInhibitionPlaces()) { + destguard = destguard && (vars[inhibPlaceEntry.first]->getExpressionVariable() > inhibPlaceEntry.second); + } + for (auto const& outputPlaceEntry : trans.getOutputPlaces()) { + if (trans.getInputPlaces().count(outputPlaceEntry.first) == 0) { + assignments.emplace_back( *vars[outputPlaceEntry.first], (vars[outputPlaceEntry.first])->getExpressionVariable() + outputPlaceEntry.second ); + } else { + assignments.emplace_back( *vars[outputPlaceEntry.first], (vars[outputPlaceEntry.first])->getExpressionVariable() + outputPlaceEntry.second - trans.getInputPlaces().at(outputPlaceEntry.first)); } - destguard = destguard.simplify(); - guard = guard || destguard; - storm::jani::OrderedAssignments oa(assignments); - storm::jani::EdgeDestination dest(locId, storm::expressions::ite(destguard, (expressionManager->rational(trans.getWeight()) / totalWeight), expressionManager->rational(0.0)), oa); - weightedDestinations.push_back(dest); } - storm::jani::Edge e(locId, storm::jani::Model::SILENT_ACTION_INDEX, boost::none, (priorityGuard && guard).simplify(), weightedDestinations); - automaton.addEdge(e); - lastPriorityGuard = lastPriorityGuard || guard; + destguard = destguard.simplify(); + guard = guard || destguard; + storm::jani::OrderedAssignments oa(assignments); + storm::jani::EdgeDestination dest(locId, storm::expressions::ite(destguard, (expressionManager->rational(trans.getWeight()) / totalWeight), expressionManager->rational(0.0)), oa); + weightedDestinations.push_back(dest); } - - + storm::jani::Edge e(locId, storm::jani::Model::SILENT_ACTION_INDEX, boost::none, (priorityGuard && guard).simplify(), weightedDestinations); + automaton.addEdge(e); + lastPriorityGuard = lastPriorityGuard || guard; } for (auto const& trans : gspn.getTimedTransitions()) { @@ -155,27 +134,33 @@ namespace storm { std::vector assignments; for (auto const& inPlaceEntry : trans.getInputPlaces()) { - guard = guard && (vars[inPlaceEntry.first]->getExpressionVariable() > inPlaceEntry.second); - assignments.emplace_back( *vars[inPlaceEntry.first], (vars[inPlaceEntry.first]->getExpressionVariable() - inPlaceEntry.second) ); + guard = guard && (vars[inPlaceEntry.first]->getExpressionVariable() >= inPlaceEntry.second); + if (trans.getOutputPlaces().count(inPlaceEntry.first) == 0) { + assignments.emplace_back( *vars[inPlaceEntry.first], (vars[inPlaceEntry.first])->getExpressionVariable() - inPlaceEntry.second); + } } for (auto const& inhibPlaceEntry : trans.getInhibitionPlaces()) { - guard = guard && (vars[inhibPlaceEntry.first]->getExpressionVariable() > inhibPlaceEntry.second); + guard = guard && (vars[inhibPlaceEntry.first]->getExpressionVariable() >= inhibPlaceEntry.second); } for (auto const& outputPlaceEntry : trans.getOutputPlaces()) { - assignments.emplace_back( *vars[outputPlaceEntry.first], (vars[outputPlaceEntry.first]->getExpressionVariable() + outputPlaceEntry.second) ); + if (trans.getInputPlaces().count(outputPlaceEntry.first) == 0) { + assignments.emplace_back( *vars[outputPlaceEntry.first], (vars[outputPlaceEntry.first])->getExpressionVariable() + outputPlaceEntry.second ); + } else { + assignments.emplace_back( *vars[outputPlaceEntry.first], (vars[outputPlaceEntry.first])->getExpressionVariable() + outputPlaceEntry.second - trans.getInputPlaces().at(outputPlaceEntry.first)); + } } storm::jani::OrderedAssignments oa(assignments); storm::jani::EdgeDestination dest(locId, expressionManager->integer(1), oa); storm::jani::Edge e(locId, storm::jani::Model::SILENT_ACTION_INDEX, expressionManager->rational(trans.getRate()), guard, {dest}); automaton.addEdge(e); + } } private: - bool ignoreWeights; const uint64_t janiVersion = 1; storm::gspn::GSPN const& gspn; - std::map vars; + std::map vars; std::shared_ptr expressionManager; }; diff --git a/src/storm-gspn/storm-gspn.h b/src/storm-gspn/storm-gspn.h new file mode 100644 index 000000000..3af59a9c1 --- /dev/null +++ b/src/storm-gspn/storm-gspn.h @@ -0,0 +1,32 @@ +#pragma once + +#include "storm/storage/jani/Model.h" + +#include "storm-gspn/builder/JaniGSPNBuilder.h" +#include "storm-gspn/storage/gspn/Gspn.h" + +#include "storm/settings/modules/GSPNExportSettings.h" + +namespace storm { + /** + * Builds JANI model from GSPN. + */ + storm::jani::Model* buildJani(storm::gspn::GSPN const& gspn) { + std::shared_ptr exprManager(new storm::expressions::ExpressionManager()); + storm::builder::JaniGSPNBuilder builder(gspn, exprManager); + return builder.build(); + } + + void handleGSPNExportSettings(storm::gspn::GSPN const& gspn) { + storm::settings::modules::GSPNExportSettings const& exportSettings = storm::settings::getModule(); + if (exportSettings.isWriteToDotSet()) { + std::ofstream fs; + fs.open(exportSettings.getWriteToDotFilename()); + gspn.writeDotToStream(std::cout); + gspn.writeDotToStream(fs); + fs.close(); + } + + } + +} \ No newline at end of file diff --git a/src/storm/cli/cli.cpp b/src/storm/cli/cli.cpp index 7ba6cc09e..cfa8c66d1 100644 --- a/src/storm/cli/cli.cpp +++ b/src/storm/cli/cli.cpp @@ -12,7 +12,7 @@ #include "storm/settings/modules/JaniExportSettings.h" #include "storm/utility/storm-version.h" -#include "storm/storage/jani/JSONExporter.h" + // Includes for the linked libraries and versions header. @@ -253,14 +253,7 @@ namespace storm { } if (model.isJaniModel() && storm::settings::getModule().isJaniFileSet()) { - STORM_LOG_TRACE("Exporting JANI model."); - if (storm::settings::getModule().isExportAsStandardJaniSet()) { - storm::jani::Model normalisedModel = storm::jani::Model(model.asJaniModel()); - normalisedModel.makeStandardJaniCompliant(); - storm::jani::JsonExporter::toFile(normalisedModel, formulasInProperties(properties), storm::settings::getModule().getJaniFilename()); - } else { - storm::jani::JsonExporter::toFile(model.asJaniModel(), formulasInProperties(properties), storm::settings::getModule().getJaniFilename()); - } + exportJaniModel(model.asJaniModel(), properties, storm::settings::getModule().getJaniFilename()); } if (ioSettings.isNoBuildModelSet()) { diff --git a/src/storm/settings/modules/GSPNExportSettings.h b/src/storm/settings/modules/GSPNExportSettings.h index 3db836cf7..32ae422ba 100644 --- a/src/storm/settings/modules/GSPNExportSettings.h +++ b/src/storm/settings/modules/GSPNExportSettings.h @@ -15,7 +15,7 @@ namespace storm { GSPNExportSettings(); /** - * Retrievew whether the pgcl file option was set + * Retrieve whether the pgcl file option was set */ bool isWriteToDotSet() const; diff --git a/src/storm/storage/jani/OrderedAssignments.cpp b/src/storm/storage/jani/OrderedAssignments.cpp index 667952719..18f0aebae 100644 --- a/src/storm/storage/jani/OrderedAssignments.cpp +++ b/src/storm/storage/jani/OrderedAssignments.cpp @@ -141,5 +141,14 @@ namespace storm { return std::lower_bound(assignments.begin(), assignments.end(), assignment, storm::jani::AssignmentPartialOrderByLevelAndVariable()); } + std::ostream& operator<<(std::ostream& stream, OrderedAssignments const& assignments) { + stream << "["; + for(auto const& e : assignments.allAssignments) { + stream << *e << std::endl; + } + stream << "]"; + return stream; + } + } } diff --git a/src/storm/storage/jani/OrderedAssignments.h b/src/storm/storage/jani/OrderedAssignments.h index 789b1014a..999b9d95f 100644 --- a/src/storm/storage/jani/OrderedAssignments.h +++ b/src/storm/storage/jani/OrderedAssignments.h @@ -109,6 +109,8 @@ namespace storm { */ void substitute(std::map const& substitution); + friend std::ostream& operator<<(std::ostream& stream, OrderedAssignments const& assignments); + private: static std::vector>::const_iterator lowerBound(Assignment const& assignment, std::vector> const& assignments); diff --git a/src/storm/utility/storm.cpp b/src/storm/utility/storm.cpp index 40ab41b91..62c499fbd 100644 --- a/src/storm/utility/storm.cpp +++ b/src/storm/utility/storm.cpp @@ -30,6 +30,17 @@ namespace storm{ modelAndFormulae.first.checkValid(); return modelAndFormulae; } + + void exportJaniModel(storm::jani::Model const& model, std::vector const& properties, std::string const& filepath) { + STORM_LOG_TRACE("Exporting JANI model."); + if (storm::settings::getModule().isExportAsStandardJaniSet()) { + storm::jani::Model normalisedModel = model; + normalisedModel.makeStandardJaniCompliant(); + storm::jani::JsonExporter::toFile(normalisedModel, formulasInProperties(properties), filepath); + } else { + storm::jani::JsonExporter::toFile(model, formulasInProperties(properties), filepath); + } + } /** * Helper diff --git a/src/storm/utility/storm.h b/src/storm/utility/storm.h index cee49998b..6657a7d6d 100644 --- a/src/storm/utility/storm.h +++ b/src/storm/utility/storm.h @@ -23,6 +23,7 @@ #include "storm/settings/modules/RegionSettings.h" #include "storm/settings/modules/EliminationSettings.h" #include "storm/settings/modules/JitBuilderSettings.h" +#include "storm/settings/modules/JaniExportSettings.h" // Formula headers. #include "storm/logic/Formulas.h" @@ -55,6 +56,7 @@ #include "storm/storage/bisimulation/NondeterministicModelBisimulationDecomposition.h" #include "storm/storage/ModelFormulasPair.h" #include "storm/storage/SymbolicModelDescription.h" +#include "storm/storage/jani/JSONExporter.h" // Headers for model checking. #include "storm/modelchecker/prctl/SparseDtmcPrctlModelChecker.h" @@ -575,7 +577,13 @@ namespace storm { } return result; } - + + + /** + * + */ + void exportJaniModel(storm::jani::Model const& model, std::vector const& properties, std::string const& filepath); + template void exportMatrixToFile(std::shared_ptr> model, std::string const& filepath) { STORM_LOG_THROW(model->getType() != storm::models::ModelType::Ctmc, storm::exceptions::NotImplementedException, "This functionality is not yet implemented." ); From 18383f5220dfb77bd615fd0cd6b3d2133ab9c1bc Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 15:46:13 +0100 Subject: [PATCH 10/47] several fixes in dft->gspn->jani code path: Most notably, mas are closed, successor nodes failed places keep intact and tb property is added --- src/storm-dft-cli/storm-dyftee.cpp | 36 ++++++++++--------- .../DftToGspnTransformator.cpp | 14 +++++++- .../transformations/DftToGspnTransformator.h | 3 ++ src/storm-gspn-cli/storm-gspn.cpp | 4 +-- src/storm-gspn/builder/JaniGSPNBuilder.h | 16 ++++----- src/storm/utility/storm.h | 1 + 6 files changed, 45 insertions(+), 29 deletions(-) diff --git a/src/storm-dft-cli/storm-dyftee.cpp b/src/storm-dft-cli/storm-dyftee.cpp index 8ccdc12be..6c54dc226 100644 --- a/src/storm-dft-cli/storm-dyftee.cpp +++ b/src/storm-dft-cli/storm-dyftee.cpp @@ -4,6 +4,7 @@ #include "storm/cli/cli.h" #include "storm/exceptions/BaseException.h" +#include "storm/logic/Formula.h" #include "storm/settings/modules/GeneralSettings.h" #include "storm/settings/modules/CoreSettings.h" @@ -71,20 +72,6 @@ void analyzeWithSMT(std::string filename) { //std::cout << "SMT result: " << sat << std::endl; } -/*! - * Load DFT from filename and transform into a GSPN. - * - * @param filename Path to DFT file in Galileo format. - * - */ -template -storm::gspn::GSPN* transformDFT(std::string filename) { - storm::parser::DFTGalileoParser parser; - storm::storage::DFT dft = parser.parseDFT(filename); - storm::transformations::dft::DftToGspnTransformator gspnTransformator(dft); - gspnTransformator.transform(); - return gspnTransformator.obtainGSPN(); -} /*! * Initialize the settings manager. @@ -140,15 +127,30 @@ int main(const int argc, const char** argv) { STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "No input model."); } + if (dftSettings.isTransformToGspn()) { - storm::gspn::GSPN* gspn = transformDFT(dftSettings.getDftFilename()); + + storm::parser::DFTGalileoParser parser; + storm::storage::DFT dft = parser.parseDFT(dftSettings.getDftFilename()); + storm::transformations::dft::DftToGspnTransformator gspnTransformator(dft); + gspnTransformator.transform(); + storm::gspn::GSPN* gspn = gspnTransformator.obtainGSPN(); + uint64_t toplevelFailedPlace = gspnTransformator.toplevelFailedPlaceId(); storm::handleGSPNExportSettings(*gspn); - storm::jani::Model* model = storm::buildJani(*gspn); + std::shared_ptr exprManager(new storm::expressions::ExpressionManager()); + storm::builder::JaniGSPNBuilder builder(*gspn, exprManager); + storm::jani::Model* model = builder.build(); + storm::jani::Variable const& topfailedVar = builder.getPlaceVariable(toplevelFailedPlace); + + + auto evtlFormula = std::make_shared(exprManager->integer(1) == topfailedVar.getExpressionVariable().getExpression()); + auto tbFormula = std::make_shared(std::make_shared(true), evtlFormula, 0.0, 10.0); + auto tbUntil = std::make_shared(tbFormula); storm::settings::modules::JaniExportSettings const& janiSettings = storm::settings::getModule(); if (janiSettings.isJaniFileSet()) { - storm::exportJaniModel(*model, {}, janiSettings.getJaniFilename()); + storm::exportJaniModel(*model, {storm::jani::Property("time-bounded", tbUntil)}, janiSettings.getJaniFilename()); } delete model; diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index 5649754cd..355c6f440 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -8,7 +8,7 @@ namespace storm { // Prevent some magic constants static constexpr const uint64_t defaultPriority = 0; - static constexpr const uint64_t defaultCapacity = 0; + static constexpr const uint64_t defaultCapacity = 1; template DftToGspnTransformator::DftToGspnTransformator(storm::storage::DFT const& dft) : mDft(dft) { @@ -27,6 +27,12 @@ namespace storm { //drawGSPNRestrictions(); } + template + uint64_t DftToGspnTransformator::toplevelFailedPlaceId() { + assert(failedNodes.size() > mDft.getTopLevelIndex()); + return failedNodes[mDft.getTopLevelIndex()]; + } + template void DftToGspnTransformator::drawGSPNElements() { @@ -133,6 +139,7 @@ namespace storm { for(auto const& child : dftAnd->children()) { assert(failedNodes.size() > child->id()); builder.addInputArc(failedNodes[child->id()], tAndFailed); + builder.addOutputArc(tAndFailed, failedNodes[child->id()]); } } @@ -157,6 +164,7 @@ namespace storm { } assert(failedNodes.size() > child->id()); builder.addInputArc(failedNodes[child->id()], tNodeFailed); + builder.addOutputArc(tNodeFailed, failedNodes[child->id()]); ++i; } } @@ -188,6 +196,7 @@ namespace storm { builder.addOutputArc(tCollect, childInhibPlace); builder.addInhibitionArc(childInhibPlace, tCollect); builder.addInputArc(failedNodes[child->id()], tCollect); + builder.addOutputArc(tCollect, failedNodes[child->id()]); ++i; } } @@ -212,12 +221,15 @@ namespace storm { } for(auto const& child : dftPand->children()) { builder.addInputArc(failedNodes[child->id()], tNodeFailed); + builder.addOutputArc(tNodeFailed, failedNodes[child->id()]); } for (uint64_t j = 1; j < dftPand->nrChildren(); ++j) { uint64_t tfs = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILSAVING + std::to_string(j)); builder.addInputArc(failedNodes[dftPand->children().at(j)->id()], tfs); + builder.addOutputArc(tfs, failedNodes[dftPand->children().at(j)->id()]); builder.addInhibitionArc(failedNodes[dftPand->children().at(j-1)->id()], tfs); builder.addOutputArc(tfs, nodeFS); + builder.addInhibitionArc(nodeFS, tfs); } } diff --git a/src/storm-dft/transformations/DftToGspnTransformator.h b/src/storm-dft/transformations/DftToGspnTransformator.h index e2812f738..2d763452d 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.h +++ b/src/storm-dft/transformations/DftToGspnTransformator.h @@ -33,6 +33,9 @@ namespace storm { */ gspn::GSPN* obtainGSPN(); + + uint64_t toplevelFailedPlaceId(); + private: /* * Draw all elements of the GSPN. diff --git a/src/storm-gspn-cli/storm-gspn.cpp b/src/storm-gspn-cli/storm-gspn.cpp index b973d046d..17b45222d 100644 --- a/src/storm-gspn-cli/storm-gspn.cpp +++ b/src/storm-gspn-cli/storm-gspn.cpp @@ -66,9 +66,7 @@ std::unordered_map parseCapacitiesList(std::string const& } void handleJani(storm::gspn::GSPN const& gspn) { - std::shared_ptr exprManager(new storm::expressions::ExpressionManager()); - storm::builder::JaniGSPNBuilder builder(gspn, exprManager); - storm::jani::Model* model = builder.build(); + storm::jani::JsonExporter::toFile(*model, {}, storm::settings::getModule().getJaniFilename()); delete model; } diff --git a/src/storm-gspn/builder/JaniGSPNBuilder.h b/src/storm-gspn/builder/JaniGSPNBuilder.h index 305fa0129..196d29562 100644 --- a/src/storm-gspn/builder/JaniGSPNBuilder.h +++ b/src/storm-gspn/builder/JaniGSPNBuilder.h @@ -16,10 +16,6 @@ namespace storm { } - void setIgnoreWeights(bool ignore = true) { - //ignoreWeights = ignore; - } - storm::jani::Model* build() { storm::jani::Model* model = new storm::jani::Model(gspn.getName(), storm::jani::ModelType::MA, janiVersion, expressionManager); @@ -32,6 +28,10 @@ namespace storm { return model; } + storm::jani::Variable const& getPlaceVariable(uint64_t placeId) { + return *vars.at(placeId); + } + void addVariables(storm::jani::Model* model) { for (auto const& place : gspn.getPlaces()) { storm::jani::Variable* janiVar = nullptr; @@ -86,7 +86,7 @@ namespace storm { destguard = destguard && (vars[inPlaceEntry.first]->getExpressionVariable() >= inPlaceEntry.second); } for (auto const& inhibPlaceEntry : trans.getInhibitionPlaces()) { - destguard = destguard && (vars[inhibPlaceEntry.first]->getExpressionVariable() >= inhibPlaceEntry.second); + destguard = destguard && (vars[inhibPlaceEntry.first]->getExpressionVariable() < inhibPlaceEntry.second); } totalWeight = totalWeight + storm::expressions::ite(destguard, expressionManager->rational(trans.getWeight()), expressionManager->rational(0.0)); @@ -103,13 +103,13 @@ namespace storm { storm::expressions::Expression destguard = expressionManager->boolean(true); std::vector assignments; for (auto const& inPlaceEntry : trans.getInputPlaces()) { - destguard = destguard && (vars[inPlaceEntry.first]->getExpressionVariable() > inPlaceEntry.second); + destguard = destguard && (vars[inPlaceEntry.first]->getExpressionVariable() >= inPlaceEntry.second); if (trans.getOutputPlaces().count(inPlaceEntry.first) == 0) { assignments.emplace_back( *vars[inPlaceEntry.first], (vars[inPlaceEntry.first])->getExpressionVariable() - inPlaceEntry.second); } } for (auto const& inhibPlaceEntry : trans.getInhibitionPlaces()) { - destguard = destguard && (vars[inhibPlaceEntry.first]->getExpressionVariable() > inhibPlaceEntry.second); + destguard = destguard && (vars[inhibPlaceEntry.first]->getExpressionVariable() < inhibPlaceEntry.second); } for (auto const& outputPlaceEntry : trans.getOutputPlaces()) { if (trans.getInputPlaces().count(outputPlaceEntry.first) == 0) { @@ -140,7 +140,7 @@ namespace storm { } } for (auto const& inhibPlaceEntry : trans.getInhibitionPlaces()) { - guard = guard && (vars[inhibPlaceEntry.first]->getExpressionVariable() >= inhibPlaceEntry.second); + guard = guard && (vars[inhibPlaceEntry.first]->getExpressionVariable() < inhibPlaceEntry.second); } for (auto const& outputPlaceEntry : trans.getOutputPlaces()) { if (trans.getInputPlaces().count(outputPlaceEntry.first) == 0) { diff --git a/src/storm/utility/storm.h b/src/storm/utility/storm.h index 6657a7d6d..343832e00 100644 --- a/src/storm/utility/storm.h +++ b/src/storm/utility/storm.h @@ -227,6 +227,7 @@ namespace storm { std::shared_ptr preprocessModel(std::shared_ptr model, std::vector> const& formulas) { if (model->getType() == storm::models::ModelType::MarkovAutomaton && model->isSparseModel()) { std::shared_ptr> ma = model->template as>(); + ma->close(); if (ma->hasOnlyTrivialNondeterminism()) { // Markov automaton can be converted into CTMC. model = ma->convertToCTMC(); From 276261ae55041ab7f941684907dc18b262f0b5b3 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 15:47:14 +0100 Subject: [PATCH 11/47] slightly more informative error message in out-of-bounds in bitvector --- src/storm/storage/BitVector.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/storm/storage/BitVector.cpp b/src/storm/storage/BitVector.cpp index 89113d718..a0004263a 100644 --- a/src/storm/storage/BitVector.cpp +++ b/src/storm/storage/BitVector.cpp @@ -486,7 +486,7 @@ namespace storm { void BitVector::setFromInt(uint_fast64_t bitIndex, uint_fast64_t numberOfBits, uint64_t value) { STORM_LOG_ASSERT(numberOfBits <= 64, "Number of bits must be <= 64."); - STORM_LOG_ASSERT(numberOfBits == 64 || (value >> numberOfBits) == 0, "Integer value too large to fit in the given number of bits."); + STORM_LOG_ASSERT(numberOfBits == 64 || (value >> numberOfBits) == 0, "Integer value ("<< value << ") too large to fit in the given number of bits (" << numberOfBits << ")."); uint64_t bucket = bitIndex >> 6; uint64_t bitIndexInBucket = bitIndex & mod64mask; From 69cae73bce1ffea49987ad120cb05db9024cdd50 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 16:50:07 +0100 Subject: [PATCH 12/47] fix in nextstate generator for MA --- src/storm/generator/NextStateGenerator.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/storm/generator/NextStateGenerator.cpp b/src/storm/generator/NextStateGenerator.cpp index 588edb70a..7f931051f 100644 --- a/src/storm/generator/NextStateGenerator.cpp +++ b/src/storm/generator/NextStateGenerator.cpp @@ -119,7 +119,7 @@ namespace storm { result.getChoices().front().add(choice); // Swap the choice to the end to indicate it can be removed (if it's not already there). - if (index != result.getNumberOfChoices() - 1) { + if (index != result.getNumberOfChoices() - 1 - numberOfChoicesToDelete) { choice = std::move(result.getChoices()[result.getNumberOfChoices() - 1 - numberOfChoicesToDelete]); } ++numberOfChoicesToDelete; From 474eaa950a143140aa67f4e30c4933627370371a Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 16:50:49 +0100 Subject: [PATCH 13/47] primes in dft element names are replaced now --- src/storm-dft/parser/DFTGalileoParser.cpp | 10 ++++++++-- src/storm-dft/parser/DFTGalileoParser.h | 1 + 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/src/storm-dft/parser/DFTGalileoParser.cpp b/src/storm-dft/parser/DFTGalileoParser.cpp index 776eb64d9..ec0b446d9 100644 --- a/src/storm-dft/parser/DFTGalileoParser.cpp +++ b/src/storm-dft/parser/DFTGalileoParser.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include "storm/storage/expressions/ExpressionManager.h" #include "storm/exceptions/NotImplementedException.h" #include "storm/exceptions/FileIoException.h" @@ -34,6 +35,11 @@ namespace storm { return name.substr(firstQuots+1,secondQuots-1); } } + + template + std::string DFTGalileoParser::parseNodeIdentifier(std::string const& name) { + return boost::replace_all_copy(name, "'", "__prime__"); + } template void DFTGalileoParser::readFile(const std::string& filename) { @@ -84,11 +90,11 @@ namespace storm { } else { std::vector tokens; boost::split(tokens, line, boost::is_any_of(" ")); - std::string name(stripQuotsFromName(tokens[0])); + std::string name(parseNodeIdentifier(stripQuotsFromName(tokens[0]))); std::vector childNames; for(unsigned i = 2; i < tokens.size(); ++i) { - childNames.push_back(stripQuotsFromName(tokens[i])); + childNames.push_back(parseNodeIdentifier(stripQuotsFromName(tokens[i]))); } if(tokens[1] == "and") { success = builder.addAndElement(name, childNames); diff --git a/src/storm-dft/parser/DFTGalileoParser.h b/src/storm-dft/parser/DFTGalileoParser.h index 3f19683ff..bb79be089 100644 --- a/src/storm-dft/parser/DFTGalileoParser.h +++ b/src/storm-dft/parser/DFTGalileoParser.h @@ -35,6 +35,7 @@ namespace storm { void readFile(std::string const& filename); std::string stripQuotsFromName(std::string const& name); + std::string parseNodeIdentifier(std::string const& name); ValueType parseRationalExpression(std::string const& expr); }; From d7aa7cc7c8754a6a4ee89df9703e055c2051cb71 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 16:51:28 +0100 Subject: [PATCH 14/47] expression AND with true is immediately simplified --- src/storm/storage/expressions/Expression.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/storm/storage/expressions/Expression.cpp b/src/storm/storage/expressions/Expression.cpp index 9dbd46986..c9ca8a320 100644 --- a/src/storm/storage/expressions/Expression.cpp +++ b/src/storm/storage/expressions/Expression.cpp @@ -235,6 +235,12 @@ namespace storm { Expression operator&&(Expression const& first, Expression const& second) { assertSameManager(first.getBaseExpression(), second.getBaseExpression()); + if (first.isTrue()) { + return second; + } + if (second.isTrue()) { + return first; + } return Expression(std::shared_ptr(new BinaryBooleanFunctionExpression(first.getBaseExpression().getManager(), first.getType().logicalConnective(second.getType()), first.getBaseExpressionPointer(), second.getBaseExpressionPointer(), BinaryBooleanFunctionExpression::OperatorType::And))); } From 5c900e4e14c6e86d6ee43b04051b54a9f7cb6956 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 17:58:58 +0100 Subject: [PATCH 15/47] stats for gspn --- src/storm-dft-cli/storm-dyftee.cpp | 1 + src/storm-gspn/storage/gspn/GSPN.cpp | 14 +++++++++ src/storm-gspn/storage/gspn/GSPN.h | 10 +++++-- src/storm-gspn/storm-gspn.h | 30 ++++++++++++++++++- .../settings/modules/GSPNExportSettings.cpp | 16 ++++++++++ .../settings/modules/GSPNExportSettings.h | 9 ++++++ 6 files changed, 77 insertions(+), 3 deletions(-) diff --git a/src/storm-dft-cli/storm-dyftee.cpp b/src/storm-dft-cli/storm-dyftee.cpp index 6c54dc226..7be07940c 100644 --- a/src/storm-dft-cli/storm-dyftee.cpp +++ b/src/storm-dft-cli/storm-dyftee.cpp @@ -136,6 +136,7 @@ int main(const int argc, const char** argv) { gspnTransformator.transform(); storm::gspn::GSPN* gspn = gspnTransformator.obtainGSPN(); uint64_t toplevelFailedPlace = gspnTransformator.toplevelFailedPlaceId(); + storm::handleGSPNExportSettings(*gspn); std::shared_ptr exprManager(new storm::expressions::ExpressionManager()); diff --git a/src/storm-gspn/storage/gspn/GSPN.cpp b/src/storm-gspn/storage/gspn/GSPN.cpp index 5a7f819de..74f5983ae 100644 --- a/src/storm-gspn/storage/gspn/GSPN.cpp +++ b/src/storm-gspn/storage/gspn/GSPN.cpp @@ -36,6 +36,14 @@ namespace storm { uint64_t GSPN::getNumberOfPlaces() const { return places.size(); } + + uint64_t GSPN::getNumberOfImmediateTransitions() const { + return immediateTransitions.size(); + } + + uint64_t GSPN::getNumberOfTimedTransitions() const { + return timedTransitions.size(); + } std::vector> const& GSPN::getTimedTransitions() const { return this->timedTransitions; @@ -565,6 +573,12 @@ namespace storm { stream << space << "" << std::endl; stream << "" << std::endl; } + + void GSPN::writeStatsToStream(std::ostream& stream) const { + stream << "Number of places: " << getNumberOfPlaces() << std::endl; + stream << "Number of timed transitions: " << getNumberOfTimedTransitions() << std::endl; + stream << "Number of immediate transitions: " << getNumberOfImmediateTransitions() << std::endl; + } } } diff --git a/src/storm-gspn/storage/gspn/GSPN.h b/src/storm-gspn/storage/gspn/GSPN.h index 7086a6c1c..b58a6adc5 100644 --- a/src/storm-gspn/storage/gspn/GSPN.h +++ b/src/storm-gspn/storage/gspn/GSPN.h @@ -37,6 +37,10 @@ namespace storm { * @return The number of places. */ uint64_t getNumberOfPlaces() const; + + uint64_t getNumberOfImmediateTransitions() const; + + uint64_t getNumberOfTimedTransitions() const; /*! * @@ -146,9 +150,11 @@ namespace storm { */ bool isValid() const; // TODO doc - void toPnpro(std::ostream &stream) const; + void toPnpro(std::ostream& stream) const; // TODO doc - void toPnml(std::ostream &stream) const; + void toPnml(std::ostream& stream) const; + + void writeStatsToStream(std::ostream& stream) const; private: storm::gspn::Place* getPlace(uint64_t id); storm::gspn::Place* getPlace(std::string const& name); diff --git a/src/storm-gspn/storm-gspn.h b/src/storm-gspn/storm-gspn.h index 3af59a9c1..3a3f9d55a 100644 --- a/src/storm-gspn/storm-gspn.h +++ b/src/storm-gspn/storm-gspn.h @@ -22,11 +22,39 @@ namespace storm { if (exportSettings.isWriteToDotSet()) { std::ofstream fs; fs.open(exportSettings.getWriteToDotFilename()); - gspn.writeDotToStream(std::cout); gspn.writeDotToStream(fs); fs.close(); } + if (exportSettings.isWriteToPnproSet()) { + std::ofstream fs; + fs.open(exportSettings.getWriteToPnproFilename()); + gspn.toPnpro(fs); + fs.close(); + } + + if (exportSettings.isWriteToPnmlSet()) { + std::ofstream fs; + fs.open(exportSettings.getWriteToPnmlFilename()); + gspn.toPnml(fs); + fs.close(); + } + + if (exportSettings.isDisplayStatsSet()) { + std::cout << "============GSPN Statistics==============" << std::endl; + gspn.writeStatsToStream(std::cout); + std::cout << "=========================================" << std::endl; + } + + if (exportSettings.isWriteStatsToFileSet()) { + std::ofstream fs; + fs.open(exportSettings.getWriteStatsFilename()); + gspn.writeStatsToStream(fs); + fs.close(); + } + + + } } \ No newline at end of file diff --git a/src/storm/settings/modules/GSPNExportSettings.cpp b/src/storm/settings/modules/GSPNExportSettings.cpp index 9be15c75e..8a5c315dc 100644 --- a/src/storm/settings/modules/GSPNExportSettings.cpp +++ b/src/storm/settings/modules/GSPNExportSettings.cpp @@ -19,6 +19,8 @@ namespace storm { const std::string GSPNExportSettings::writeToPnmlOptionName = "to-pnml"; const std::string GSPNExportSettings::writeToPnproOptionName = "to-pnpro"; + const std::string GSPNExportSettings::writeStatsOptionName = "to-stats"; + const std::string GSPNExportSettings::displayStatsOptionName = "show-stats"; //const std::string GSPNExportSettings::janiFileOptionShortName = "dotoutput"; @@ -27,6 +29,8 @@ namespace storm { this->addOption(storm::settings::OptionBuilder(moduleName, writeToDotOptionName, false, "Destination for the dot output.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "path to file").build()).build()); this->addOption(storm::settings::OptionBuilder(moduleName, writeToPnmlOptionName, false, "Destination for the pnml output").addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "path to file").build()).build()); this->addOption(storm::settings::OptionBuilder(moduleName, writeToPnproOptionName, false, "Destination for the pnpro output").addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "path to file").build()).build()); + this->addOption(storm::settings::OptionBuilder(moduleName, writeStatsOptionName, false, "Destination for the stats file").addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "path to file").build()).build()); + this->addOption(storm::settings::OptionBuilder(moduleName, displayStatsOptionName, false, "Print stats to stdout").build()); } bool GSPNExportSettings::isWriteToDotSet() const { @@ -54,6 +58,18 @@ namespace storm { } + bool GSPNExportSettings::isDisplayStatsSet() const { + return this->getOption(displayStatsOptionName).getHasOptionBeenSet(); + } + + bool GSPNExportSettings::isWriteStatsToFileSet() const { + return this->getOption(writeStatsOptionName).getHasOptionBeenSet(); + } + + std::string GSPNExportSettings::getWriteStatsFilename() const { + return this->getOption(writeStatsOptionName).getArgumentByName("filename").getValueAsString(); + } + void GSPNExportSettings::finalize() { } diff --git a/src/storm/settings/modules/GSPNExportSettings.h b/src/storm/settings/modules/GSPNExportSettings.h index 32ae422ba..554cce223 100644 --- a/src/storm/settings/modules/GSPNExportSettings.h +++ b/src/storm/settings/modules/GSPNExportSettings.h @@ -38,6 +38,12 @@ namespace storm { */ std::string getWriteToPnproFilename() const; + bool isDisplayStatsSet() const; + + bool isWriteStatsToFileSet() const; + + std::string getWriteStatsFilename() const; + bool check() const override; void finalize() override; @@ -48,6 +54,9 @@ namespace storm { static const std::string writeToDotOptionName; static const std::string writeToPnmlOptionName; static const std::string writeToPnproOptionName; + static const std::string displayStatsOptionName; + static const std::string writeStatsOptionName; + //static const std::string writeToDotOptionShortName; }; From f229a531879a6a16fdcccec1209ae51249f5b8ec Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 18:30:48 +0100 Subject: [PATCH 16/47] export priorities --- src/storm-gspn/storage/gspn/GSPN.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/storm-gspn/storage/gspn/GSPN.cpp b/src/storm-gspn/storage/gspn/GSPN.cpp index 74f5983ae..19f598c17 100644 --- a/src/storm-gspn/storage/gspn/GSPN.cpp +++ b/src/storm-gspn/storage/gspn/GSPN.cpp @@ -408,6 +408,7 @@ namespace storm { for (auto& trans : immediateTransitions) { stream << space3 << "" << std::endl; From 49537a83d35fbb1ee19261aa4074f69f88ab5559 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 20:04:32 +0100 Subject: [PATCH 17/47] added layout info to gspn - dft to gspn builds some layout in be and and --- .../DftToGspnTransformator.cpp | 15 ++++++- src/storm-gspn/storage/gspn/GSPN.cpp | 43 ++++++++++++++++--- src/storm-gspn/storage/gspn/GSPN.h | 13 +++++- src/storm-gspn/storage/gspn/GspnBuilder.cpp | 14 +++++- src/storm-gspn/storage/gspn/GspnBuilder.h | 14 ++++-- src/storm-gspn/storage/gspn/PlacementInfo.h | 17 ++++++++ src/storm-gspn/storage/gspn/Transition.h | 3 ++ 7 files changed, 106 insertions(+), 13 deletions(-) create mode 100644 src/storm-gspn/storage/gspn/PlacementInfo.h diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index 355c6f440..9ab52f28c 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -90,11 +90,13 @@ namespace storm { template void DftToGspnTransformator::drawBE(std::shared_ptr const> dftBE, bool isRepresentative) { - + double xcenter = 10.0; + double ycenter = 10.0; uint64_t beActive = builder.addPlace(defaultCapacity, isBEActive(dftBE) ? 1 : 0, dftBE->name() + STR_ACTIVATED); activeNodes.emplace(dftBE->id(), beActive); uint64_t beFailed = builder.addPlace(defaultCapacity, 0, dftBE->name() + STR_FAILED); + uint64_t unavailableNode = 0; if (isRepresentative) { unavailableNode = addUnavailableNode(dftBE); @@ -116,10 +118,18 @@ namespace storm { builder.addOutputArc(tActive, unavailableNode); builder.addOutputArc(tPassive, unavailableNode); } + + builder.setPlaceLayoutInfo(beActive, storm::gspn::LayoutInfo(xcenter - 3.0, ycenter)); + builder.setPlaceLayoutInfo(beFailed, storm::gspn::LayoutInfo(xcenter + 3.0, ycenter)); + builder.setTransitionLayoutInfo(tActive, storm::gspn::LayoutInfo(xcenter, ycenter + 3.0)); + builder.setTransitionLayoutInfo(tPassive, storm::gspn::LayoutInfo(xcenter, ycenter - 3.0)); + } template void DftToGspnTransformator::drawAND(std::shared_ptr const> dftAnd, bool isRepresentative) { + double xcenter = 10.0; + double ycenter = 20.0; uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftAnd->name() + STR_FAILED); assert(failedNodes.size() == dftAnd->id()); failedNodes.push_back(nodeFailed); @@ -142,6 +152,9 @@ namespace storm { builder.addOutputArc(tAndFailed, failedNodes[child->id()]); } + builder.setPlaceLayoutInfo(nodeFailed, storm::gspn::LayoutInfo(xcenter, ycenter-3.0)); + builder.setTransitionLayoutInfo(tAndFailed, storm::gspn::LayoutInfo(xcenter, ycenter+3.0)); + } template diff --git a/src/storm-gspn/storage/gspn/GSPN.cpp b/src/storm-gspn/storage/gspn/GSPN.cpp index 19f598c17..ce0d47d44 100644 --- a/src/storm-gspn/storage/gspn/GSPN.cpp +++ b/src/storm-gspn/storage/gspn/GSPN.cpp @@ -376,6 +376,20 @@ namespace storm { return result; } + + void GSPN::setPlaceLayoutInfo(uint64_t placeId, LayoutInfo const& layout) const { + placeLayout[placeId] = layout; + } + void GSPN::setTransitionLayoutInfo(uint64_t transitionId, LayoutInfo const& layout) const { + transitionLayout[transitionId] = layout; + } + + void GSPN::setPlaceLayoutInfo(std::map const& placeLayout) const { + this->placeLayout = placeLayout; + } + void GSPN::setTransitionLayoutInfo(std::map const& transitionLayout) const { + this->transitionLayout = transitionLayout; + } void GSPN::toPnpro(std::ostream &stream) const { auto space = " "; @@ -390,8 +404,14 @@ namespace storm { for (auto& place : places) { stream << space3 << " 0) { + stream << "x=\"" << placeLayout.at(place.getID()).x << "\" "; + stream << "y=\"" << placeLayout.at(place.getID()).y << "\" "; + } else { + stream << "x=\"" << x << "\" "; + stream << "y=\"1\" "; + + } stream << "/>" << std::endl; x = x + 3; } @@ -400,8 +420,14 @@ namespace storm { stream << space3 << " 0) { + stream << "x=\"" << transitionLayout.at(trans.getID()).x << "\" "; + stream << "y=\"" << transitionLayout.at(trans.getID()).y << "\" "; + } else { + stream << "x=\"" << x << "\" "; + stream << "y=\"4\" "; + + } stream << "/>" << std::endl; x = x + 3; } @@ -409,8 +435,13 @@ namespace storm { stream << space3 << " 0) { + stream << "x=\"" << transitionLayout.at(trans.getID()).x << "\" "; + stream << "y=\"" << transitionLayout.at(trans.getID()).y << "\" "; + } else { + stream << "x=\"" << x << "\" "; + stream << "y=\"4\" "; + } stream << "/>" << std::endl; x = x + 3; } diff --git a/src/storm-gspn/storage/gspn/GSPN.h b/src/storm-gspn/storage/gspn/GSPN.h index b58a6adc5..947769af3 100644 --- a/src/storm-gspn/storage/gspn/GSPN.h +++ b/src/storm-gspn/storage/gspn/GSPN.h @@ -11,6 +11,7 @@ #include "storm-gspn/storage/gspn/Place.h" #include "storm-gspn/storage/gspn/TimedTransition.h" #include "storm-gspn/storage/gspn/TransitionPartition.h" +#include "storm-gspn/storage/gspn/PlacementInfo.h" namespace storm { namespace gspn { @@ -140,7 +141,13 @@ namespace storm { * Set Capacities according to name->capacity map. */ void setCapacities(std::unordered_map const& mapping); - + + void setPlaceLayoutInfo(uint64_t placeId, LayoutInfo const& layout) const; + void setTransitionLayoutInfo(uint64_t transitionId, LayoutInfo const& layout) const; + void setPlaceLayoutInfo(std::map const& placeLayout) const; + void setTransitionLayoutInfo(std::map const& transitionLayout) const; + + /*! * Performe some checks * - testPlaces() @@ -191,6 +198,10 @@ namespace storm { std::vector partitions; + mutable std::map placeLayout; + mutable std::map transitionLayout; + + }; } } diff --git a/src/storm-gspn/storage/gspn/GspnBuilder.cpp b/src/storm-gspn/storage/gspn/GspnBuilder.cpp index fa81444c3..e0bbd76fd 100644 --- a/src/storm-gspn/storage/gspn/GspnBuilder.cpp +++ b/src/storm-gspn/storage/gspn/GspnBuilder.cpp @@ -23,6 +23,15 @@ namespace storm { places.push_back(place); return newId; } + + + void GspnBuilder::setPlaceLayoutInfo(uint64_t placeId, LayoutInfo const& layoutInfo) { + placeLayout[placeId] = layoutInfo; + } + + void GspnBuilder::setTransitionLayoutInfo(uint64_t transitionId, LayoutInfo const& layoutInfo) { + transitionLayout[transitionId] = layoutInfo; + } uint_fast64_t GspnBuilder::addImmediateTransition(uint_fast64_t const& priority, double const& weight, std::string const& name) { auto trans = storm::gspn::ImmediateTransition(); @@ -164,7 +173,10 @@ namespace storm { } std::reverse(orderedPartitions.begin(), orderedPartitions.end()); - return new GSPN(gspnName, places, immediateTransitions, timedTransitions, orderedPartitions); + GSPN* result = new GSPN(gspnName, places, immediateTransitions, timedTransitions, orderedPartitions); + result->setTransitionLayoutInfo(transitionLayout); + result->setPlaceLayoutInfo(placeLayout); + return result; } } } diff --git a/src/storm-gspn/storage/gspn/GspnBuilder.h b/src/storm-gspn/storage/gspn/GspnBuilder.h index 2f63ba719..79fb2e712 100644 --- a/src/storm-gspn/storage/gspn/GspnBuilder.h +++ b/src/storm-gspn/storage/gspn/GspnBuilder.h @@ -20,29 +20,32 @@ namespace storm { /** * Add a place to the gspn. - * @param id The id must be unique for the gspn. * @param name The name must be unique for the gspn. * @param capacity The capacity is the limit of tokens in the place. * A capacity of -1 indicates an unbounded place. * @param initialTokens The number of inital tokens in the place. */ uint_fast64_t addPlace(int_fast64_t const& capacity = 1, uint_fast64_t const& initialTokens = 0, std::string const& name = ""); + + void setPlaceLayoutInfo(uint64_t placeId, LayoutInfo const& layoutInfo); /** * Adds an immediate transition to the gspn. - * @param id The id must be unique for the gspn. * @param priority The priority for the transtion. * @param weight The weight for the transition. */ uint_fast64_t addImmediateTransition(uint_fast64_t const& priority = 0, WeightType const& weight = 0, std::string const& name = ""); - + + /** * Adds an timed transition to the gspn. - * @param id The name id be unique for the gspn. * @param priority The priority for the transtion. * @param weight The weight for the transition. */ uint_fast64_t addTimedTransition(uint_fast64_t const &priority, RateType const& rate, std::string const& name = ""); + + void setTransitionLayoutInfo(uint64_t transitionId, LayoutInfo const& layoutInfo); + /** * Adds an new input arc from a place to an transition. @@ -112,6 +115,9 @@ namespace storm { // set containing all places std::vector places; + + std::map placeLayout; + std::map transitionLayout; }; } } diff --git a/src/storm-gspn/storage/gspn/PlacementInfo.h b/src/storm-gspn/storage/gspn/PlacementInfo.h new file mode 100644 index 000000000..e59218686 --- /dev/null +++ b/src/storm-gspn/storage/gspn/PlacementInfo.h @@ -0,0 +1,17 @@ +#pragma once + +namespace storm { + namespace gspn { + struct LayoutInfo { + LayoutInfo() {}; + LayoutInfo(double x, double y, double rotation = 0.0) : x(x), y(y), rotation(rotation) {}; + + // x location + double x = 0.0; + // y location + double y = 0.0; + // degrees + double rotation = 0.0; + }; + } +} \ No newline at end of file diff --git a/src/storm-gspn/storage/gspn/Transition.h b/src/storm-gspn/storage/gspn/Transition.h index d61affaea..9deab2fb0 100644 --- a/src/storm-gspn/storage/gspn/Transition.h +++ b/src/storm-gspn/storage/gspn/Transition.h @@ -168,6 +168,9 @@ namespace storm { void setID(uint64_t const& id) { this->id = id; } + + + uint64_t getID() const { return id; } private: // maps place ids connected to this transition with an input arc to the corresponding multiplicity From 0bf00ff7acba4384678e6eb259afee45c54c9632 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 20:38:59 +0100 Subject: [PATCH 18/47] preparations for support of exclusive pand and por --- src/storm-dft/parser/DFTGalileoParser.h | 4 +++- src/storm-dft/storage/dft/DFTBuilder.cpp | 4 ++-- src/storm-dft/storage/dft/DFTBuilder.h | 14 +++++++++++++- src/storm-dft/storage/dft/elements/DFTPand.h | 15 ++++++++++++--- src/storm-dft/storage/dft/elements/DFTPor.h | 17 +++++++++++++---- 5 files changed, 43 insertions(+), 11 deletions(-) diff --git a/src/storm-dft/parser/DFTGalileoParser.h b/src/storm-dft/parser/DFTGalileoParser.h index bb79be089..04b822914 100644 --- a/src/storm-dft/parser/DFTGalileoParser.h +++ b/src/storm-dft/parser/DFTGalileoParser.h @@ -26,7 +26,7 @@ namespace storm { std::unordered_map identifierMapping; public: - DFTGalileoParser() : manager(new storm::expressions::ExpressionManager()), parser(*manager), evaluator(*manager) { + DFTGalileoParser(bool defaultInclusive = true) : builder(defaultInclusive), manager(new storm::expressions::ExpressionManager()), parser(*manager), evaluator(*manager) { } storm::storage::DFT parseDFT(std::string const& filename); @@ -38,6 +38,8 @@ namespace storm { std::string parseNodeIdentifier(std::string const& name); ValueType parseRationalExpression(std::string const& expr); + + bool defaultInclusive; }; } } diff --git a/src/storm-dft/storage/dft/DFTBuilder.cpp b/src/storm-dft/storage/dft/DFTBuilder.cpp index 612008226..10c84f5f6 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.cpp +++ b/src/storm-dft/storage/dft/DFTBuilder.cpp @@ -144,10 +144,10 @@ namespace storm { element = std::make_shared>(mNextId++, name); break; case DFTElementType::PAND: - element = std::make_shared>(mNextId++, name); + element = std::make_shared>(mNextId++, name, pandDefaultInclusive); break; case DFTElementType::POR: - element = std::make_shared>(mNextId++, name); + element = std::make_shared>(mNextId++, name, porDefaultInclusive); break; case DFTElementType::SPARE: element = std::make_shared>(mNextId++, name); diff --git a/src/storm-dft/storage/dft/DFTBuilder.h b/src/storm-dft/storage/dft/DFTBuilder.h index f9a11d52b..55c1cb588 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.h +++ b/src/storm-dft/storage/dft/DFTBuilder.h @@ -35,7 +35,7 @@ namespace storm { std::vector mRestrictions; public: - DFTBuilder() { + DFTBuilder(bool defaultInclusive = true) : pandDefaultInclusive(defaultInclusive), porDefaultInclusive(defaultInclusive) { } @@ -51,6 +51,13 @@ namespace storm { return addStandardGate(name, children, DFTElementType::PAND); } + bool addPandElement(std::string const& name, std::vector const& children, bool inclusive) { + bool tmpDefault = pandDefaultInclusive; + bool result = addStandardGate(name, children, DFTElementType::PAND); + pandDefaultInclusive = tmpDefault; + return result; + } + bool addPorElement(std::string const& name, std::vector const& children) { return addStandardGate(name, children, DFTElementType::POR); } @@ -187,6 +194,11 @@ namespace storm { DFTElementVector topoSort(); + // If true, the standard gate adders make a pand inclusive, and exclusive otherwise. + bool pandDefaultInclusive; + // If true, the standard gate adders make a pand inclusive, and exclusive otherwise. + bool porDefaultInclusive; + }; } } diff --git a/src/storm-dft/storage/dft/elements/DFTPand.h b/src/storm-dft/storage/dft/elements/DFTPand.h index bb18efe72..d89e357b1 100644 --- a/src/storm-dft/storage/dft/elements/DFTPand.h +++ b/src/storm-dft/storage/dft/elements/DFTPand.h @@ -7,11 +7,13 @@ namespace storm { class DFTPand : public DFTGate { public: - DFTPand(size_t id, std::string const& name, std::vector>> const& children = {}) : - DFTGate(id, name, children) + DFTPand(size_t id, std::string const& name, bool inclusive, std::vector>> const& children = {}) : + DFTGate(id, name, children), + inclusive(inclusive) {} void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const override { + assert(inclusive); if(state.isOperational(this->mId)) { bool childOperationalBefore = false; for(auto const& child : this->mChildren) @@ -31,6 +33,7 @@ namespace storm { } void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const override { + bool(inclusive); STORM_LOG_ASSERT(this->hasFailsafeChild(state), "No failsafe child."); if(state.isOperational(this->mId)) { this->failsafe(state, queues); @@ -42,9 +45,15 @@ namespace storm { return DFTElementType::PAND; } + bool isInclusive() const { + return inclusive; + } + std::string typestring() const override { - return "PAND"; + return "PAND" + inclusive ? "" : "-ex"; } + protected: + bool inclusive; }; template diff --git a/src/storm-dft/storage/dft/elements/DFTPor.h b/src/storm-dft/storage/dft/elements/DFTPor.h index 6e2fe731c..3adaf16fc 100644 --- a/src/storm-dft/storage/dft/elements/DFTPor.h +++ b/src/storm-dft/storage/dft/elements/DFTPor.h @@ -6,12 +6,14 @@ namespace storm { template class DFTPor : public DFTGate { public: - DFTPor(size_t id, std::string const& name, std::vector>> const& children = {}) : - DFTGate(id, name, children) + DFTPor(size_t id, std::string const& name, bool inclusive, std::vector>> const& children = {}) : + DFTGate(id, name, children), + inclusive(inclusive) {} void checkFails(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const override { - if(state.isOperational(this->mId)) { + assert(inclusive); + if(state.isOperational(this->mId)) { if (state.hasFailed(this->mChildren.front()->id())) { // First child has failed before others this->fail(state, queues); @@ -28,6 +30,7 @@ namespace storm { } void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const override { + assert(inclusive); if (state.isFailsafe(this->mChildren.front()->id())) { this->failsafe(state, queues); this->childrenDontCare(state, queues); @@ -39,8 +42,14 @@ namespace storm { } std::string typestring() const override { - return "POR"; + return "POR" + inclusive ? "" : "-ex"; } + + bool isInclusive() { + return inclusive; + } + protected: + bool inclusive; }; template From 92584d577f2c907f72993532ff70c4374ab7a70d Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 21:27:02 +0100 Subject: [PATCH 19/47] initial support for seq in dft->gspn --- .../storage/dft/elements/DFTRestriction.h | 9 +++ .../DftToGspnTransformator.cpp | 65 ++++++++++++------- .../transformations/DftToGspnTransformator.h | 8 ++- 3 files changed, 58 insertions(+), 24 deletions(-) diff --git a/src/storm-dft/storage/dft/elements/DFTRestriction.h b/src/storm-dft/storage/dft/elements/DFTRestriction.h index f4a03f688..195a217bb 100644 --- a/src/storm-dft/storage/dft/elements/DFTRestriction.h +++ b/src/storm-dft/storage/dft/elements/DFTRestriction.h @@ -36,6 +36,15 @@ namespace storm { virtual bool isSeqEnforcer() const { return false; } + + bool allChildrenBEs() const { + for(auto const& elem : mChildren) { + if (!elem->isBasicElement()) { + return false; + } + } + return true; + } virtual std::string typestring() const = 0; diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index 9ab52f28c..f3a113215 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -63,8 +63,8 @@ namespace storm { drawPOR(std::static_pointer_cast const>(dftElement), isRepresentative); break; case storm::storage::DFTElementType::SEQ: - // No method call needed here. SEQ only consists of restrictions, which are handled later. - break; + drawSeq(std::static_pointer_cast const>(dftElement)); + break; case storm::storage::DFTElementType::MUTEX: // No method call needed here. MUTEX only consists of restrictions, which are handled later. break; @@ -78,7 +78,7 @@ namespace storm { drawCONSTS(dftElement, isRepresentative); break; case storm::storage::DFTElementType::PDEP: - drawPDEP(std::static_pointer_cast const>(dftElement), isRepresentative); + drawPDEP(std::static_pointer_cast const>(dftElement)); break; default: STORM_LOG_ASSERT(false, "DFT type unknown."); @@ -96,9 +96,13 @@ namespace storm { activeNodes.emplace(dftBE->id(), beActive); uint64_t beFailed = builder.addPlace(defaultCapacity, 0, dftBE->name() + STR_FAILED); + uint64_t disabledNode = 0; + if (!smart || dftBE->nrRestrictions() > 0) { + disabledNode = addDisabledPlace(dftBE); + } uint64_t unavailableNode = 0; - if (isRepresentative) { + if (!smart || isRepresentative) { unavailableNode = addUnavailableNode(dftBE); } @@ -114,7 +118,12 @@ namespace storm { builder.addInhibitionArc(beFailed, tPassive); builder.addOutputArc(tPassive, beFailed); - if (isRepresentative) { + if (!smart || dftBE->nrRestrictions() > 0) { + builder.addInhibitionArc(disabledNode, tActive); + builder.addInhibitionArc(disabledNode, tPassive); + } + + if (!smart || isRepresentative) { builder.addOutputArc(tActive, unavailableNode); builder.addOutputArc(tPassive, unavailableNode); } @@ -350,26 +359,29 @@ namespace storm { } // template - void DftToGspnTransformator::drawPDEP(std::shared_ptr const> dftDependency, bool isRepresentative) { -// // Only draw dependency, if it wasn't drawn before. -// std::string gateName = dftDependency->name().substr(0, dftDependency->name().find("_")); -// auto exists = mGspn.getPlace(gateName + STR_FAILED); -// if (!exists.first) { -// storm::gspn::Place placeDEPFailed; -// placeDEPFailed.setName(gateName + STR_FAILED); -// placeDEPFailed.setNumberOfInitialTokens(0); -// mGspn.addPlace(placeDEPFailed); -// -// storm::gspn::TimedTransition timedTransitionDEPFailure; -// timedTransitionDEPFailure.setName(gateName + STR_FAILING); -// timedTransitionDEPFailure.setPriority(getPriority(0, dftDependency)); -// timedTransitionDEPFailure.setRate(dftDependency->probability()); -// timedTransitionDEPFailure.setOutputArcMultiplicity(placeDEPFailed, 1); -// timedTransitionDEPFailure.setInhibitionArcMultiplicity(placeDEPFailed, 1); -// mGspn.addTimedTransition(timedTransitionDEPFailure); -// } + void DftToGspnTransformator::drawPDEP(std::shared_ptr const> dftDependency) { + } + template + void DftToGspnTransformator::drawSeq(std::shared_ptr const> dftSeq) { + STORM_LOG_THROW(dftSeq->allChildrenBEs(), storm::exceptions::NotImplementedException, "Sequence enforcers with gates as children are currently not supported"); + bool first = true; + uint64_t tEnable = 0; + uint64_t nextPlace = 0; + for(auto const& child : dftSeq->children()) { + nextPlace = builder.addPlace(defaultCapacity, first ? 1 : 0, dftSeq->name() + "_next_" + child->name()); + if(!first) { + builder.addOutputArc(tEnable, nextPlace); + } + tEnable = builder.addImmediateTransition(defaultPriority, 0.0, dftSeq->name() + "_unblock_" +child->name() ); + builder.addInputArc(nextPlace, tEnable); + builder.addInputArc(disabledNodes.at(child->id()), tEnable); + first = false; + } + + } + template uint64_t DftToGspnTransformator::addUnavailableNode(std::shared_ptr const> dftElement, bool initialAvailable) { uint64_t unavailableNode = builder.addPlace(defaultCapacity, initialAvailable ? 0 : 1, dftElement->name() + "_unavailable"); @@ -377,6 +389,13 @@ namespace storm { unavailableNodes.emplace(dftElement->id(), unavailableNode); return unavailableNode; } + + template + uint64_t DftToGspnTransformator::addDisabledPlace(std::shared_ptr > dftBe) { + uint64_t disabledNode = builder.addPlace(dftBe->nrRestrictions(), dftBe->nrRestrictions(), dftBe->name() + "_dabled"); + disabledNodes.emplace(dftBe->id(), disabledNode); + return disabledNode; + } // template diff --git a/src/storm-dft/transformations/DftToGspnTransformator.h b/src/storm-dft/transformations/DftToGspnTransformator.h index 2d763452d..3cf5477e3 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.h +++ b/src/storm-dft/transformations/DftToGspnTransformator.h @@ -114,8 +114,10 @@ namespace storm { /* * Draw a Petri net PDEP (FDEP is included with a firerate of 1). */ - void drawPDEP(std::shared_ptr const> dftDependency, bool isRepresentative); + void drawPDEP(std::shared_ptr const> dftDependency); + + void drawSeq(std::shared_ptr const> dftSeq); /* * Return true if BE is active (corresponding place contains one initial token) or false if BE is inactive (corresponding place contains no initial token). * @@ -136,11 +138,15 @@ namespace storm { uint64_t addUnavailableNode(std::shared_ptr const> dftElement, bool initialAvailable = true); + uint64_t addDisabledPlace(std::shared_ptr const> dftBe); + storm::storage::DFT const& mDft; storm::gspn::GspnBuilder builder; std::vector failedNodes; std::map unavailableNodes; std::map activeNodes; + std::map disabledNodes; + bool smart = true; static constexpr const char* STR_FAILING = "_failing"; // Name standard for transitions that point towards a place, which in turn indicates the failure of a gate. static constexpr const char* STR_FAILED = "_failed"; // Name standard for place which indicates the failure of a gate. From 349b0404ba8c6e8ace97dbcee2317be4d3c52f8c Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 22:32:23 +0100 Subject: [PATCH 20/47] restrictions are now topo-sorted correctly --- src/storm-dft/storage/dft/DFTBuilder.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/storm-dft/storage/dft/DFTBuilder.cpp b/src/storm-dft/storage/dft/DFTBuilder.cpp index 10c84f5f6..69b100783 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.cpp +++ b/src/storm-dft/storage/dft/DFTBuilder.cpp @@ -175,7 +175,13 @@ namespace storm { } else if(visited[n] == topoSortColour::WHITE) { if(n->isGate()) { visited[n] = topoSortColour::GREY; - for(DFTElementPointer const& c : std::static_pointer_cast>(n)->children()) { + for (DFTElementPointer const& c : std::static_pointer_cast>(n)->children()) { + topoVisit(c, visited, L); + } + } + if(n->isRestriction()) { + visited[n] = topoSortColour::GREY; + for (DFTElementPointer const& c : std::static_pointer_cast>(n)->children()) { topoVisit(c, visited, L); } } From 6e5a316f1d70be83d983aef90ec7045edce11fa1 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 22:37:37 +0100 Subject: [PATCH 21/47] fix in dft::maxrank --- src/storm-dft/storage/dft/DFT.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/storm-dft/storage/dft/DFT.cpp b/src/storm-dft/storage/dft/DFT.cpp index 8f19119a2..3e06299f1 100644 --- a/src/storm-dft/storage/dft/DFT.cpp +++ b/src/storm-dft/storage/dft/DFT.cpp @@ -284,7 +284,13 @@ namespace storm { template uint64_t DFT::maxRank() const { - return mElements.back()->rank(); + uint64_t max = 0; + for (auto const& e : mElements) { + if(e->rank() > max) { + max = e->rank(); + } + } + return max; } template From 99428f9a7b87268da07c48bdd750c1a324edfad1 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 22:38:23 +0100 Subject: [PATCH 22/47] priorities updated such that 0 is not used as this is often reserved, e.g. in greatspn --- src/storm-dft/transformations/DftToGspnTransformator.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index f3a113215..14b037025 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -7,7 +7,7 @@ namespace storm { namespace dft { // Prevent some magic constants - static constexpr const uint64_t defaultPriority = 0; + static constexpr const uint64_t defaultPriority = 1; static constexpr const uint64_t defaultCapacity = 1; template @@ -436,7 +436,7 @@ namespace storm { template uint64_t DftToGspnTransformator::getFailPriority(std::shared_ptr const> dftElement) { - return mDft.maxRank() - dftElement->rank(); + return mDft.maxRank() - dftElement->rank() + 2; } From 80d578d1303cca9d63597f71348c76b55971e6dc Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 23:04:41 +0100 Subject: [PATCH 23/47] POR[inclusive] support seems to be working now --- .../DftToGspnTransformator.cpp | 60 +++++++++++-------- 1 file changed, 35 insertions(+), 25 deletions(-) diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index 14b037025..ccfa5bdf4 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -232,27 +232,32 @@ namespace storm { if (isRepresentative) { unavailableNode = addUnavailableNode(dftPand); } - - uint64_t nodeFS = builder.addPlace(defaultCapacity, 0, dftPand->name() + STR_FAILSAVE); - uint64_t tNodeFailed = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILING); - builder.addInhibitionArc(nodeFailed, tNodeFailed); - builder.addInhibitionArc(nodeFS, tNodeFailed); - builder.addOutputArc(tNodeFailed, nodeFailed); - if (isRepresentative) { + + if(dftPand->isInclusive()) { + + uint64_t nodeFS = builder.addPlace(defaultCapacity, 0, dftPand->name() + STR_FAILSAVE); + uint64_t tNodeFailed = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILING); + builder.addInhibitionArc(nodeFailed, tNodeFailed); + builder.addInhibitionArc(nodeFS, tNodeFailed); builder.addOutputArc(tNodeFailed, nodeFailed); - } - for(auto const& child : dftPand->children()) { - builder.addInputArc(failedNodes[child->id()], tNodeFailed); - builder.addOutputArc(tNodeFailed, failedNodes[child->id()]); - } - for (uint64_t j = 1; j < dftPand->nrChildren(); ++j) { - uint64_t tfs = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILSAVING + std::to_string(j)); - builder.addInputArc(failedNodes[dftPand->children().at(j)->id()], tfs); - builder.addOutputArc(tfs, failedNodes[dftPand->children().at(j)->id()]); - builder.addInhibitionArc(failedNodes[dftPand->children().at(j-1)->id()], tfs); - builder.addOutputArc(tfs, nodeFS); - builder.addInhibitionArc(nodeFS, tfs); - + if (isRepresentative) { + builder.addOutputArc(tNodeFailed, nodeFailed); + } + for(auto const& child : dftPand->children()) { + builder.addInputArc(failedNodes[child->id()], tNodeFailed); + builder.addOutputArc(tNodeFailed, failedNodes[child->id()]); + } + for (uint64_t j = 1; j < dftPand->nrChildren(); ++j) { + uint64_t tfs = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILSAVING + std::to_string(j)); + builder.addInputArc(failedNodes[dftPand->children().at(j)->id()], tfs); + builder.addOutputArc(tfs, failedNodes[dftPand->children().at(j)->id()]); + builder.addInhibitionArc(failedNodes[dftPand->children().at(j-1)->id()], tfs); + builder.addOutputArc(tfs, nodeFS); + builder.addInhibitionArc(nodeFS, tfs); + + } + } else { + STORM_LOG_THROW(false, storm::exceptions::NotImplementedException, "NOt yet implemented"); } } // @@ -318,6 +323,7 @@ namespace storm { template void DftToGspnTransformator::drawPOR(std::shared_ptr const> dftPor, bool isRepresentative) { uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftPor->name() + STR_FAILED); + failedNodes.push_back(nodeFailed); uint64_t nodeFS = builder.addPlace(defaultCapacity, 0, dftPor->name() + STR_FAILSAVE); @@ -329,11 +335,15 @@ namespace storm { builder.addInhibitionArc(nodeFailed, tfail); uint64_t j = 0; for (auto const& child : dftPor->children()) { - uint64_t tfailsf = builder.addImmediateTransition(getFailPriority(dftPor), 0.0, dftPor->name() + STR_FAILSAVING + std::to_string(j)); - builder.addInputArc(failedNodes.at(child->id()), tfailsf); - builder.addOutputArc(tfailsf, failedNodes.at(child->id())); - // TODO -// builder.addInhibitionArc(<#const uint_fast64_t &from#>, <#const uint_fast64_t &to#>) + if(j > 0) { + uint64_t tfailsf = builder.addImmediateTransition(getFailPriority(dftPor), 0.0, dftPor->name() + STR_FAILSAVING + std::to_string(j)); + builder.addInputArc(failedNodes.at(child->id()), tfailsf); + builder.addOutputArc(tfailsf, failedNodes.at(child->id())); + builder.addOutputArc(tfailsf, nodeFS); + builder.addInhibitionArc(nodeFS, tfailsf); + builder.addInhibitionArc(failedNodes.at(dftPor->children().front()->id()), tfailsf); + } + ++j; } } From fac77c0a3eac62f4a6873733de2b1468af3964c9 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 23:14:54 +0100 Subject: [PATCH 24/47] fixed seq, now correct... --- .../transformations/DftToGspnTransformator.cpp | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index ccfa5bdf4..4a4432f78 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -376,18 +376,21 @@ namespace storm { template void DftToGspnTransformator::drawSeq(std::shared_ptr const> dftSeq) { STORM_LOG_THROW(dftSeq->allChildrenBEs(), storm::exceptions::NotImplementedException, "Sequence enforcers with gates as children are currently not supported"); - bool first = true; + uint64_t j = 0; uint64_t tEnable = 0; uint64_t nextPlace = 0; for(auto const& child : dftSeq->children()) { - nextPlace = builder.addPlace(defaultCapacity, first ? 1 : 0, dftSeq->name() + "_next_" + child->name()); - if(!first) { + nextPlace = builder.addPlace(defaultCapacity, j==0 ? 1 : 0, dftSeq->name() + "_next_" + child->name()); + if (j>0) { builder.addOutputArc(tEnable, nextPlace); } tEnable = builder.addImmediateTransition(defaultPriority, 0.0, dftSeq->name() + "_unblock_" +child->name() ); builder.addInputArc(nextPlace, tEnable); builder.addInputArc(disabledNodes.at(child->id()), tEnable); - first = false; + if (j>0) { + builder.addInputArc(failedNodes.at(dftSeq->children().at(j-1)->id()), tEnable); + } + ++j; } } From 9c5444e059623d2654ebc0749578a489c2c7993d Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 23:44:19 +0100 Subject: [PATCH 25/47] better inclusive/exclusive support, including parsing --- src/storm-dft/parser/DFTGalileoParser.cpp | 8 ++++++++ src/storm-dft/storage/dft/DFTBuilder.h | 9 +++++++++ src/storm-dft/storage/dft/elements/DFTPand.h | 6 +++++- src/storm-dft/storage/dft/elements/DFTPor.h | 9 +++++++-- 4 files changed, 29 insertions(+), 3 deletions(-) diff --git a/src/storm-dft/parser/DFTGalileoParser.cpp b/src/storm-dft/parser/DFTGalileoParser.cpp index ec0b446d9..f872f4526 100644 --- a/src/storm-dft/parser/DFTGalileoParser.cpp +++ b/src/storm-dft/parser/DFTGalileoParser.cpp @@ -110,8 +110,16 @@ namespace storm { success = builder.addVotElement(name, threshold, childNames); } else if (tokens[1] == "pand") { success = builder.addPandElement(name, childNames); + } else if (tokens[1] == "pand-inc") { + success = builder.addPandElement(name, childNames, true); + } else if (tokens[1] == "pand-ex") { + success = builder.addPandElement(name, childNames, false); } else if (tokens[1] == "por") { success = builder.addPorElement(name, childNames); + } else if (tokens[1] == "por-ex") { + success = builder.addPorElement(name, childNames, false); + } else if (tokens[1] == "por-inc") { + success = builder.addPorElement(name, childNames, true); } else if (tokens[1] == "wsp" || tokens[1] == "csp") { success = builder.addSpareElement(name, childNames); } else if (tokens[1] == "seq") { diff --git a/src/storm-dft/storage/dft/DFTBuilder.h b/src/storm-dft/storage/dft/DFTBuilder.h index 55c1cb588..fbec0943e 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.h +++ b/src/storm-dft/storage/dft/DFTBuilder.h @@ -53,6 +53,7 @@ namespace storm { bool addPandElement(std::string const& name, std::vector const& children, bool inclusive) { bool tmpDefault = pandDefaultInclusive; + pandDefaultInclusive = inclusive; bool result = addStandardGate(name, children, DFTElementType::PAND); pandDefaultInclusive = tmpDefault; return result; @@ -62,6 +63,14 @@ namespace storm { return addStandardGate(name, children, DFTElementType::POR); } + bool addPorElement(std::string const& name, std::vector const& children, bool inclusive) { + bool tmpDefault = porDefaultInclusive; + porDefaultInclusive = inclusive; + bool result = addStandardGate(name, children, DFTElementType::POR); + pandDefaultInclusive = tmpDefault; + return result; + } + bool addSpareElement(std::string const& name, std::vector const& children) { return addStandardGate(name, children, DFTElementType::SPARE); } diff --git a/src/storm-dft/storage/dft/elements/DFTPand.h b/src/storm-dft/storage/dft/elements/DFTPand.h index d89e357b1..8e5e2716a 100644 --- a/src/storm-dft/storage/dft/elements/DFTPand.h +++ b/src/storm-dft/storage/dft/elements/DFTPand.h @@ -50,7 +50,11 @@ namespace storm { } std::string typestring() const override { - return "PAND" + inclusive ? "" : "-ex"; + if (inclusive) { + return "PAND-inc"; + } else { + return "PAND-ex"; + } } protected: bool inclusive; diff --git a/src/storm-dft/storage/dft/elements/DFTPor.h b/src/storm-dft/storage/dft/elements/DFTPor.h index 3adaf16fc..565b5dacd 100644 --- a/src/storm-dft/storage/dft/elements/DFTPor.h +++ b/src/storm-dft/storage/dft/elements/DFTPor.h @@ -42,10 +42,15 @@ namespace storm { } std::string typestring() const override { - return "POR" + inclusive ? "" : "-ex"; + if (inclusive) { + return "POR-inc"; + } else { + return "POR-ex"; + } + } - bool isInclusive() { + bool isInclusive() const { return inclusive; } protected: From c718b1caef03fe8ba7684d8a367c1fd6ec8b74a7 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Wed, 14 Dec 2016 23:44:55 +0100 Subject: [PATCH 26/47] dft-por exclusive added; also ensured that PORs work under SPAREs --- .../DftToGspnTransformator.cpp | 50 +++++++++++++------ 1 file changed, 36 insertions(+), 14 deletions(-) diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index 4a4432f78..6d22c8184 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -324,28 +324,50 @@ namespace storm { void DftToGspnTransformator::drawPOR(std::shared_ptr const> dftPor, bool isRepresentative) { uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftPor->name() + STR_FAILED); failedNodes.push_back(nodeFailed); - uint64_t nodeFS = builder.addPlace(defaultCapacity, 0, dftPor->name() + STR_FAILSAVE); + uint64_t unavailableNode = 0; + if (!smart || isRepresentative) { + unavailableNode = addUnavailableNode(dftPor); + } uint64_t tfail = builder.addImmediateTransition(getFailPriority(dftPor), 0.0, dftPor->name() + STR_FAILING); - builder.addInhibitionArc(nodeFS, tfail); - builder.addInputArc(failedNodes.at(dftPor->children().front()->id()), tfail); - builder.addOutputArc(tfail, failedNodes.at(dftPor->children().front()->id())); builder.addOutputArc(tfail, nodeFailed); builder.addInhibitionArc(nodeFailed, tfail); - uint64_t j = 0; - for (auto const& child : dftPor->children()) { - if(j > 0) { - uint64_t tfailsf = builder.addImmediateTransition(getFailPriority(dftPor), 0.0, dftPor->name() + STR_FAILSAVING + std::to_string(j)); - builder.addInputArc(failedNodes.at(child->id()), tfailsf); - builder.addOutputArc(tfailsf, failedNodes.at(child->id())); - builder.addOutputArc(tfailsf, nodeFS); - builder.addInhibitionArc(nodeFS, tfailsf); - builder.addInhibitionArc(failedNodes.at(dftPor->children().front()->id()), tfailsf); + + builder.addInputArc(failedNodes.at(dftPor->children().front()->id()), tfail); + builder.addOutputArc(tfail, failedNodes.at(dftPor->children().front()->id())); + + if(!smart || isRepresentative) { + builder.addOutputArc(tfail, unavailableNode); + } + + if(dftPor->isInclusive()) { + uint64_t nodeFS = builder.addPlace(defaultCapacity, 0, dftPor->name() + STR_FAILSAVE); + builder.addInhibitionArc(nodeFS, tfail); + uint64_t j = 0; + for (auto const& child : dftPor->children()) { + if(j > 0) { + uint64_t tfailsf = builder.addImmediateTransition(getFailPriority(dftPor), 0.0, dftPor->name() + STR_FAILSAVING + std::to_string(j)); + builder.addInputArc(failedNodes.at(child->id()), tfailsf); + builder.addOutputArc(tfailsf, failedNodes.at(child->id())); + builder.addOutputArc(tfailsf, nodeFS); + builder.addInhibitionArc(nodeFS, tfailsf); + builder.addInhibitionArc(failedNodes.at(dftPor->children().front()->id()), tfailsf); + } + + ++j; + } + } else { + uint64_t j = 0; + for (auto const& child : dftPor->children()) { + if(j > 0) { + builder.addInhibitionArc(failedNodes.at(child->id()), tfail); + } + ++j; } - ++j; } + } // From 44082fbc37ba9d0a514c8c8fa485a89bc5178f9a Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Thu, 15 Dec 2016 00:08:00 +0100 Subject: [PATCH 27/47] pand-ex support --- .../DftToGspnTransformator.cpp | 40 +++++++++++++++---- 1 file changed, 32 insertions(+), 8 deletions(-) diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index 6d22c8184..9028db24c 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -229,20 +229,22 @@ namespace storm { assert(failedNodes.size() == dftPand->id()); failedNodes.push_back(nodeFailed); uint64_t unavailableNode = 0; - if (isRepresentative) { + if (!smart || isRepresentative) { unavailableNode = addUnavailableNode(dftPand); } + uint64_t tNodeFailed = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILING); + builder.addInhibitionArc(nodeFailed, tNodeFailed); + builder.addOutputArc(tNodeFailed, nodeFailed); + if (!smart || isRepresentative) { + builder.addOutputArc(tNodeFailed, nodeFailed); + } + + if(dftPand->isInclusive()) { uint64_t nodeFS = builder.addPlace(defaultCapacity, 0, dftPand->name() + STR_FAILSAVE); - uint64_t tNodeFailed = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILING); - builder.addInhibitionArc(nodeFailed, tNodeFailed); builder.addInhibitionArc(nodeFS, tNodeFailed); - builder.addOutputArc(tNodeFailed, nodeFailed); - if (isRepresentative) { - builder.addOutputArc(tNodeFailed, nodeFailed); - } for(auto const& child : dftPand->children()) { builder.addInputArc(failedNodes[child->id()], tNodeFailed); builder.addOutputArc(tNodeFailed, failedNodes[child->id()]); @@ -257,7 +259,29 @@ namespace storm { } } else { - STORM_LOG_THROW(false, storm::exceptions::NotImplementedException, "NOt yet implemented"); + uint64_t fi = 0; + uint64_t tn = 0; + for(uint64_t j = 0; j < dftPand->nrChildren(); ++j) { + auto const& child = dftPand->children()[j]; + if (j > 0) { + builder.addInhibitionArc(failedNodes.at(child->id()), tn); + } + if (j != dftPand->nrChildren() - 1) { + tn = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILING + "_" +std::to_string(j)); + } else { + tn = tNodeFailed; + } + builder.addInputArc(failedNodes.at(child->id()), tn); + builder.addOutputArc(tn, failedNodes.at(child->id())); + if (j > 0) { + builder.addInputArc(fi, tn); + } + if (j != dftPand->nrChildren() - 1) { + fi = builder.addPlace(defaultCapacity, 0, dftPand->name() + "_F_" + std::to_string(j)); + builder.addOutputArc(tn, fi); + } + + } } } // From ec060a59b274b9a8d0a0ea012c14c48eb6b5d06a Mon Sep 17 00:00:00 2001 From: Matthias Volk Date: Thu, 15 Dec 2016 00:23:42 +0100 Subject: [PATCH 28/47] Fixed warnings --- src/storm-dft/storage/dft/elements/DFTPand.h | 2 +- src/storm-dft/storage/dft/elements/DFTPor.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/storm-dft/storage/dft/elements/DFTPand.h b/src/storm-dft/storage/dft/elements/DFTPand.h index d89e357b1..9879b8c31 100644 --- a/src/storm-dft/storage/dft/elements/DFTPand.h +++ b/src/storm-dft/storage/dft/elements/DFTPand.h @@ -50,7 +50,7 @@ namespace storm { } std::string typestring() const override { - return "PAND" + inclusive ? "" : "-ex"; + return inclusive ? "PAND" : "PAND-ex"; } protected: bool inclusive; diff --git a/src/storm-dft/storage/dft/elements/DFTPor.h b/src/storm-dft/storage/dft/elements/DFTPor.h index 3adaf16fc..7fd168b33 100644 --- a/src/storm-dft/storage/dft/elements/DFTPor.h +++ b/src/storm-dft/storage/dft/elements/DFTPor.h @@ -42,7 +42,7 @@ namespace storm { } std::string typestring() const override { - return "POR" + inclusive ? "" : "-ex"; + return inclusive ? "POR" : "POR-ex"; } bool isInclusive() { From a6cf0d2e0d2f91c9dab8b2e35854908d8481109d Mon Sep 17 00:00:00 2001 From: Matthias Volk Date: Thu, 15 Dec 2016 00:37:50 +0100 Subject: [PATCH 29/47] Fixed typo --- src/storm-dft/storage/dft/elements/DFTPand.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/storm-dft/storage/dft/elements/DFTPand.h b/src/storm-dft/storage/dft/elements/DFTPand.h index 9879b8c31..233dbc651 100644 --- a/src/storm-dft/storage/dft/elements/DFTPand.h +++ b/src/storm-dft/storage/dft/elements/DFTPand.h @@ -33,7 +33,7 @@ namespace storm { } void checkFailsafe(storm::storage::DFTState& state, DFTStateSpaceGenerationQueues& queues) const override { - bool(inclusive); + assert(inclusive); STORM_LOG_ASSERT(this->hasFailsafeChild(state), "No failsafe child."); if(state.isOperational(this->mId)) { this->failsafe(state, queues); From 63d594fb45decd7cd590104253f64a9a8868252b Mon Sep 17 00:00:00 2001 From: Matthias Volk Date: Thu, 15 Dec 2016 00:48:58 +0100 Subject: [PATCH 30/47] Rudimentary DFT parser from Cytoscape's JSON --- src/storm-dft-cli/storm-dyftee.cpp | 17 +- src/storm-dft/parser/DFTJsonParser.cpp | 168 ++++++++++++++++++ src/storm-dft/parser/DFTJsonParser.h | 48 +++++ .../settings/modules/DFTSettings.cpp | 14 +- src/storm-dft/settings/modules/DFTSettings.h | 16 ++ src/storm-dft/storage/dft/DFT.h | 15 +- src/storm-dft/storage/dft/DFTBuilder.cpp | 10 +- src/storm-dft/storage/dft/DFTBuilder.h | 8 +- src/storm-dft/storage/dft/DFTLayoutInfo.h | 15 ++ .../DftToGspnTransformator.cpp | 8 +- 10 files changed, 304 insertions(+), 15 deletions(-) create mode 100644 src/storm-dft/parser/DFTJsonParser.cpp create mode 100644 src/storm-dft/parser/DFTJsonParser.h create mode 100644 src/storm-dft/storage/dft/DFTLayoutInfo.h diff --git a/src/storm-dft-cli/storm-dyftee.cpp b/src/storm-dft-cli/storm-dyftee.cpp index 7be07940c..37b048b96 100644 --- a/src/storm-dft-cli/storm-dyftee.cpp +++ b/src/storm-dft-cli/storm-dyftee.cpp @@ -15,6 +15,7 @@ #include "storm/settings/modules/EliminationSettings.h" #include "storm-dft/parser/DFTGalileoParser.h" +#include "storm-dft/parser/DFTJsonParser.h" #include "storm-dft/modelchecker/dft/DFTModelChecker.h" #include "storm-dft/modelchecker/dft/DFTASFChecker.h" #include "storm-dft/transformations/DftToGspnTransformator.h" @@ -29,6 +30,7 @@ #include +#include /*! * Load DFT from filename, build corresponding Model and check against given property. @@ -123,16 +125,21 @@ int main(const int argc, const char** argv) { storm::settings::modules::DFTSettings const& dftSettings = storm::settings::getModule(); storm::settings::modules::GeneralSettings const& generalSettings = storm::settings::getModule(); - if (!dftSettings.isDftFileSet()) { + if (!dftSettings.isDftFileSet() && !dftSettings.isDftJsonFileSet()) { STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "No input model."); } if (dftSettings.isTransformToGspn()) { - - storm::parser::DFTGalileoParser parser; - storm::storage::DFT dft = parser.parseDFT(dftSettings.getDftFilename()); - storm::transformations::dft::DftToGspnTransformator gspnTransformator(dft); + std::shared_ptr> dft; + if (dftSettings.isDftJsonFileSet()) { + storm::parser::DFTJsonParser parser; + dft = std::make_shared>(parser.parseJson(dftSettings.getDftJsonFilename())); + } else { + storm::parser::DFTGalileoParser parser; + dft = std::make_shared>(parser.parseDFT(dftSettings.getDftFilename())); + } + storm::transformations::dft::DftToGspnTransformator gspnTransformator(*dft); gspnTransformator.transform(); storm::gspn::GSPN* gspn = gspnTransformator.obtainGSPN(); uint64_t toplevelFailedPlace = gspnTransformator.toplevelFailedPlaceId(); diff --git a/src/storm-dft/parser/DFTJsonParser.cpp b/src/storm-dft/parser/DFTJsonParser.cpp new file mode 100644 index 000000000..4bedbe7ac --- /dev/null +++ b/src/storm-dft/parser/DFTJsonParser.cpp @@ -0,0 +1,168 @@ +#include "DFTJsonParser.h" + +#include +#include +#include +#include +#include +#include "storm/storage/expressions/ExpressionManager.h" +#include "storm/exceptions/NotImplementedException.h" +#include "storm/exceptions/FileIoException.h" +#include "storm/exceptions/NotSupportedException.h" +#include "storm/utility/macros.h" + +namespace storm { + namespace parser { + + template + storm::storage::DFT DFTJsonParser::parseJson(const std::string& filename) { + readFile(filename); + storm::storage::DFT dft = builder.build(); + STORM_LOG_DEBUG("Elements:" << std::endl << dft.getElementsString()); + STORM_LOG_DEBUG("Spare Modules:" << std::endl << dft.getSpareModulesString()); + return dft; + } + + template + std::string DFTJsonParser::stripQuotsFromName(std::string const& name) { + size_t firstQuots = name.find("\""); + size_t secondQuots = name.find("\"", firstQuots+1); + + if(firstQuots == std::string::npos) { + return name; + } else { + STORM_LOG_THROW(secondQuots != std::string::npos, storm::exceptions::FileIoException, "No ending quotation mark found in " << name); + return name.substr(firstQuots+1,secondQuots-1); + } + } + + template + std::string DFTJsonParser::getString(json const& structure, std::string const& errorInfo) { + STORM_LOG_THROW(structure.is_string(), storm::exceptions::FileIoException, "Expected a string in " << errorInfo << ", got '" << structure.dump() << "'"); + return structure.front(); + } + + template + std::string DFTJsonParser::parseNodeIdentifier(std::string const& name) { + return boost::replace_all_copy(name, "'", "__prime__"); + } + + template + void DFTJsonParser::readFile(const std::string& filename) { + std::cout << "Parsing from JSON" << std::endl; + + std::ifstream file; + file.exceptions ( std::ifstream::failbit ); + try { + file.open(filename); + } + catch (std::ifstream::failure e) { + STORM_LOG_THROW(false, storm::exceptions::FileIoException, "Exception during file opening on " << filename << "."); + return; + } + file.exceptions( std::ifstream::goodbit ); + + json parsedJson; + parsedJson << file; + file.close(); + + // Start by building mapping from ids to names + std::map nameMapping; + for (auto& element: parsedJson) { + if (element.at("classes") != "") { + json data = element.at("data"); + std::string id = data.at("id"); + std::string name = data.at("name"); + nameMapping[id] = name; + } + } + + // TODO: avoid hack + std::string toplevelId = nameMapping["1"]; + + for (auto& element : parsedJson) { + std::cout << element << std::endl; + + bool success = true; + if (element.at("classes") == "") { + continue; + } + json data = element.at("data"); + std::string name = data.at("name"); + std::vector childNames; + if (data.count("children") > 0) { + for (auto& child : data.at("children")) { + childNames.push_back(nameMapping[child]); + } + } + + std::string type = getString(element.at("classes"), "classes"); + + if(type == "and") { + success = builder.addAndElement(name, childNames); + } else if (type == "or") { + success = builder.addOrElement(name, childNames); + } else if (type == "pand") { + success = builder.addPandElement(name, childNames); + } else if (type == "por") { + success = builder.addPorElement(name, childNames); + } else if (type == "spare") { + success = builder.addSpareElement(name, childNames); + } else if (type == "seq") { + success = builder.addSequenceEnforcer(name, childNames); + } else if (type== "fdep") { + success = builder.addDepElement(name, childNames, storm::utility::one()); + } else if (type== "pdep") { + ValueType probability = parseRationalExpression(data.at("prob")); + success = builder.addDepElement(name, childNames, probability); + } else if (type == "be") { + ValueType failureRate = parseRationalExpression(data.at("rate")); + ValueType dormancyFactor = parseRationalExpression(data.at("dorm")); + success = builder.addBasicElement(name, failureRate, dormancyFactor); + } else { + STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Type name: " << type << " not recognized."); + success = false; + } + + json position = element.at("position"); + double x = position.at("x"); + double y = position.at("y"); + builder.addLayoutInfo(name, x, y); + STORM_LOG_THROW(success, storm::exceptions::FileIoException, "Error while adding element '" << element << "'."); + } + + if(!builder.setTopLevel(toplevelId)) { + STORM_LOG_THROW(false, storm::exceptions::FileIoException, "Top level id unknown."); + } + } + + template + ValueType DFTJsonParser::parseRationalExpression(std::string const& expr) { + STORM_LOG_ASSERT(false, "Specialized method should be called."); + return 0; + } + + template<> + double DFTJsonParser::parseRationalExpression(std::string const& expr) { + return boost::lexical_cast(expr); + } + + // Explicitly instantiate the class. + template class DFTJsonParser; + +#ifdef STORM_HAVE_CARL + template<> + storm::RationalFunction DFTJsonParser::parseRationalExpression(std::string const& expr) { + STORM_LOG_TRACE("Translating expression: " << expr); + storm::expressions::Expression expression = parser.parseFromString(expr); + STORM_LOG_TRACE("Expression: " << expression); + storm::RationalFunction rationalFunction = evaluator.asRational(expression); + STORM_LOG_TRACE("Parsed expression: " << rationalFunction); + return rationalFunction; + } + + template class DFTJsonParser; +#endif + + } +} diff --git a/src/storm-dft/parser/DFTJsonParser.h b/src/storm-dft/parser/DFTJsonParser.h new file mode 100644 index 000000000..cf2e83826 --- /dev/null +++ b/src/storm-dft/parser/DFTJsonParser.h @@ -0,0 +1,48 @@ +#pragma once + +#include + +#include "storm/storage/expressions/ExpressionManager.h" +#include "storm/parser/ExpressionParser.h" +#include "storm/storage/expressions/ExpressionEvaluator.h" + +#include "storm-dft/storage/dft/DFT.h" +#include "storm-dft/storage/dft/DFTBuilder.h" + +// JSON parser +#include "json.hpp" + +using json = nlohmann::json; + +namespace storm { + namespace parser { + + template + class DFTJsonParser { + storm::storage::DFTBuilder builder; + + std::shared_ptr manager; + + storm::parser::ExpressionParser parser; + + storm::expressions::ExpressionEvaluator evaluator; + + std::unordered_map identifierMapping; + + public: + DFTJsonParser() : manager(new storm::expressions::ExpressionManager()), parser(*manager), evaluator(*manager) { + } + + storm::storage::DFT parseJson(std::string const& filename); + + private: + void readFile(std::string const& filename); + + std::string stripQuotsFromName(std::string const& name); + std::string parseNodeIdentifier(std::string const& name); + std::string getString(json const& structure, std::string const& errorInfo); + + ValueType parseRationalExpression(std::string const& expr); + }; + } +} diff --git a/src/storm-dft/settings/modules/DFTSettings.cpp b/src/storm-dft/settings/modules/DFTSettings.cpp index 5bf705d8a..898360c4b 100644 --- a/src/storm-dft/settings/modules/DFTSettings.cpp +++ b/src/storm-dft/settings/modules/DFTSettings.cpp @@ -16,6 +16,8 @@ namespace storm { const std::string DFTSettings::moduleName = "dft"; const std::string DFTSettings::dftFileOptionName = "dftfile"; const std::string DFTSettings::dftFileOptionShortName = "dft"; + const std::string DFTSettings::dftJsonFileOptionName = "dftfile-json"; + const std::string DFTSettings::dftJsonFileOptionShortName = "dftjson"; const std::string DFTSettings::symmetryReductionOptionName = "symmetryreduction"; const std::string DFTSettings::symmetryReductionOptionShortName = "symred"; const std::string DFTSettings::modularisationOptionName = "modularisation"; @@ -37,6 +39,8 @@ namespace storm { DFTSettings::DFTSettings() : ModuleSettings(moduleName) { this->addOption(storm::settings::OptionBuilder(moduleName, dftFileOptionName, false, "Parses the model given in the Galileo format.").setShortName(dftFileOptionShortName) .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the file from which to read the DFT model.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build()); + this->addOption(storm::settings::OptionBuilder(moduleName, dftJsonFileOptionName, false, "Parses the model given in the Cytoscape JSON format.").setShortName(dftJsonFileOptionShortName) + .addArgument(storm::settings::ArgumentBuilder::createStringArgument("filename", "The name of the JSON file from which to read the DFT model.").addValidationFunctionString(storm::settings::ArgumentValidators::existingReadableFileValidator()).build()).build()); this->addOption(storm::settings::OptionBuilder(moduleName, symmetryReductionOptionName, false, "Exploit symmetric structure of model.").setShortName(symmetryReductionOptionShortName).build()); this->addOption(storm::settings::OptionBuilder(moduleName, modularisationOptionName, false, "Use modularisation (not applicable for expected time).").build()); this->addOption(storm::settings::OptionBuilder(moduleName, disableDCOptionName, false, "Disable Dont Care propagation.").build()); @@ -60,7 +64,15 @@ namespace storm { std::string DFTSettings::getDftFilename() const { return this->getOption(dftFileOptionName).getArgumentByName("filename").getValueAsString(); } - + + bool DFTSettings::isDftJsonFileSet() const { + return this->getOption(dftJsonFileOptionName).getHasOptionBeenSet(); + } + + std::string DFTSettings::getDftJsonFilename() const { + return this->getOption(dftJsonFileOptionName).getArgumentByName("filename").getValueAsString(); + } + bool DFTSettings::useSymmetryReduction() const { return this->getOption(symmetryReductionOptionName).getHasOptionBeenSet(); } diff --git a/src/storm-dft/settings/modules/DFTSettings.h b/src/storm-dft/settings/modules/DFTSettings.h index 1b1b097f9..c1a9df7e5 100644 --- a/src/storm-dft/settings/modules/DFTSettings.h +++ b/src/storm-dft/settings/modules/DFTSettings.h @@ -34,6 +34,20 @@ namespace storm { */ std::string getDftFilename() const; + /*! + * Retrieves whether the dft file option for Json was set. + * + * @return True if the dft file option was set. + */ + bool isDftJsonFileSet() const; + + /*! + * Retrieves the name of the json file that contains the dft specification. + * + * @return The name of the json file that contains the dft specification. + */ + std::string getDftJsonFilename() const; + /*! * Retrieves whether the option to use symmetry reduction is set. * @@ -144,6 +158,8 @@ namespace storm { // Define the string names of the options as constants. static const std::string dftFileOptionName; static const std::string dftFileOptionShortName; + static const std::string dftJsonFileOptionName; + static const std::string dftJsonFileOptionShortName; static const std::string symmetryReductionOptionName; static const std::string symmetryReductionOptionShortName; static const std::string modularisationOptionName; diff --git a/src/storm-dft/storage/dft/DFT.h b/src/storm-dft/storage/dft/DFT.h index 9ef232a65..1304bbfa9 100644 --- a/src/storm-dft/storage/dft/DFT.h +++ b/src/storm-dft/storage/dft/DFT.h @@ -15,7 +15,7 @@ #include "storm-dft/storage/dft/DFTElements.h" #include "storm-dft/storage/dft/SymmetricUnits.h" #include "storm-dft/storage/dft/DFTStateGenerationInfo.h" - +#include "storm-dft/storage/dft/DFTLayoutInfo.h" namespace storm { namespace storage { @@ -63,7 +63,8 @@ namespace storm { std::vector mTopModule; std::map mRepresentants; // id element -> id representative std::vector> mSymmetries; - + std::map mLayoutInfo; + public: DFT(DFTElementVector const& elements, DFTElementPointer const& tle); @@ -263,7 +264,15 @@ namespace storm { std::vector immediateFailureCauses(size_t index) const; std::vector findModularisationRewrite() const; - + + void setElementLayoutInfo(size_t id, DFTLayoutInfo const& layoutInfo) { + mLayoutInfo[id] = layoutInfo; + } + + DFTLayoutInfo const& getElementLayoutInfo(size_t id) const { + return mLayoutInfo.at(id); + } + private: std::pair, std::vector> getSortedParentAndOutDepIds(size_t index) const; diff --git a/src/storm-dft/storage/dft/DFTBuilder.cpp b/src/storm-dft/storage/dft/DFTBuilder.cpp index 10c84f5f6..68ffce742 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.cpp +++ b/src/storm-dft/storage/dft/DFTBuilder.cpp @@ -73,8 +73,16 @@ namespace storm { for(DFTElementPointer e : elems) { e->setId(id++); } + STORM_LOG_ASSERT(!mTopLevelIdentifier.empty(), "No top level element."); - return DFT(elems, mElements[mTopLevelIdentifier]); + DFT dft(elems, mElements[mTopLevelIdentifier]); + + // Set layout info + for (auto& elem : mElements) { + dft.setElementLayoutInfo(elem.second->id(), mLayoutInfo.at(elem.first)); + } + + return dft; } template diff --git a/src/storm-dft/storage/dft/DFTBuilder.h b/src/storm-dft/storage/dft/DFTBuilder.h index 55c1cb588..baa9232a0 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.h +++ b/src/storm-dft/storage/dft/DFTBuilder.h @@ -7,7 +7,7 @@ #include "storm-dft/storage/dft/DFTElements.h" #include "storm-dft/storage/dft/elements/DFTRestriction.h" - +#include "storm-dft/storage/dft/DFTLayoutInfo.h" namespace storm { namespace storage { @@ -33,6 +33,7 @@ namespace storm { std::unordered_map> mRestrictionChildNames; std::vector mDependencies; std::vector mRestrictions; + std::unordered_map mLayoutInfo; public: DFTBuilder(bool defaultInclusive = true) : pandDefaultInclusive(defaultInclusive), porDefaultInclusive(defaultInclusive) { @@ -154,6 +155,11 @@ namespace storm { mElements[name] = std::make_shared>(mNextId++, name, failureRate, dormancyFactor); return true; } + + void addLayoutInfo(std::string const& name, double x, double y) { + STORM_LOG_ASSERT(mElements.count(name) > 0, "Element '" << name << "' not found."); + mLayoutInfo[name] = storm::storage::DFTLayoutInfo(x, y); + } bool setTopLevel(std::string const& tle) { mTopLevelIdentifier = tle; diff --git a/src/storm-dft/storage/dft/DFTLayoutInfo.h b/src/storm-dft/storage/dft/DFTLayoutInfo.h new file mode 100644 index 000000000..c61de0f6d --- /dev/null +++ b/src/storm-dft/storage/dft/DFTLayoutInfo.h @@ -0,0 +1,15 @@ +#pragma once + +namespace storm { + namespace storage { + struct DFTLayoutInfo { + DFTLayoutInfo() {}; + DFTLayoutInfo(double x, double y) : x(x), y(y) {}; + + // x location + double x = 0.0; + // y location + double y = 0.0; + }; + } +} diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index f3a113215..caed44166 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -90,8 +90,8 @@ namespace storm { template void DftToGspnTransformator::drawBE(std::shared_ptr const> dftBE, bool isRepresentative) { - double xcenter = 10.0; - double ycenter = 10.0; + double xcenter = mDft.getElementLayoutInfo(dftBE->id()).x; + double ycenter = mDft.getElementLayoutInfo(dftBE->id()).y; uint64_t beActive = builder.addPlace(defaultCapacity, isBEActive(dftBE) ? 1 : 0, dftBE->name() + STR_ACTIVATED); activeNodes.emplace(dftBE->id(), beActive); uint64_t beFailed = builder.addPlace(defaultCapacity, 0, dftBE->name() + STR_FAILED); @@ -137,8 +137,8 @@ namespace storm { template void DftToGspnTransformator::drawAND(std::shared_ptr const> dftAnd, bool isRepresentative) { - double xcenter = 10.0; - double ycenter = 20.0; + double xcenter = mDft.getElementLayoutInfo(dftAnd->id()).x; + double ycenter = mDft.getElementLayoutInfo(dftAnd->id()).y; uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftAnd->name() + STR_FAILED); assert(failedNodes.size() == dftAnd->id()); failedNodes.push_back(nodeFailed); From c2ea78b880a338c3a2408834830b39de1f9e2eb2 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Thu, 15 Dec 2016 00:54:24 +0100 Subject: [PATCH 31/47] no need anymore to create files from formulas if properties are present anyway --- src/storm/storage/jani/JSONExporter.cpp | 10 +++++----- src/storm/storage/jani/JSONExporter.h | 8 +++++--- src/storm/utility/storm.cpp | 4 ++-- 3 files changed, 12 insertions(+), 10 deletions(-) diff --git a/src/storm/storage/jani/JSONExporter.cpp b/src/storm/storage/jani/JSONExporter.cpp index 7548fd323..889496265 100644 --- a/src/storm/storage/jani/JSONExporter.cpp +++ b/src/storm/storage/jani/JSONExporter.cpp @@ -516,7 +516,7 @@ namespace storm { - void JsonExporter::toFile(storm::jani::Model const& janiModel, std::vector> const& formulas, std::string const& filepath, bool checkValid) { + void JsonExporter::toFile(storm::jani::Model const& janiModel, std::vector const& formulas, std::string const& filepath, bool checkValid) { std::ofstream ofs; ofs.open (filepath, std::ofstream::out ); if(ofs.is_open()) { @@ -526,7 +526,7 @@ namespace storm { } } - void JsonExporter::toStream(storm::jani::Model const& janiModel, std::vector> const& formulas, std::ostream& os, bool checkValid) { + void JsonExporter::toStream(storm::jani::Model const& janiModel, std::vector const& formulas, std::ostream& os, bool checkValid) { if(checkValid) { janiModel.checkValid(); } @@ -759,13 +759,13 @@ namespace storm { } - void JsonExporter::convertProperties( std::vector> const& formulas, storm::jani::Model const& model) { + void JsonExporter::convertProperties( std::vector const& formulas, storm::jani::Model const& model) { std::vector properties; uint64_t index = 0; for(auto const& f : formulas) { modernjson::json propDecl; - propDecl["name"] = "prop" + std::to_string(index); - propDecl["expression"] = convertFilterExpression(storm::jani::FilterExpression(f), model); + propDecl["name"] = f.getName(); + propDecl["expression"] = convertFilterExpression(f.getFilter(), model); ++index; properties.push_back(propDecl); } diff --git a/src/storm/storage/jani/JSONExporter.h b/src/storm/storage/jani/JSONExporter.h index 1008ec097..1eceb5d2e 100644 --- a/src/storm/storage/jani/JSONExporter.h +++ b/src/storm/storage/jani/JSONExporter.h @@ -4,6 +4,7 @@ #include "storm/storage/expressions/ExpressionVisitor.h" #include "storm/logic/FormulaVisitor.h" #include "Model.h" +#include "storm/storage/jani/Property.h" #include "storm/adapters/NumberAdapter.h" // JSON parser #include "json.hpp" @@ -66,12 +67,13 @@ namespace storm { JsonExporter() = default; public: - static void toFile(storm::jani::Model const& janiModel, std::vector> const& formulas, std::string const& filepath, bool checkValid = true); - static void toStream(storm::jani::Model const& janiModel, std::vector> const& formulas, std::ostream& ostream, bool checkValid = false); + static void toFile(storm::jani::Model const& janiModel, std::vector const& formulas, std::string const& filepath, bool checkValid = true); + static void toStream(storm::jani::Model const& janiModel, std::vector const& formulas, std::ostream& ostream, bool checkValid = false); + private: void convertModel(storm::jani::Model const& model); - void convertProperties(std::vector> const& formulas, storm::jani::Model const& model); + void convertProperties(std::vector const& formulas, storm::jani::Model const& model); void appendVariableDeclaration(storm::jani::Variable const& variable); modernjson::json finalize() { diff --git a/src/storm/utility/storm.cpp b/src/storm/utility/storm.cpp index 62c499fbd..9a0e6faba 100644 --- a/src/storm/utility/storm.cpp +++ b/src/storm/utility/storm.cpp @@ -36,9 +36,9 @@ namespace storm{ if (storm::settings::getModule().isExportAsStandardJaniSet()) { storm::jani::Model normalisedModel = model; normalisedModel.makeStandardJaniCompliant(); - storm::jani::JsonExporter::toFile(normalisedModel, formulasInProperties(properties), filepath); + storm::jani::JsonExporter::toFile(normalisedModel, properties, filepath); } else { - storm::jani::JsonExporter::toFile(model, formulasInProperties(properties), filepath); + storm::jani::JsonExporter::toFile(model, properties, filepath); } } From d379baef732d6cbd7389f41c5804709ed1adeedb Mon Sep 17 00:00:00 2001 From: sjunges Date: Thu, 15 Dec 2016 01:21:50 +0100 Subject: [PATCH 32/47] fix correct capit. to compile on linux --- src/storm-gspn/storm-gspn.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/storm-gspn/storm-gspn.h b/src/storm-gspn/storm-gspn.h index 3a3f9d55a..63b0746f1 100644 --- a/src/storm-gspn/storm-gspn.h +++ b/src/storm-gspn/storm-gspn.h @@ -3,7 +3,7 @@ #include "storm/storage/jani/Model.h" #include "storm-gspn/builder/JaniGSPNBuilder.h" -#include "storm-gspn/storage/gspn/Gspn.h" +#include "storm-gspn/storage/gspn/GSPN.h" #include "storm/settings/modules/GSPNExportSettings.h" From 31efb4f0c97f1919fd7ad360addd1addeb82511d Mon Sep 17 00:00:00 2001 From: sjunges Date: Thu, 15 Dec 2016 01:26:35 +0100 Subject: [PATCH 33/47] prep for more formulas --- src/storm-dft-cli/storm-dyftee.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/storm-dft-cli/storm-dyftee.cpp b/src/storm-dft-cli/storm-dyftee.cpp index 37b048b96..13f048a55 100644 --- a/src/storm-dft-cli/storm-dyftee.cpp +++ b/src/storm-dft-cli/storm-dyftee.cpp @@ -151,8 +151,9 @@ int main(const int argc, const char** argv) { storm::jani::Model* model = builder.build(); storm::jani::Variable const& topfailedVar = builder.getPlaceVariable(toplevelFailedPlace); - - auto evtlFormula = std::make_shared(exprManager->integer(1) == topfailedVar.getExpressionVariable().getExpression()); + + storm::expressions::Expression targetExpression = exprManager->integer(1) == topfailedVar.getExpressionVariable().getExpression(); + auto evtlFormula = std::make_shared(targetExpression); auto tbFormula = std::make_shared(std::make_shared(true), evtlFormula, 0.0, 10.0); auto tbUntil = std::make_shared(tbFormula); From a42703a49a47229cc5668e70a9b90b60a028d9a9 Mon Sep 17 00:00:00 2001 From: sjunges Date: Thu, 15 Dec 2016 01:27:03 +0100 Subject: [PATCH 34/47] towards support for n-ary pdeps --- src/storm-dft/storage/dft/DFTBuilder.cpp | 32 ++++++++++++------ src/storm-dft/storage/dft/DFTBuilder.h | 33 ++++++++++++------- .../storage/dft/elements/DFTDependency.h | 19 ++++------- 3 files changed, 50 insertions(+), 34 deletions(-) diff --git a/src/storm-dft/storage/dft/DFTBuilder.cpp b/src/storm-dft/storage/dft/DFTBuilder.cpp index 7953bf498..ed35b176d 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.cpp +++ b/src/storm-dft/storage/dft/DFTBuilder.cpp @@ -50,17 +50,29 @@ namespace storm { } } - // Initialize dependencies - for (auto& dependency : mDependencies) { - DFTGatePointer triggerEvent = std::static_pointer_cast>(mElements[dependency->nameTrigger()]); - STORM_LOG_ASSERT(mElements[dependency->nameDependent()]->isBasicElement(), "Dependent element is not BE."); - std::shared_ptr> dependentEvent = std::static_pointer_cast>(mElements[dependency->nameDependent()]); - dependency->initialize(triggerEvent, dependentEvent); - triggerEvent->addOutgoingDependency(dependency); - dependentEvent->addIngoingDependency(dependency); + for(auto& elem : mDependencyChildNames) { + bool first = true; + std::vector>> dependencies; + for(auto const& childName : elem.second) { + auto itFind = mElements.find(childName); + STORM_LOG_ASSERT(itFind != mElements.end(), "Child '" << childName << "' not found"); + DFTElementPointer childElement = itFind->second; + if (!first) { + dependencies.push_back(std::static_pointer_cast>(childElement)); + } else { + elem.first->setTriggerElement(std::static_pointer_cast>(childElement)); + childElement->addOutgoingDependency(elem.first); + } + first = false; + } + if (binaryDependencies) { + assert(dependencies.size() == 1); + } + assert(binaryDependencies); + elem.first->setDependentEvent(dependencies[0]); + dependencies[0]->addIngoingDependency(elem.first); } - - + // Sort elements topologically // compute rank diff --git a/src/storm-dft/storage/dft/DFTBuilder.h b/src/storm-dft/storage/dft/DFTBuilder.h index 4109272b7..9f216720c 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.h +++ b/src/storm-dft/storage/dft/DFTBuilder.h @@ -31,6 +31,7 @@ namespace storm { std::unordered_map mElements; std::unordered_map> mChildNames; std::unordered_map> mRestrictionChildNames; + std::unordered_map> mDependencyChildNames; std::vector mDependencies; std::vector mRestrictions; std::unordered_map mLayoutInfo; @@ -101,7 +102,7 @@ namespace storm { //TODO Matthias: collect constraints for SMT solving //0 <= probability <= 1 - if (!storm::utility::isOne(probability) && children.size() > 2) { + if (binaryDependencies && !storm::utility::isOne(probability) && children.size() > 2) { // Introduce additional element for first capturing the proabilistic dependency std::string nameAdditional = name + "_additional"; addBasicElement(nameAdditional, storm::utility::zero(), storm::utility::zero()); @@ -114,17 +115,25 @@ namespace storm { return true; } else { // Add dependencies - for (size_t i = 1; i < children.size(); ++i) { - std::string nameDep = name + "_" + std::to_string(i); - if(mElements.count(nameDep) != 0) { - // Element with that name already exists. - STORM_LOG_ERROR("Element with name: " << nameDep << " already exists."); - return false; + if(binaryDependencies) { + for (size_t i = 1; i < children.size(); ++i) { + std::string nameDep = name + "_" + std::to_string(i); + if (mElements.count(nameDep) != 0) { + // Element with that name already exists. + STORM_LOG_ERROR("Element with name: " << nameDep << " already exists."); + return false; + } + STORM_LOG_ASSERT(storm::utility::isOne(probability) || children.size() == 2, + "PDep with multiple children supported."); + DFTDependencyPointer element = std::make_shared>(mNextId++, + nameDep, + probability); + mElements[element->name()] = element; + mDependencyChildNames[element] = {trigger, children[i]}; + mDependencies.push_back(element); } - STORM_LOG_ASSERT(storm::utility::isOne(probability) || children.size() == 2, "PDep with multiple children supported."); - DFTDependencyPointer element = std::make_shared>(mNextId++, nameDep, trigger, children[i], probability); - mElements[element->name()] = element; - mDependencies.push_back(element); + } else { + } return true; } @@ -213,6 +222,8 @@ namespace storm { bool pandDefaultInclusive; // If true, the standard gate adders make a pand inclusive, and exclusive otherwise. bool porDefaultInclusive; + + bool binaryDependencies; }; } diff --git a/src/storm-dft/storage/dft/elements/DFTDependency.h b/src/storm-dft/storage/dft/elements/DFTDependency.h index 2c5b7d0cc..957048d68 100644 --- a/src/storm-dft/storage/dft/elements/DFTDependency.h +++ b/src/storm-dft/storage/dft/elements/DFTDependency.h @@ -12,35 +12,28 @@ namespace storm { using DFTBEPointer = std::shared_ptr>; protected: - std::string mNameTrigger; - std::string mNameDependent; ValueType mProbability; DFTGatePointer mTriggerEvent; DFTBEPointer mDependentEvent; public: - DFTDependency(size_t id, std::string const& name, std::string const& trigger, std::string const& dependent, ValueType probability) : - DFTElement(id, name), mNameTrigger(trigger), mNameDependent(dependent), mProbability(probability) + DFTDependency(size_t id, std::string const& name, ValueType probability) : + DFTElement(id, name), mProbability(probability) { } virtual ~DFTDependency() {} - void initialize(DFTGatePointer triggerEvent, DFTBEPointer dependentEvent) { - STORM_LOG_ASSERT(triggerEvent->name() == mNameTrigger, "Name does not match."); - STORM_LOG_ASSERT(dependentEvent->name() == mNameDependent, "Name does not match."); + void setTriggerElement(DFTGatePointer const& triggerEvent) { mTriggerEvent = triggerEvent; - mDependentEvent = dependentEvent; - } - std::string nameTrigger() const { - return mNameTrigger; } - std::string nameDependent() const { - return mNameDependent; + void setDependentEvent(DFTBEPointer const& dependentEvent) { + mDependentEvent = dependentEvent; } + ValueType const& probability() const { return mProbability; } From a5c7057fc382aa450f381e88605c08b6e88124f2 Mon Sep 17 00:00:00 2001 From: sjunges Date: Thu, 15 Dec 2016 02:12:46 +0100 Subject: [PATCH 35/47] quickfix for setting layout info only when available (review tomorrow) --- src/storm-dft/storage/dft/DFTBuilder.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/storm-dft/storage/dft/DFTBuilder.cpp b/src/storm-dft/storage/dft/DFTBuilder.cpp index ed35b176d..35ed767b8 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.cpp +++ b/src/storm-dft/storage/dft/DFTBuilder.cpp @@ -91,7 +91,9 @@ namespace storm { // Set layout info for (auto& elem : mElements) { - dft.setElementLayoutInfo(elem.second->id(), mLayoutInfo.at(elem.first)); + if(mLayoutInfo.count(elem.first) > 0) { + dft.setElementLayoutInfo(elem.second->id(), mLayoutInfo.at(elem.first)); + } } return dft; From d35bc5ed367419b685f8c7a252680a6fb85991e7 Mon Sep 17 00:00:00 2001 From: sjunges Date: Thu, 15 Dec 2016 02:13:30 +0100 Subject: [PATCH 36/47] n-ary pdeps supported as a datastructure --- src/storm-dft/storage/dft/DFT.cpp | 3 +- src/storm-dft/storage/dft/DFTBuilder.cpp | 4 ++- src/storm-dft/storage/dft/DFTIsomorphism.h | 23 +++++++++++++-- src/storm-dft/storage/dft/DFTState.cpp | 14 +++++---- src/storm-dft/storage/dft/elements/DFTBE.h | 3 +- .../storage/dft/elements/DFTDependency.h | 29 ++++++++++++------- .../storage/dft/elements/DFTElement.cpp | 4 ++- 7 files changed, 58 insertions(+), 22 deletions(-) diff --git a/src/storm-dft/storage/dft/DFT.cpp b/src/storm-dft/storage/dft/DFT.cpp index 3e06299f1..e38c40ce1 100644 --- a/src/storm-dft/storage/dft/DFT.cpp +++ b/src/storm-dft/storage/dft/DFT.cpp @@ -174,7 +174,8 @@ namespace storm { std::shared_ptr const> dependency = getDependency(idDependency); visitQueue.push(dependency->id()); visitQueue.push(dependency->triggerEvent()->id()); - visitQueue.push(dependency->dependentEvent()->id()); + STORM_LOG_THROW(dependency->dependentEvents().size() == 1, storm::exceptions::NotSupportedException, "Direct state generation does not support n-ary dependencies. Consider rewriting them by setting the binary dependency flag."); + visitQueue.push(dependency->dependentEvents()[0]->id()); } stateIndex = performStateGenerationInfoDFS(generationInfo, visitQueue, visited, stateIndex); diff --git a/src/storm-dft/storage/dft/DFTBuilder.cpp b/src/storm-dft/storage/dft/DFTBuilder.cpp index 35ed767b8..44846612f 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.cpp +++ b/src/storm-dft/storage/dft/DFTBuilder.cpp @@ -268,7 +268,9 @@ namespace storm { { DFTDependencyPointer dependency = std::static_pointer_cast>(element); children.push_back(dependency->triggerEvent()->name()); - children.push_back(dependency->dependentEvent()->name()); + for(auto const& depEv : dependency->dependentEvents()) { + children.push_back(depEv->name()); + } addDepElement(element->name(), children, dependency->probability()); break; } diff --git a/src/storm-dft/storage/dft/DFTIsomorphism.h b/src/storm-dft/storage/dft/DFTIsomorphism.h index 86625c975..081b76f0b 100644 --- a/src/storm-dft/storage/dft/DFTIsomorphism.h +++ b/src/storm-dft/storage/dft/DFTIsomorphism.h @@ -258,7 +258,8 @@ namespace storage { } void colourize(std::shared_ptr> const& dep) { - depColour[dep->id()] = std::pair(dep->probability(), dep->dependentEvent()->activeFailureRate()); + // TODO this can be improved for n-ary dependencies. + depColour[dep->id()] = std::pair(dep->probability(), dep->dependentEvents()[0]->activeFailureRate()); } void colourize(std::shared_ptr> const& restr) { @@ -486,10 +487,26 @@ namespace storage { STORM_LOG_ASSERT(dft.isDependency(indexpair.second), "Element is no dependency."); auto const& lDep = dft.getDependency(indexpair.first); auto const& rDep = dft.getDependency(indexpair.second); + if(bijection.at(lDep->triggerEvent()->id()) != rDep->triggerEvent()->id()) { return false; - } - if(bijection.at(lDep->dependentEvent()->id()) != rDep->dependentEvent()->id()) { + } + + std::set dependenciesLeftMapped; + for (auto const& depEv : lDep->dependentEvents()) { + if (bleft.has(depEv->id())) { + dependenciesLeftMapped.insert(bijection.at(depEv->id())); + } + } + + std::set dependenciesRight; + for (auto const& depEv : rDep->dependentEvents()) { + if (bright.has(depEv->id())) { + dependenciesRight.insert(depEv->id()); + } + } + + if (dependenciesLeftMapped != dependenciesRight) { return false; } } else if(dft.isRestriction(indexpair.first)) { diff --git a/src/storm-dft/storage/dft/DFTState.cpp b/src/storm-dft/storage/dft/DFTState.cpp index 78c0937d8..ec6509944 100644 --- a/src/storm-dft/storage/dft/DFTState.cpp +++ b/src/storm-dft/storage/dft/DFTState.cpp @@ -57,7 +57,8 @@ namespace storm { for (size_t dependencyId : mDft.getDependencies()) { std::shared_ptr const> dependency = mDft.getDependency(dependencyId); STORM_LOG_ASSERT(dependencyId == dependency->id(), "Ids do not match."); - if (hasFailed(dependency->triggerEvent()->id()) && getElementState(dependency->dependentEvent()->id()) == DFTElementState::Operational) { + assert(dependency->dependentEvents().size() == 1); + if (hasFailed(dependency->triggerEvent()->id()) && getElementState(dependency->dependentEvents()[0]->id()) == DFTElementState::Operational) { mFailableDependencies.push_back(dependencyId); STORM_LOG_TRACE("New dependency failure: " << dependency->toString()); } @@ -198,8 +199,9 @@ namespace storm { for (auto dependency : mDft.getElement(id)->outgoingDependencies()) { STORM_LOG_ASSERT(dependency->triggerEvent()->id() == id, "Ids do not match."); - if (getElementState(dependency->dependentEvent()->id()) == DFTElementState::Operational) { - STORM_LOG_ASSERT(!isFailsafe(dependency->dependentEvent()->id()), "Dependent event is failsafe."); + assert(dependency->dependentEvents().size() == 1); + if (getElementState(dependency->dependentEvents()[0]->id()) == DFTElementState::Operational) { + STORM_LOG_ASSERT(!isFailsafe(dependency->dependentEvents()[0]->id()), "Dependent event is failsafe."); mFailableDependencies.push_back(dependency->id()); STORM_LOG_TRACE("New dependency failure: " << dependency->toString()); } @@ -213,7 +215,8 @@ namespace storm { STORM_LOG_ASSERT(hasFailed(id), "Element has not failed."); for (auto dependency : mDft.getBasicElement(id)->ingoingDependencies()) { - STORM_LOG_ASSERT(dependency->dependentEvent()->id() == id, "Ids do not match."); + assert(dependency->dependentEvents().size() == 1); + STORM_LOG_ASSERT(dependency->dependentEvents()[0]->id() == id, "Ids do not match."); setDependencyDontCare(dependency->id()); } } @@ -244,7 +247,8 @@ namespace storm { // Consider failure due to dependency STORM_LOG_ASSERT(index < nrFailableDependencies(), "Index invalid."); std::shared_ptr const> dependency = mDft.getDependency(mFailableDependencies[index]); - std::pair const>,bool> res(mDft.getBasicElement(dependency->dependentEvent()->id()), true); + assert(dependency->dependentEvents().size() == 1); + std::pair const>,bool> res(mDft.getBasicElement(dependency->dependentEvents()[0]->id()), true); mFailableDependencies.erase(mFailableDependencies.begin() + index); setFailed(res.first->id()); setDependencySuccessful(dependency->id()); diff --git a/src/storm-dft/storage/dft/elements/DFTBE.h b/src/storm-dft/storage/dft/elements/DFTBE.h index 216227af6..3be82d9f1 100644 --- a/src/storm-dft/storage/dft/elements/DFTBE.h +++ b/src/storm-dft/storage/dft/elements/DFTBE.h @@ -38,7 +38,8 @@ namespace storm { } bool addIngoingDependency(DFTDependencyPointer const& e) { - STORM_LOG_ASSERT(e->dependentEvent()->id() == this->id(), "Ids do not match."); + // TODO write this assertion for n-ary dependencies, probably by addign a method to the dependencies to support this. + //STORM_LOG_ASSERT(e->dependentEvent()->id() == this->id(), "Ids do not match."); if(std::find(mIngoingDependencies.begin(), mIngoingDependencies.end(), e) != mIngoingDependencies.end()) { return false; } diff --git a/src/storm-dft/storage/dft/elements/DFTDependency.h b/src/storm-dft/storage/dft/elements/DFTDependency.h index 957048d68..e389f519e 100644 --- a/src/storm-dft/storage/dft/elements/DFTDependency.h +++ b/src/storm-dft/storage/dft/elements/DFTDependency.h @@ -14,7 +14,7 @@ namespace storm { protected: ValueType mProbability; DFTGatePointer mTriggerEvent; - DFTBEPointer mDependentEvent; + std::vector mDependentEvents; public: DFTDependency(size_t id, std::string const& name, ValueType probability) : @@ -30,7 +30,7 @@ namespace storm { } void setDependentEvent(DFTBEPointer const& dependentEvent) { - mDependentEvent = dependentEvent; + mDependentEvents = { dependentEvent }; } @@ -43,9 +43,9 @@ namespace storm { return mTriggerEvent; } - DFTBEPointer const& dependentEvent() const { - STORM_LOG_ASSERT(mDependentEvent, "Dependent element does not exists."); - return mDependentEvent; + std::vector const& dependentEvents() const { + STORM_LOG_ASSERT(mDependentEvents.size() > 0, "Dependent element does not exists."); + return mDependentEvents; } DFTElementType type() const override { @@ -69,9 +69,11 @@ namespace storm { virtual std::vector independentUnit() const override { std::set unit = {this->mId}; - mDependentEvent->extendUnit(unit); - if(unit.count(mTriggerEvent->id()) != 0) { - return {}; + for(auto const& depEv : mDependentEvents) { + depEv->extendUnit(unit); + if(unit.count(mTriggerEvent->id()) != 0) { + return {}; + } } return std::vector(unit.begin(), unit.end()); } @@ -83,7 +85,10 @@ namespace storm { // Parent in the subdft, ie it is *not* a subdft return; } - mDependentEvent->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves); + for (auto const& depEv : mDependentEvents) { + depEv->extendSubDft(elemsInSubtree, parentsOfSubRoot, blockParents, sparesAsLeaves); + if (elemsInSubtree.empty()) return; + } if(elemsInSubtree.empty()) { // Parent in the subdft, ie it is *not* a subdft return; @@ -95,7 +100,11 @@ namespace storm { virtual std::string toString() const override { std::stringstream stream; bool fdep = storm::utility::isOne(mProbability); - stream << "{" << this->name() << "} " << (fdep ? "FDEP" : "PDEP") << "(" << mTriggerEvent->name() << " => " << mDependentEvent->name() << ")"; + stream << "{" << this->name() << "} " << (fdep ? "FDEP" : "PDEP") << "(" << mTriggerEvent->name() << " => { "; + for(auto const& depEv : mDependentEvents) { + stream << depEv->name() << " "; + } + stream << "}"; if (!fdep) { stream << " with probability " << mProbability; } diff --git a/src/storm-dft/storage/dft/elements/DFTElement.cpp b/src/storm-dft/storage/dft/elements/DFTElement.cpp index 61a087bdb..287af8e98 100644 --- a/src/storm-dft/storage/dft/elements/DFTElement.cpp +++ b/src/storm-dft/storage/dft/elements/DFTElement.cpp @@ -14,8 +14,10 @@ namespace storm { } // Check that no outgoing dependencies can be triggered anymore + // Notice that n-ary dependencies are supported via rewriting them during build-time for (DFTDependencyPointer dependency : mOutgoingDependencies) { - if (state.isOperational(dependency->dependentEvent()->id()) && state.isOperational(dependency->triggerEvent()->id())) { + assert(dependency->dependentEvents().size() == 1); + if (state.isOperational(dependency->dependentEvents()[0]->id()) && state.isOperational(dependency->triggerEvent()->id())) { return false; } } From 159890844e6a8fef56b930c2297e034c947fcca2 Mon Sep 17 00:00:00 2001 From: Matthias Volk Date: Thu, 15 Dec 2016 09:57:27 +0100 Subject: [PATCH 37/47] Layout for AND and BE --- src/storm-dft/parser/DFTJsonParser.cpp | 7 +++-- .../DftToGspnTransformator.cpp | 27 ++++++++++++++----- 2 files changed, 23 insertions(+), 11 deletions(-) diff --git a/src/storm-dft/parser/DFTJsonParser.cpp b/src/storm-dft/parser/DFTJsonParser.cpp index 4bedbe7ac..2a1f3f1ac 100644 --- a/src/storm-dft/parser/DFTJsonParser.cpp +++ b/src/storm-dft/parser/DFTJsonParser.cpp @@ -49,7 +49,7 @@ namespace storm { template void DFTJsonParser::readFile(const std::string& filename) { - std::cout << "Parsing from JSON" << std::endl; + STORM_LOG_DEBUG("Parsing from JSON"); std::ifstream file; file.exceptions ( std::ifstream::failbit ); @@ -81,8 +81,6 @@ namespace storm { std::string toplevelId = nameMapping["1"]; for (auto& element : parsedJson) { - std::cout << element << std::endl; - bool success = true; if (element.at("classes") == "") { continue; @@ -124,10 +122,11 @@ namespace storm { success = false; } + // Set layout positions json position = element.at("position"); double x = position.at("x"); double y = position.at("y"); - builder.addLayoutInfo(name, x, y); + builder.addLayoutInfo(name, x / 10, y / 10); STORM_LOG_THROW(success, storm::exceptions::FileIoException, "Error while adding element '" << element << "'."); } diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index 868ab652c..176ed3254 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -90,9 +90,7 @@ namespace storm { template void DftToGspnTransformator::drawBE(std::shared_ptr const> dftBE, bool isRepresentative) { - double xcenter = mDft.getElementLayoutInfo(dftBE->id()).x; - double ycenter = mDft.getElementLayoutInfo(dftBE->id()).y; - uint64_t beActive = builder.addPlace(defaultCapacity, isBEActive(dftBE) ? 1 : 0, dftBE->name() + STR_ACTIVATED); + uint64_t beActive = builder.addPlace(defaultCapacity, isBEActive(dftBE) ? 1 : 0, dftBE->name() + STR_ACTIVATED); activeNodes.emplace(dftBE->id(), beActive); uint64_t beFailed = builder.addPlace(defaultCapacity, 0, dftBE->name() + STR_FAILED); @@ -127,7 +125,10 @@ namespace storm { builder.addOutputArc(tActive, unavailableNode); builder.addOutputArc(tPassive, unavailableNode); } - + + double xcenter = mDft.getElementLayoutInfo(dftBE->id()).x; + double ycenter = mDft.getElementLayoutInfo(dftBE->id()).y; + builder.setPlaceLayoutInfo(beActive, storm::gspn::LayoutInfo(xcenter - 3.0, ycenter)); builder.setPlaceLayoutInfo(beFailed, storm::gspn::LayoutInfo(xcenter + 3.0, ycenter)); builder.setTransitionLayoutInfo(tActive, storm::gspn::LayoutInfo(xcenter, ycenter + 3.0)); @@ -137,8 +138,6 @@ namespace storm { template void DftToGspnTransformator::drawAND(std::shared_ptr const> dftAnd, bool isRepresentative) { - double xcenter = mDft.getElementLayoutInfo(dftAnd->id()).x; - double ycenter = mDft.getElementLayoutInfo(dftAnd->id()).y; uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftAnd->name() + STR_FAILED); assert(failedNodes.size() == dftAnd->id()); failedNodes.push_back(nodeFailed); @@ -160,7 +159,10 @@ namespace storm { builder.addInputArc(failedNodes[child->id()], tAndFailed); builder.addOutputArc(tAndFailed, failedNodes[child->id()]); } - + + double xcenter = mDft.getElementLayoutInfo(dftAnd->id()).x; + double ycenter = mDft.getElementLayoutInfo(dftAnd->id()).y; + builder.setPlaceLayoutInfo(nodeFailed, storm::gspn::LayoutInfo(xcenter, ycenter-3.0)); builder.setTransitionLayoutInfo(tAndFailed, storm::gspn::LayoutInfo(xcenter, ycenter+3.0)); @@ -171,6 +173,11 @@ namespace storm { uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftOr->name() + STR_FAILED); assert(failedNodes.size() == dftOr->id()); failedNodes.push_back(nodeFailed); + + double xcenter = mDft.getElementLayoutInfo(dftOr->id()).x; + double ycenter = mDft.getElementLayoutInfo(dftOr->id()).y; + builder.setPlaceLayoutInfo(nodeFailed, storm::gspn::LayoutInfo(xcenter, ycenter-3.0)); + uint64_t unavailableNode = 0; if (isRepresentative) { unavailableNode = addUnavailableNode(dftOr); @@ -188,6 +195,7 @@ namespace storm { builder.addInputArc(failedNodes[child->id()], tNodeFailed); builder.addOutputArc(tNodeFailed, failedNodes[child->id()]); ++i; + builder.setTransitionLayoutInfo(tNodeFailed, storm::gspn::LayoutInfo(xcenter-5+i*3, ycenter+3.0)); } } @@ -228,6 +236,11 @@ namespace storm { uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftPand->name() + STR_FAILED); assert(failedNodes.size() == dftPand->id()); failedNodes.push_back(nodeFailed); + + double xcenter = mDft.getElementLayoutInfo(dftPand->id()).x; + double ycenter = mDft.getElementLayoutInfo(dftPand->id()).y; + builder.setPlaceLayoutInfo(nodeFailed, storm::gspn::LayoutInfo(xcenter, ycenter-3.0)); + uint64_t unavailableNode = 0; if (!smart || isRepresentative) { unavailableNode = addUnavailableNode(dftPand); From f78d30ab4fa073ae77666dc9a5b40d9a523880d8 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Thu, 15 Dec 2016 10:50:59 +0100 Subject: [PATCH 38/47] default layout info including warning --- src/storm-dft/storage/dft/DFT.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/storm-dft/storage/dft/DFT.h b/src/storm-dft/storage/dft/DFT.h index 1304bbfa9..4c904ec5c 100644 --- a/src/storm-dft/storage/dft/DFT.h +++ b/src/storm-dft/storage/dft/DFT.h @@ -270,6 +270,10 @@ namespace storm { } DFTLayoutInfo const& getElementLayoutInfo(size_t id) const { + if(mLayoutInfo.count(id) == 0) { + STORM_LOG_WARN("Layout info for element with id " << id << " not found"); + return DFTLayoutInfo(); + } return mLayoutInfo.at(id); } From 0d010fa6dcc94ebb1a1b5c005a5f9cdc26a77a0a Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Thu, 15 Dec 2016 10:52:06 +0100 Subject: [PATCH 39/47] dependencies as children are dummy output --- src/storm-dft/storage/dft/DFTBuilder.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/storm-dft/storage/dft/DFTBuilder.cpp b/src/storm-dft/storage/dft/DFTBuilder.cpp index 44846612f..f2a17541a 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.cpp +++ b/src/storm-dft/storage/dft/DFTBuilder.cpp @@ -25,9 +25,11 @@ namespace storm { if (itFind != mElements.end()) { // Child found DFTElementPointer childElement = itFind->second; - STORM_LOG_ASSERT(!childElement->isDependency(), "Child is dependency."); - gate->pushBackChild(childElement); - childElement->addParent(gate); + STORM_LOG_TRACE("Ignore functional dependency " << child << " in gate " << gate->name()); + if(!childElement->isDependency()) { + gate->pushBackChild(childElement); + childElement->addParent(gate); + } } else { // Child not found -> find first dependent event to assure that child is dependency // TODO: Not sure whether this is the intended behaviour? From 87b6182ea3638264ca84304e54f0e3bac2320f59 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Thu, 15 Dec 2016 10:53:04 +0100 Subject: [PATCH 40/47] build n-ary pdeps for transformation --- src/storm-dft-cli/storm-dyftee.cpp | 2 +- src/storm-dft/parser/DFTGalileoParser.h | 2 +- src/storm-dft/storage/dft/DFTBuilder.cpp | 8 +++++--- src/storm-dft/storage/dft/DFTBuilder.h | 7 +++++-- src/storm-dft/storage/dft/elements/DFTDependency.h | 4 ++-- 5 files changed, 14 insertions(+), 9 deletions(-) diff --git a/src/storm-dft-cli/storm-dyftee.cpp b/src/storm-dft-cli/storm-dyftee.cpp index 13f048a55..61959158a 100644 --- a/src/storm-dft-cli/storm-dyftee.cpp +++ b/src/storm-dft-cli/storm-dyftee.cpp @@ -136,7 +136,7 @@ int main(const int argc, const char** argv) { storm::parser::DFTJsonParser parser; dft = std::make_shared>(parser.parseJson(dftSettings.getDftJsonFilename())); } else { - storm::parser::DFTGalileoParser parser; + storm::parser::DFTGalileoParser parser(true, false); dft = std::make_shared>(parser.parseDFT(dftSettings.getDftFilename())); } storm::transformations::dft::DftToGspnTransformator gspnTransformator(*dft); diff --git a/src/storm-dft/parser/DFTGalileoParser.h b/src/storm-dft/parser/DFTGalileoParser.h index 04b822914..c2a35bc50 100644 --- a/src/storm-dft/parser/DFTGalileoParser.h +++ b/src/storm-dft/parser/DFTGalileoParser.h @@ -26,7 +26,7 @@ namespace storm { std::unordered_map identifierMapping; public: - DFTGalileoParser(bool defaultInclusive = true) : builder(defaultInclusive), manager(new storm::expressions::ExpressionManager()), parser(*manager), evaluator(*manager) { + DFTGalileoParser(bool defaultInclusive = true, bool binaryDependencies = true) : builder(defaultInclusive, binaryDependencies), manager(new storm::expressions::ExpressionManager()), parser(*manager), evaluator(*manager) { } storm::storage::DFT parseDFT(std::string const& filename); diff --git a/src/storm-dft/storage/dft/DFTBuilder.cpp b/src/storm-dft/storage/dft/DFTBuilder.cpp index f2a17541a..0bff9bd2b 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.cpp +++ b/src/storm-dft/storage/dft/DFTBuilder.cpp @@ -70,9 +70,11 @@ namespace storm { if (binaryDependencies) { assert(dependencies.size() == 1); } - assert(binaryDependencies); - elem.first->setDependentEvent(dependencies[0]); - dependencies[0]->addIngoingDependency(elem.first); + elem.first->setDependentEvents(dependencies); + for (auto& dependency : dependencies) { + dependency->addIngoingDependency(elem.first); + } + } diff --git a/src/storm-dft/storage/dft/DFTBuilder.h b/src/storm-dft/storage/dft/DFTBuilder.h index 9f216720c..636b5e5a1 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.h +++ b/src/storm-dft/storage/dft/DFTBuilder.h @@ -37,7 +37,7 @@ namespace storm { std::unordered_map mLayoutInfo; public: - DFTBuilder(bool defaultInclusive = true) : pandDefaultInclusive(defaultInclusive), porDefaultInclusive(defaultInclusive) { + DFTBuilder(bool defaultInclusive = true, bool binaryDependencies = true) : pandDefaultInclusive(defaultInclusive), porDefaultInclusive(defaultInclusive), binaryDependencies(binaryDependencies) { } @@ -133,7 +133,10 @@ namespace storm { mDependencies.push_back(element); } } else { - + DFTDependencyPointer element = std::make_shared>(mNextId++, name, probability); + mElements[element->name()] = element; + mDependencyChildNames[element] = children; + mDependencies.push_back(element); } return true; } diff --git a/src/storm-dft/storage/dft/elements/DFTDependency.h b/src/storm-dft/storage/dft/elements/DFTDependency.h index e389f519e..7d11bae2a 100644 --- a/src/storm-dft/storage/dft/elements/DFTDependency.h +++ b/src/storm-dft/storage/dft/elements/DFTDependency.h @@ -29,8 +29,8 @@ namespace storm { } - void setDependentEvent(DFTBEPointer const& dependentEvent) { - mDependentEvents = { dependentEvent }; + void setDependentEvents(std::vector const& dependentEvents) { + mDependentEvents = dependentEvents; } From 1fc2c2e82d0f28a10143c7fe7acede1c17bd63ff Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Thu, 15 Dec 2016 10:53:50 +0100 Subject: [PATCH 41/47] dft->gspn for n-ary pdeps: WIP --- .../DftToGspnTransformator.cpp | 26 +++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-) diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index 176ed3254..0d145ef0c 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -429,7 +429,29 @@ namespace storm { // template void DftToGspnTransformator::drawPDEP(std::shared_ptr const> dftDependency) { - + double xcenter = mDft.getElementLayoutInfo(dftDependency->id()).x;; + double ycenter = mDft.getElementLayoutInfo(dftDependency->id()).y;; + + uint64_t coinPlace = builder.addPlace(defaultCapacity, 1, dftDependency->name() + "_coin"); + uint64_t flipPlace = builder.addPlace(defaultCapacity, 1, dftDependency->name() + "_flip"); + uint64_t forwardPlace = builder.addPlace(defaultCapacity, 1, dftDependency->name() + "_forward"); + uint64_t t1 = builder.addImmediateTransition(defaultPriority, 0.0, dftDependency->name() + "_start_flip"); + builder.addInputArc(coinPlace, t1); + builder.addInputArc(failedNodes.at(dftDependency->triggerEvent()->id()), t1); + builder.addOutputArc(t1, failedNodes.at(dftDependency->triggerEvent()->id())); + builder.addOutputArc(t1, flipPlace); + uint64_t t2 = builder.addImmediateTransition(defaultPriority + 1, dftDependency->probability(), "_win_flip"); + builder.addInputArc(flipPlace, t2); + builder.addOutputArc(t2, forwardPlace); + if (dftDependency->probability() < 1.0) { + uint64_t t3 = builder.addImmediateTransition(defaultPriority + 1, 1 - dftDependency->probability(), "_loose_flip"); + builder.addInputArc(flipPlace, t3); + } + + builder.setPlaceLayoutInfo(coinPlace, storm::gspn::LayoutInfo(xcenter-5.0, ycenter+2.0)); + builder.setPlaceLayoutInfo(flipPlace, storm::gspn::LayoutInfo(xcenter-2.0, ycenter+2.0)); + builder.setPlaceLayoutInfo(forwardPlace, storm::gspn::LayoutInfo(xcenter+1.0, ycenter+2.0)); + } template @@ -443,7 +465,7 @@ namespace storm { if (j>0) { builder.addOutputArc(tEnable, nextPlace); } - tEnable = builder.addImmediateTransition(defaultPriority, 0.0, dftSeq->name() + "_unblock_" +child->name() ); + tEnable = builder.addImmediateTransition(defaultPriority + 1, 0.0, dftSeq->name() + "_unblock_" +child->name() ); builder.addInputArc(nextPlace, tEnable); builder.addInputArc(disabledNodes.at(child->id()), tEnable); if (j>0) { From a57c749f72a4aecd61d5ed6b44b38534b0f4df98 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Thu, 15 Dec 2016 11:26:23 +0100 Subject: [PATCH 42/47] topo sort for dependencies (stupid way..) --- src/storm-dft/storage/dft/DFTBuilder.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/storm-dft/storage/dft/DFTBuilder.cpp b/src/storm-dft/storage/dft/DFTBuilder.cpp index 0bff9bd2b..70df810cf 100644 --- a/src/storm-dft/storage/dft/DFTBuilder.cpp +++ b/src/storm-dft/storage/dft/DFTBuilder.cpp @@ -205,12 +205,20 @@ namespace storm { topoVisit(c, visited, L); } } + // TODO restrictions and dependencies have no parents, so this can be done more efficiently. if(n->isRestriction()) { visited[n] = topoSortColour::GREY; for (DFTElementPointer const& c : std::static_pointer_cast>(n)->children()) { topoVisit(c, visited, L); } } + if(n->isDependency()) { + visited[n] = topoSortColour::GREY; + for (DFTElementPointer const& c : std::static_pointer_cast>(n)->dependentEvents()) { + topoVisit(c, visited, L); + } + topoVisit(std::static_pointer_cast>(n)->triggerEvent(), visited, L); + } visited[n] = topoSortColour::BLACK; L.push_back(n); } From 8ef9b8a57673fa380bf1c2dbbb31e6b2a10f3756 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Thu, 15 Dec 2016 11:26:34 +0100 Subject: [PATCH 43/47] pdeps now fully working --- .../DftToGspnTransformator.cpp | 101 +++++++----------- 1 file changed, 36 insertions(+), 65 deletions(-) diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index 0d145ef0c..12d85e000 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -433,24 +433,48 @@ namespace storm { double ycenter = mDft.getElementLayoutInfo(dftDependency->id()).y;; uint64_t coinPlace = builder.addPlace(defaultCapacity, 1, dftDependency->name() + "_coin"); - uint64_t flipPlace = builder.addPlace(defaultCapacity, 1, dftDependency->name() + "_flip"); - uint64_t forwardPlace = builder.addPlace(defaultCapacity, 1, dftDependency->name() + "_forward"); + builder.setPlaceLayoutInfo(coinPlace, storm::gspn::LayoutInfo(xcenter-5.0, ycenter+2.0)); uint64_t t1 = builder.addImmediateTransition(defaultPriority, 0.0, dftDependency->name() + "_start_flip"); + builder.addInputArc(coinPlace, t1); builder.addInputArc(failedNodes.at(dftDependency->triggerEvent()->id()), t1); builder.addOutputArc(t1, failedNodes.at(dftDependency->triggerEvent()->id())); - builder.addOutputArc(t1, flipPlace); - uint64_t t2 = builder.addImmediateTransition(defaultPriority + 1, dftDependency->probability(), "_win_flip"); - builder.addInputArc(flipPlace, t2); - builder.addOutputArc(t2, forwardPlace); - if (dftDependency->probability() < 1.0) { - uint64_t t3 = builder.addImmediateTransition(defaultPriority + 1, 1 - dftDependency->probability(), "_loose_flip"); - builder.addInputArc(flipPlace, t3); + uint64_t forwardPlace = builder.addPlace(defaultCapacity, 0, dftDependency->name() + "_forward"); + builder.setPlaceLayoutInfo(forwardPlace, storm::gspn::LayoutInfo(xcenter+1.0, ycenter+2.0)); + + if (!smart || dftDependency->probability() < 1.0) { + uint64_t flipPlace = builder.addPlace(defaultCapacity, 0, dftDependency->name() + "_flip"); + builder.addOutputArc(t1, flipPlace); + + builder.setPlaceLayoutInfo(flipPlace, storm::gspn::LayoutInfo(xcenter-2.0, ycenter+2.0)); + uint64_t t2 = builder.addImmediateTransition(defaultPriority + 1, dftDependency->probability(), "_win_flip"); + builder.addInputArc(flipPlace, t2); + builder.addOutputArc(t2, forwardPlace); + if (dftDependency->probability() < 1.0) { + uint64_t t3 = builder.addImmediateTransition(defaultPriority + 1, 1 - dftDependency->probability(), "_loose_flip"); + builder.addInputArc(flipPlace, t3); + } + } else { + builder.addOutputArc(t1, forwardPlace); + } + for(auto const& depEv : dftDependency->dependentEvents()) { + uint64_t tx = builder.addImmediateTransition(defaultPriority, 0.0, dftDependency->name() + "_propagate_" + depEv->name()); + builder.addInputArc(forwardPlace, tx); + builder.addOutputArc(tx, forwardPlace); + builder.addOutputArc(tx, failedNodes.at(depEv->id())); + builder.addInhibitionArc(failedNodes.at(depEv->id()), tx); + if (!smart || depEv->nrRestrictions() > 0) { + builder.addInhibitionArc(disabledNodes.at(depEv->id()), tx); + } + if (!smart || mDft.isRepresentative(depEv->id())) { + builder.addOutputArc(tx, unavailableNodes.at(depEv->id())); + } + } - builder.setPlaceLayoutInfo(coinPlace, storm::gspn::LayoutInfo(xcenter-5.0, ycenter+2.0)); - builder.setPlaceLayoutInfo(flipPlace, storm::gspn::LayoutInfo(xcenter-2.0, ycenter+2.0)); - builder.setPlaceLayoutInfo(forwardPlace, storm::gspn::LayoutInfo(xcenter+1.0, ycenter+2.0)); + + + } @@ -536,59 +560,6 @@ namespace storm { template void DftToGspnTransformator::drawGSPNRestrictions() { -// for (std::size_t i = 0; i < mDft.nrElements(); i++) { -// auto dftElement = mDft.getElement(i); -// -// if (dftElement->isRestriction()) { -// switch (dftElement->type()) { -// case storm::storage::DFTElementType::SEQ: -// { -// auto children = mDft.getRestriction(i)->children(); -// -// for (std::size_t j = 0; j < children.size() - 1; j++) { -// auto suppressor = mGspn.getPlace(children[j]->name() + STR_FAILED); -// -// switch (children[j + 1]->type()) { -// case storm::storage::DFTElementType::BE: // If suppressed is a BE, add 2 arcs to timed transitions. -// { -// auto suppressedActive = mGspn.getTimedTransition(children[j + 1]->name() + "_activeFailing"); -// auto suppressedPassive = mGspn.getTimedTransition(children[j + 1]->name() + "_passiveFailing"); -// -// if (suppressor.first && suppressedActive.first && suppressedPassive.first) { // Only add arcs if the objects have been found. -// suppressedActive.second->setInputArcMultiplicity(suppressor.second, 1); -// suppressedActive.second->setOutputArcMultiplicity(suppressor.second, 1); -// suppressedPassive.second->setInputArcMultiplicity(suppressor.second, 1); -// suppressedPassive.second->setOutputArcMultiplicity(suppressor.second, 1); -// } -// break; -// } -// default: // If supressed is not a BE, add single arc to immediate transition. -// { -// auto suppressed = mGspn.getImmediateTransition(children[j + 1]->name() + STR_FAILING); -// -// if (suppressor.first && suppressed.first) { // Only add arcs if the objects have been found. -// suppressed.second->setInputArcMultiplicity(suppressor.second, 1); -// suppressed.second->setOutputArcMultiplicity(suppressor.second, 1); -// } -// break; -// } -// } -// } -// break; -// } -// case storm::storage::DFTElementType::MUTEX: -// { -// // MUTEX is not implemented by the DFTGalileoParser yet. Nothing to do here. -// STORM_LOG_ASSERT(false, "MUTEX is not supported by DftToGspnTransformator."); -// break; -// } -// default: -// { -// break; -// } -// } -// } -// } } template From 146bd193ea370484d134b1f1a16918f5137ea810 Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Thu, 15 Dec 2016 12:03:00 +0100 Subject: [PATCH 44/47] spare activation --- .../transformations/DftToGspnTransformator.cpp | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index 12d85e000..f97faa404 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -280,7 +280,7 @@ namespace storm { builder.addInhibitionArc(failedNodes.at(child->id()), tn); } if (j != dftPand->nrChildren() - 1) { - tn = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILING + "_" +std::to_string(j)); + tn = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILING + "_" + std::to_string(j)); } else { tn = tNodeFailed; } @@ -307,7 +307,7 @@ namespace storm { if (isRepresentative) { unavailableNode = addUnavailableNode(dftSpare); } - uint64_t spareActive = builder.addPlace(defaultCapacity, 0, dftSpare->name() + STR_ACTIVATED); + uint64_t spareActive = builder.addPlace(defaultCapacity, isBEActive(dftSpare) ? 1 : 0, dftSpare->name() + STR_ACTIVATED); activeNodes.emplace(dftSpare->id(), spareActive); @@ -345,6 +345,16 @@ namespace storm { builder.addOutputArc(tnextcl, failedNodes.at(child->id())); nextclTransitions.push_back(tnextcl); ++j; + for (uint64_t k : mDft.module(child->id())) { + + uint64_t tactive = builder.addImmediateTransition(defaultPriority+1, 0.0, dftSpare->name() + "_activate_" + std::to_string(j) + "_" + std::to_string(k)); + builder.addInputArc(cucNodes.back(), tactive); + builder.addInputArc(spareActive, tactive); + builder.addOutputArc(tactive, activeNodes.at(k)); + builder.addInhibitionArc(activeNodes.at(k), tactive); + } + + } builder.addOutputArc(nextconsiderTransitions.back(), nodeFailed); builder.addOutputArc(nextclTransitions.back(), nodeFailed); @@ -354,6 +364,7 @@ namespace storm { builder.addOutputArc(nextclTransitions.back(), unavailableNode); } + } // From 6672009cd164073f1889915b08cdad0ad996fe99 Mon Sep 17 00:00:00 2001 From: Matthias Volk Date: Thu, 15 Dec 2016 12:04:03 +0100 Subject: [PATCH 45/47] Layouting for GSPN --- src/storm-dft/parser/DFTJsonParser.cpp | 2 +- .../DftToGspnTransformator.cpp | 220 ++++++++++-------- .../transformations/DftToGspnTransformator.h | 2 +- 3 files changed, 130 insertions(+), 94 deletions(-) diff --git a/src/storm-dft/parser/DFTJsonParser.cpp b/src/storm-dft/parser/DFTJsonParser.cpp index 2a1f3f1ac..9a5c5d047 100644 --- a/src/storm-dft/parser/DFTJsonParser.cpp +++ b/src/storm-dft/parser/DFTJsonParser.cpp @@ -126,7 +126,7 @@ namespace storm { json position = element.at("position"); double x = position.at("x"); double y = position.at("y"); - builder.addLayoutInfo(name, x / 10, y / 10); + builder.addLayoutInfo(name, x / 7, y / 7); STORM_LOG_THROW(success, storm::exceptions::FileIoException, "Error while adding element '" << element << "'."); } diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index 12d85e000..f04aa79c8 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -93,6 +93,12 @@ namespace storm { uint64_t beActive = builder.addPlace(defaultCapacity, isBEActive(dftBE) ? 1 : 0, dftBE->name() + STR_ACTIVATED); activeNodes.emplace(dftBE->id(), beActive); uint64_t beFailed = builder.addPlace(defaultCapacity, 0, dftBE->name() + STR_FAILED); + + double xcenter = mDft.getElementLayoutInfo(dftBE->id()).x; + double ycenter = mDft.getElementLayoutInfo(dftBE->id()).y; + builder.setPlaceLayoutInfo(beActive, storm::gspn::LayoutInfo(xcenter - 3.0, ycenter)); + builder.setPlaceLayoutInfo(beFailed, storm::gspn::LayoutInfo(xcenter + 3.0, ycenter)); + uint64_t disabledNode = 0; if (!smart || dftBE->nrRestrictions() > 0) { @@ -101,17 +107,19 @@ namespace storm { uint64_t unavailableNode = 0; if (!smart || isRepresentative) { - unavailableNode = addUnavailableNode(dftBE); + unavailableNode = addUnavailableNode(dftBE, storm::gspn::LayoutInfo(xcenter+9.0, ycenter)); } assert(failedNodes.size() == dftBE->id()); failedNodes.push_back(beFailed); uint64_t tActive = builder.addTimedTransition(defaultPriority, dftBE->activeFailureRate(), dftBE->name() + "_activeFailing"); + builder.setTransitionLayoutInfo(tActive, storm::gspn::LayoutInfo(xcenter, ycenter + 3.0)); builder.addInputArc(beActive, tActive); builder.addInhibitionArc(beFailed, tActive); builder.addOutputArc(tActive, beActive); builder.addOutputArc(tActive, beFailed); uint64_t tPassive = builder.addTimedTransition(defaultPriority, dftBE->passiveFailureRate(), dftBE->name() + "_passiveFailing"); + builder.setTransitionLayoutInfo(tPassive, storm::gspn::LayoutInfo(xcenter, ycenter - 3.0)); builder.addInhibitionArc(beActive, tPassive); builder.addInhibitionArc(beFailed, tPassive); builder.addOutputArc(tPassive, beFailed); @@ -125,15 +133,6 @@ namespace storm { builder.addOutputArc(tActive, unavailableNode); builder.addOutputArc(tPassive, unavailableNode); } - - double xcenter = mDft.getElementLayoutInfo(dftBE->id()).x; - double ycenter = mDft.getElementLayoutInfo(dftBE->id()).y; - - builder.setPlaceLayoutInfo(beActive, storm::gspn::LayoutInfo(xcenter - 3.0, ycenter)); - builder.setPlaceLayoutInfo(beFailed, storm::gspn::LayoutInfo(xcenter + 3.0, ycenter)); - builder.setTransitionLayoutInfo(tActive, storm::gspn::LayoutInfo(xcenter, ycenter + 3.0)); - builder.setTransitionLayoutInfo(tPassive, storm::gspn::LayoutInfo(xcenter, ycenter - 3.0)); - } template @@ -141,14 +140,19 @@ namespace storm { uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftAnd->name() + STR_FAILED); assert(failedNodes.size() == dftAnd->id()); failedNodes.push_back(nodeFailed); - + + double xcenter = mDft.getElementLayoutInfo(dftAnd->id()).x; + double ycenter = mDft.getElementLayoutInfo(dftAnd->id()).y; + builder.setPlaceLayoutInfo(nodeFailed, storm::gspn::LayoutInfo(xcenter, ycenter-3.0)); + uint64_t unavailableNode = 0; if (isRepresentative) { - unavailableNode = addUnavailableNode(dftAnd); + unavailableNode = addUnavailableNode(dftAnd, storm::gspn::LayoutInfo(xcenter+6.0, ycenter-3.0)); } uint64_t tAndFailed = builder.addImmediateTransition( getFailPriority(dftAnd) , 0.0, dftAnd->name() + STR_FAILING ); + builder.setTransitionLayoutInfo(tAndFailed, storm::gspn::LayoutInfo(xcenter, ycenter+3.0)); builder.addInhibitionArc(nodeFailed, tAndFailed); builder.addOutputArc(tAndFailed, nodeFailed); if (isRepresentative) { @@ -159,13 +163,6 @@ namespace storm { builder.addInputArc(failedNodes[child->id()], tAndFailed); builder.addOutputArc(tAndFailed, failedNodes[child->id()]); } - - double xcenter = mDft.getElementLayoutInfo(dftAnd->id()).x; - double ycenter = mDft.getElementLayoutInfo(dftAnd->id()).y; - - builder.setPlaceLayoutInfo(nodeFailed, storm::gspn::LayoutInfo(xcenter, ycenter-3.0)); - builder.setTransitionLayoutInfo(tAndFailed, storm::gspn::LayoutInfo(xcenter, ycenter+3.0)); - } template @@ -180,12 +177,13 @@ namespace storm { uint64_t unavailableNode = 0; if (isRepresentative) { - unavailableNode = addUnavailableNode(dftOr); + unavailableNode = addUnavailableNode(dftOr, storm::gspn::LayoutInfo(xcenter+6.0, ycenter-3.0)); } uint64_t i = 0; for (auto const& child : dftOr->children()) { - uint64_t tNodeFailed = builder.addImmediateTransition( getFailPriority(dftOr) , 0.0, dftOr->name() + STR_FAILING + std::to_string(i) ); + uint64_t tNodeFailed = builder.addImmediateTransition( getFailPriority(dftOr), 0.0, dftOr->name() + STR_FAILING + std::to_string(i) ); + builder.setTransitionLayoutInfo(tNodeFailed, storm::gspn::LayoutInfo(xcenter-5.0+i*3.0, ycenter+3.0)); builder.addInhibitionArc(nodeFailed, tNodeFailed); builder.addOutputArc(tNodeFailed, nodeFailed); if (isRepresentative) { @@ -195,21 +193,28 @@ namespace storm { builder.addInputArc(failedNodes[child->id()], tNodeFailed); builder.addOutputArc(tNodeFailed, failedNodes[child->id()]); ++i; - builder.setTransitionLayoutInfo(tNodeFailed, storm::gspn::LayoutInfo(xcenter-5+i*3, ycenter+3.0)); } } template void DftToGspnTransformator::drawVOT(std::shared_ptr const> dftVot, bool isRepresentative) { + // TODO: finish layouting uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftVot->name() + STR_FAILED); assert(failedNodes.size() == dftVot->id()); failedNodes.push_back(nodeFailed); + + double xcenter = mDft.getElementLayoutInfo(dftVot->id()).x; + double ycenter = mDft.getElementLayoutInfo(dftVot->id()).y; + builder.setPlaceLayoutInfo(nodeFailed, storm::gspn::LayoutInfo(xcenter, ycenter-3.0)); + uint64_t unavailableNode = 0; if (isRepresentative) { - unavailableNode = addUnavailableNode(dftVot); + unavailableNode = addUnavailableNode(dftVot, storm::gspn::LayoutInfo(xcenter+6.0, ycenter-3.0)); } uint64_t nodeCollector = builder.addPlace(dftVot->nrChildren(), 0, dftVot->name() + "_collector"); + builder.setPlaceLayoutInfo(nodeCollector, storm::gspn::LayoutInfo(xcenter, ycenter)); + uint64_t tNodeFailed = builder.addImmediateTransition(getFailPriority(dftVot), 0.0, dftVot->name() + STR_FAILING); builder.addOutputArc(tNodeFailed, nodeFailed); if (isRepresentative) { @@ -239,24 +244,26 @@ namespace storm { double xcenter = mDft.getElementLayoutInfo(dftPand->id()).x; double ycenter = mDft.getElementLayoutInfo(dftPand->id()).y; - builder.setPlaceLayoutInfo(nodeFailed, storm::gspn::LayoutInfo(xcenter, ycenter-3.0)); + builder.setPlaceLayoutInfo(nodeFailed, storm::gspn::LayoutInfo(xcenter+3.0, ycenter-3.0)); uint64_t unavailableNode = 0; if (!smart || isRepresentative) { - unavailableNode = addUnavailableNode(dftPand); + unavailableNode = addUnavailableNode(dftPand, storm::gspn::LayoutInfo(xcenter+9.0, ycenter-3.0)); } uint64_t tNodeFailed = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILING); + builder.setTransitionLayoutInfo(tNodeFailed, storm::gspn::LayoutInfo(xcenter+3.0, ycenter+3.0)); builder.addInhibitionArc(nodeFailed, tNodeFailed); builder.addOutputArc(tNodeFailed, nodeFailed); if (!smart || isRepresentative) { builder.addOutputArc(tNodeFailed, nodeFailed); } - - + if(dftPand->isInclusive()) { - + // Inclusive PAND uint64_t nodeFS = builder.addPlace(defaultCapacity, 0, dftPand->name() + STR_FAILSAVE); + builder.setPlaceLayoutInfo(nodeFS, storm::gspn::LayoutInfo(xcenter-3.0, ycenter-3.0)); + builder.addInhibitionArc(nodeFS, tNodeFailed); for(auto const& child : dftPand->children()) { builder.addInputArc(failedNodes[child->id()], tNodeFailed); @@ -264,6 +271,8 @@ namespace storm { } for (uint64_t j = 1; j < dftPand->nrChildren(); ++j) { uint64_t tfs = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILSAVING + std::to_string(j)); + builder.setTransitionLayoutInfo(tfs, storm::gspn::LayoutInfo(xcenter-6.0+j*3.0, ycenter+3.0)); + builder.addInputArc(failedNodes[dftPand->children().at(j)->id()], tfs); builder.addOutputArc(tfs, failedNodes[dftPand->children().at(j)->id()]); builder.addInhibitionArc(failedNodes[dftPand->children().at(j-1)->id()], tfs); @@ -272,6 +281,7 @@ namespace storm { } } else { + // Exclusive PAND uint64_t fi = 0; uint64_t tn = 0; for(uint64_t j = 0; j < dftPand->nrChildren(); ++j) { @@ -281,6 +291,7 @@ namespace storm { } if (j != dftPand->nrChildren() - 1) { tn = builder.addImmediateTransition(getFailPriority(dftPand), 0.0, dftPand->name() + STR_FAILING + "_" +std::to_string(j)); + builder.setTransitionLayoutInfo(tn, storm::gspn::LayoutInfo(xcenter-3.0, ycenter+3.0)); } else { tn = tNodeFailed; } @@ -291,54 +302,128 @@ namespace storm { } if (j != dftPand->nrChildren() - 1) { fi = builder.addPlace(defaultCapacity, 0, dftPand->name() + "_F_" + std::to_string(j)); + builder.setPlaceLayoutInfo(fi, storm::gspn::LayoutInfo(xcenter-3.0+j*3.0, ycenter)); builder.addOutputArc(tn, fi); } } } } -// + + template + void DftToGspnTransformator::drawPOR(std::shared_ptr const> dftPor, bool isRepresentative) { + uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftPor->name() + STR_FAILED); + failedNodes.push_back(nodeFailed); + + double xcenter = mDft.getElementLayoutInfo(dftPor->id()).x; + double ycenter = mDft.getElementLayoutInfo(dftPor->id()).y; + builder.setPlaceLayoutInfo(nodeFailed, storm::gspn::LayoutInfo(xcenter+3.0, ycenter-3.0)); + + uint64_t unavailableNode = 0; + if (!smart || isRepresentative) { + unavailableNode = addUnavailableNode(dftPor, storm::gspn::LayoutInfo(xcenter+9.0, ycenter-3.0)); + } + + uint64_t tfail = builder.addImmediateTransition(getFailPriority(dftPor), 0.0, dftPor->name() + STR_FAILING); + builder.setTransitionLayoutInfo(tfail, storm::gspn::LayoutInfo(xcenter+3.0, ycenter+3.0)); + builder.addOutputArc(tfail, nodeFailed); + builder.addInhibitionArc(nodeFailed, tfail); + + builder.addInputArc(failedNodes.at(dftPor->children().front()->id()), tfail); + builder.addOutputArc(tfail, failedNodes.at(dftPor->children().front()->id())); + + if(!smart || isRepresentative) { + builder.addOutputArc(tfail, unavailableNode); + } + + if(dftPor->isInclusive()) { + // Inclusive POR + uint64_t nodeFS = builder.addPlace(defaultCapacity, 0, dftPor->name() + STR_FAILSAVE); + builder.setPlaceLayoutInfo(nodeFS, storm::gspn::LayoutInfo(xcenter-3.0, ycenter-3.0)); + + builder.addInhibitionArc(nodeFS, tfail); + uint64_t j = 0; + for (auto const& child : dftPor->children()) { + if(j > 0) { + uint64_t tfailsf = builder.addImmediateTransition(getFailPriority(dftPor), 0.0, dftPor->name() + STR_FAILSAVING + std::to_string(j)); + builder.setTransitionLayoutInfo(tfailsf, storm::gspn::LayoutInfo(xcenter-3.0+j*3.0, ycenter+3.0)); + builder.addInputArc(failedNodes.at(child->id()), tfailsf); + builder.addOutputArc(tfailsf, failedNodes.at(child->id())); + builder.addOutputArc(tfailsf, nodeFS); + builder.addInhibitionArc(nodeFS, tfailsf); + builder.addInhibitionArc(failedNodes.at(dftPor->children().front()->id()), tfailsf); + } + + ++j; + } + } else { + // Exclusive POR + uint64_t j = 0; + for (auto const& child : dftPor->children()) { + if(j > 0) { + builder.addInhibitionArc(failedNodes.at(child->id()), tfail); + } + ++j; + } + + } + + } + template void DftToGspnTransformator::drawSPARE(std::shared_ptr const> dftSpare, bool isRepresentative) { uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftSpare->name() + STR_FAILED); failedNodes.push_back(nodeFailed); + + double xcenter = mDft.getElementLayoutInfo(dftSpare->id()).x; + double ycenter = mDft.getElementLayoutInfo(dftSpare->id()).y; + builder.setPlaceLayoutInfo(nodeFailed, storm::gspn::LayoutInfo(xcenter+10.0, ycenter-8.0)); + uint64_t unavailableNode = 0; if (isRepresentative) { - unavailableNode = addUnavailableNode(dftSpare); + unavailableNode = addUnavailableNode(dftSpare, storm::gspn::LayoutInfo(xcenter+16.0, ycenter-8.0)); } uint64_t spareActive = builder.addPlace(defaultCapacity, 0, dftSpare->name() + STR_ACTIVATED); + builder.setPlaceLayoutInfo(spareActive, storm::gspn::LayoutInfo(xcenter-20.0, ycenter-8.0)); activeNodes.emplace(dftSpare->id(), spareActive); std::vector cucNodes; - std::vector nextClaimNodes; + std::vector considerNodes; std::vector nextclTransitions; std::vector nextconsiderTransitions; uint64_t j = 0; for(auto const& child : dftSpare->children()) { if (j > 0) { - nextClaimNodes.push_back(builder.addPlace(defaultCapacity, 0, dftSpare->name()+ "_consider_" + child->name())); - - builder.addOutputArc(nextclTransitions.back(), nextClaimNodes.back(), 1); + size_t nodeConsider = builder.addPlace(defaultCapacity, 0, dftSpare->name()+ "_consider_" + child->name()); + considerNodes.push_back(nodeConsider); + builder.setPlaceLayoutInfo(nodeConsider, storm::gspn::LayoutInfo(xcenter-15.0+j*14.0, ycenter-8.0)); + + builder.addOutputArc(nextclTransitions.back(), considerNodes.back(), 1); if (j > 1) { - builder.addOutputArc(nextconsiderTransitions.back(), nextClaimNodes.back()); + builder.addOutputArc(nextconsiderTransitions.back(), considerNodes.back()); } uint64_t tnextconsider = builder.addImmediateTransition(getFailPriority(dftSpare), 0.0, dftSpare->name() + "_cannot_claim_" + child->name()); - builder.addInputArc(nextClaimNodes.back(), tnextconsider); + builder.setTransitionLayoutInfo(tnextconsider, storm::gspn::LayoutInfo(xcenter-7.0+j*14.0, ycenter-8.0)); + builder.addInputArc(considerNodes.back(), tnextconsider); builder.addInputArc(unavailableNodes.at(child->id()), tnextconsider); nextconsiderTransitions.push_back(tnextconsider); } - cucNodes.push_back(builder.addPlace(defaultCapacity, j == 0 ? 1 : 0, dftSpare->name() + "_claimed_" + child->name())); + size_t nodeCUC = builder.addPlace(defaultCapacity, j == 0 ? 1 : 0, dftSpare->name() + "_claimed_" + child->name()); + cucNodes.push_back(nodeCUC); + builder.setPlaceLayoutInfo(nodeCUC, storm::gspn::LayoutInfo(xcenter-9.0+j*14.0, ycenter+5.0)); if (j > 0) { uint64 tclaim = builder.addImmediateTransition(getFailPriority(dftSpare), 0.0, dftSpare->name() + "_claim_" + child->name()); + builder.setTransitionLayoutInfo(tclaim, storm::gspn::LayoutInfo(xcenter-9.0+j*14.0, ycenter)); builder.addInhibitionArc(unavailableNodes.at(child->id()), tclaim); - builder.addInputArc(nextClaimNodes.back(), tclaim); + builder.addInputArc(considerNodes.back(), tclaim); builder.addOutputArc(tclaim, cucNodes.back()); } uint64_t tnextcl = builder.addImmediateTransition(getFailPriority(dftSpare), 0.0, dftSpare->name() + "_next_claim_" + std::to_string(j)); + builder.setTransitionLayoutInfo(tnextcl, storm::gspn::LayoutInfo(xcenter-3.0+j*14.0, ycenter+5.0)); builder.addInputArc(cucNodes.back(), tnextcl); builder.addOutputArc(tnextcl, cucNodes.back()); builder.addInputArc(failedNodes.at(child->id()), tnextcl); @@ -356,64 +441,14 @@ namespace storm { } -// - template - void DftToGspnTransformator::drawPOR(std::shared_ptr const> dftPor, bool isRepresentative) { - uint64_t nodeFailed = builder.addPlace(defaultCapacity, 0, dftPor->name() + STR_FAILED); - failedNodes.push_back(nodeFailed); - - uint64_t unavailableNode = 0; - if (!smart || isRepresentative) { - unavailableNode = addUnavailableNode(dftPor); - } - - uint64_t tfail = builder.addImmediateTransition(getFailPriority(dftPor), 0.0, dftPor->name() + STR_FAILING); - builder.addOutputArc(tfail, nodeFailed); - builder.addInhibitionArc(nodeFailed, tfail); - - builder.addInputArc(failedNodes.at(dftPor->children().front()->id()), tfail); - builder.addOutputArc(tfail, failedNodes.at(dftPor->children().front()->id())); - - if(!smart || isRepresentative) { - builder.addOutputArc(tfail, unavailableNode); - } - - if(dftPor->isInclusive()) { - uint64_t nodeFS = builder.addPlace(defaultCapacity, 0, dftPor->name() + STR_FAILSAVE); - builder.addInhibitionArc(nodeFS, tfail); - uint64_t j = 0; - for (auto const& child : dftPor->children()) { - if(j > 0) { - uint64_t tfailsf = builder.addImmediateTransition(getFailPriority(dftPor), 0.0, dftPor->name() + STR_FAILSAVING + std::to_string(j)); - builder.addInputArc(failedNodes.at(child->id()), tfailsf); - builder.addOutputArc(tfailsf, failedNodes.at(child->id())); - builder.addOutputArc(tfailsf, nodeFS); - builder.addInhibitionArc(nodeFS, tfailsf); - builder.addInhibitionArc(failedNodes.at(dftPor->children().front()->id()), tfailsf); - } - - ++j; - } - } else { - uint64_t j = 0; - for (auto const& child : dftPor->children()) { - if(j > 0) { - builder.addInhibitionArc(failedNodes.at(child->id()), tfail); - } - ++j; - } - - } - - } - -// + template void DftToGspnTransformator::drawCONSTF(std::shared_ptr const> dftConstF, bool isRepresentative) { failedNodes.push_back(builder.addPlace(defaultCapacity, 1, dftConstF->name() + STR_FAILED)); uint64_t unavailableNode = 0; if (isRepresentative) { - unavailableNode = addUnavailableNode(dftConstF, false); + // TODO set position + unavailableNode = addUnavailableNode(dftConstF, storm::gspn::LayoutInfo(0, 0), false); } } @@ -501,10 +536,11 @@ namespace storm { } template - uint64_t DftToGspnTransformator::addUnavailableNode(std::shared_ptr const> dftElement, bool initialAvailable) { + uint64_t DftToGspnTransformator::addUnavailableNode(std::shared_ptr const> dftElement, storm::gspn::LayoutInfo const& layoutInfo, bool initialAvailable) { uint64_t unavailableNode = builder.addPlace(defaultCapacity, initialAvailable ? 0 : 1, dftElement->name() + "_unavailable"); assert(unavailableNode != 0); unavailableNodes.emplace(dftElement->id(), unavailableNode); + builder.setPlaceLayoutInfo(unavailableNode, layoutInfo); return unavailableNode; } diff --git a/src/storm-dft/transformations/DftToGspnTransformator.h b/src/storm-dft/transformations/DftToGspnTransformator.h index 3cf5477e3..4ec911b23 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.h +++ b/src/storm-dft/transformations/DftToGspnTransformator.h @@ -136,7 +136,7 @@ namespace storm { uint64_t getFailPriority(std::shared_ptr const> dFTElement); - uint64_t addUnavailableNode(std::shared_ptr const> dftElement, bool initialAvailable = true); + uint64_t addUnavailableNode(std::shared_ptr const> dftElement, storm::gspn::LayoutInfo const& layoutInfo, bool initialAvailable = true); uint64_t addDisabledPlace(std::shared_ptr const> dftBe); From 9851100602bcaa22260127bfcb23f8713c57980e Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Thu, 15 Dec 2016 23:14:25 +0100 Subject: [PATCH 46/47] mttf --- src/storm-dft-cli/storm-dyftee.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/storm-dft-cli/storm-dyftee.cpp b/src/storm-dft-cli/storm-dyftee.cpp index 61959158a..f246438fe 100644 --- a/src/storm-dft-cli/storm-dyftee.cpp +++ b/src/storm-dft-cli/storm-dyftee.cpp @@ -157,9 +157,12 @@ int main(const int argc, const char** argv) { auto tbFormula = std::make_shared(std::make_shared(true), evtlFormula, 0.0, 10.0); auto tbUntil = std::make_shared(tbFormula); + auto evFormula = std::make_shared(evtlFormula, storm::logic::FormulaContext::Time); + auto rewFormula = std::make_shared(evFormula, storm::logic::OperatorInformation(), storm::logic::RewardMeasureType::Expectation); + storm::settings::modules::JaniExportSettings const& janiSettings = storm::settings::getModule(); if (janiSettings.isJaniFileSet()) { - storm::exportJaniModel(*model, {storm::jani::Property("time-bounded", tbUntil)}, janiSettings.getJaniFilename()); + storm::exportJaniModel(*model, {storm::jani::Property("time-bounded", tbUntil), storm::jani::Property("mttf", rewFormula)}, janiSettings.getJaniFilename()); } delete model; From 7c3649297a58c15631944531f7b9ff0dba6ca7bd Mon Sep 17 00:00:00 2001 From: Sebastian Junges Date: Thu, 15 Dec 2016 23:23:14 +0100 Subject: [PATCH 47/47] fix spares --- src/storm-dft/transformations/DftToGspnTransformator.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/storm-dft/transformations/DftToGspnTransformator.cpp b/src/storm-dft/transformations/DftToGspnTransformator.cpp index c95a7f21d..8c3ef0448 100644 --- a/src/storm-dft/transformations/DftToGspnTransformator.cpp +++ b/src/storm-dft/transformations/DftToGspnTransformator.cpp @@ -425,7 +425,6 @@ namespace storm { uint64_t tnextcl = builder.addImmediateTransition(getFailPriority(dftSpare), 0.0, dftSpare->name() + "_next_claim_" + std::to_string(j)); builder.setTransitionLayoutInfo(tnextcl, storm::gspn::LayoutInfo(xcenter-3.0+j*14.0, ycenter+5.0)); builder.addInputArc(cucNodes.back(), tnextcl); - builder.addOutputArc(tnextcl, cucNodes.back()); builder.addInputArc(failedNodes.at(child->id()), tnextcl); builder.addOutputArc(tnextcl, failedNodes.at(child->id())); nextclTransitions.push_back(tnextcl); @@ -434,6 +433,7 @@ namespace storm { uint64_t tactive = builder.addImmediateTransition(defaultPriority+1, 0.0, dftSpare->name() + "_activate_" + std::to_string(j) + "_" + std::to_string(k)); builder.addInputArc(cucNodes.back(), tactive); + builder.addOutputArc(tactive, cucNodes.back()); builder.addInputArc(spareActive, tactive); builder.addOutputArc(tactive, activeNodes.at(k)); builder.addInhibitionArc(activeNodes.at(k), tactive);