sp
/
tempest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

started to include reachability in JANI model generation 

Former-commit-id: d54f35b999
main
dehnert 9 years ago
parent
32ec106588
commit
310db8a234
10 changed files with 284 additions and 98 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 143
      src/builder/DdJaniModelBuilder.cpp
  2. 51
      src/builder/DdPrismModelBuilder.cpp
  3. 2
      src/builder/DdPrismModelBuilder.h
  4. 9
      src/parser/JaniParser.cpp
  5. 44
      src/storage/jani/Exporter.cpp
  6. 35
      src/storage/prism/Program.cpp
  7. 44
      src/utility/dd.cpp
  8. 24
      src/utility/dd.h
  9. 24
      test/functional/builder/DdJaniModelBuilderTest.cpp
  10. 6
      test/functional/builder/DdPrismModelBuilderTest.cpp

143
src/builder/DdJaniModelBuilder.cpp
View File

@ -18,9 +18,14 @@
#include "src/models/symbolic/Dtmc.h" #include "src/models/symbolic/Dtmc.h"
#include "src/models/symbolic/Ctmc.h" #include "src/models/symbolic/Ctmc.h"
#include "src/models/symbolic/Mdp.h" #include "src/models/symbolic/Mdp.h"
#include "src/models/symbolic/StandardRewardModel.h"
#include "src/settings/SettingsManager.h"
#include "src/settings/modules/MarkovChainSettings.h"
#include "src/utility/macros.h" #include "src/utility/macros.h"
#include "src/utility/jani.h" #include "src/utility/jani.h"
#include "src/utility/dd.h"
#include "src/exceptions/InvalidArgumentException.h" #include "src/exceptions/InvalidArgumentException.h"
namespace storm { namespace storm {
@ -164,7 +169,8 @@ namespace storm {
std::map<uint64_t, storm::expressions::Variable> actionVariablesMap; std::map<uint64_t, storm::expressions::Variable> actionVariablesMap;
// The meta variables used to encode the remaining nondeterminism. // The meta variables used to encode the remaining nondeterminism.
std::vector<storm::expressions::Variable> nondeterminismVariables;
std::vector<storm::expressions::Variable> orderedNondeterminismVariables;
std::set<storm::expressions::Variable> nondeterminismVariables;
// DDs representing the identity for each variable. // DDs representing the identity for each variable.
std::map<storm::expressions::Variable, storm::dd::Add<Type, ValueType>> variableToIdentityMap; std::map<storm::expressions::Variable, storm::dd::Add<Type, ValueType>> variableToIdentityMap;
@ -242,7 +248,8 @@ namespace storm {
} }
for (uint_fast64_t i = 0; i < numberOfNondeterminismVariables; ++i) { for (uint_fast64_t i = 0; i < numberOfNondeterminismVariables; ++i) {
std::pair<storm::expressions::Variable, storm::expressions::Variable> variablePair = result.manager->addMetaVariable("nondet" + std::to_string(i)); std::pair<storm::expressions::Variable, storm::expressions::Variable> variablePair = result.manager->addMetaVariable("nondet" + std::to_string(i));
result.nondeterminismVariables.push_back(variablePair.first);
result.orderedNondeterminismVariables.push_back(variablePair.first);
result.nondeterminismVariables.insert(variablePair.first);
} }
// Create global variables. // Create global variables.
@ -269,6 +276,10 @@ namespace storm {
identity &= variableIdentity.toBdd(); identity &= variableIdentity.toBdd();
range &= result.manager->getRange(variablePair.first); range &= result.manager->getRange(variablePair.first);
// Add the location variable to the row/column variables.
result.rowMetaVariables.insert(variablePair.first);
result.columnMetaVariables.insert(variablePair.second);
// Then create variables for the variables of the automaton. // Then create variables for the variables of the automaton.
for (auto const& variable : automaton.getVariables().getBoundedIntegerVariables()) { for (auto const& variable : automaton.getVariables().getBoundedIntegerVariables()) {
createVariable(variable, result); createVariable(variable, result);
@ -687,17 +698,17 @@ namespace storm {
} }
template <storm::dd::DdType Type, typename ValueType> template <storm::dd::DdType Type, typename ValueType>
storm::dd::Add<Type, ValueType> encodeIndex(uint64_t index, std::vector<storm::expressions::Variable> const& nondeterminismVariables, CompositionVariables<Type, ValueType> const& variables) {
storm::dd::Add<Type, ValueType> encodeIndex(uint64_t index, std::vector<storm::expressions::Variable> const& orderedNondeterminismVariables, CompositionVariables<Type, ValueType> const& variables) {
storm::dd::Add<Type, ValueType> result = variables.manager->template getAddZero<ValueType>(); storm::dd::Add<Type, ValueType> result = variables.manager->template getAddZero<ValueType>();
STORM_LOG_TRACE("Encoding " << index << " with " << nondeterminismVariables.size() << " binary variable(s).");
STORM_LOG_TRACE("Encoding " << index << " with " << orderedNondeterminismVariables.size() << " binary variable(s).");
std::map<storm::expressions::Variable, int_fast64_t> metaVariableNameToValueMap; std::map<storm::expressions::Variable, int_fast64_t> metaVariableNameToValueMap;
for (uint_fast64_t i = 0; i < nondeterminismVariables.size(); ++i) {
if (index & (1ull << (nondeterminismVariables.size() - i - 1))) {
metaVariableNameToValueMap.emplace(nondeterminismVariables[i], 1);
for (uint_fast64_t i = 0; i < orderedNondeterminismVariables.size(); ++i) {
if (index & (1ull << (orderedNondeterminismVariables.size() - i - 1))) {
metaVariableNameToValueMap.emplace(orderedNondeterminismVariables[i], 1);
} else { } else {
metaVariableNameToValueMap.emplace(nondeterminismVariables[i], 0);
metaVariableNameToValueMap.emplace(orderedNondeterminismVariables[i], 0);
} }
} }
@ -717,21 +728,23 @@ namespace storm {
}; };
template <storm::dd::DdType Type, typename ValueType> template <storm::dd::DdType Type, typename ValueType>
SystemDd<Type, ValueType> buildSystemDd(storm::jani::Model const& model, AutomatonDd<Type, ValueType> const& automatonDd, CompositionVariables<Type, ValueType> const& variables) {
SystemDd<Type, ValueType> buildSystemDd(storm::jani::Model const& model, AutomatonDd<Type, ValueType> const& automatonDd, CompositionVariables<Type, ValueType>& variables) {
// If the model is an MDP, we need to encode the nondeterminism using additional variables. // If the model is an MDP, we need to encode the nondeterminism using additional variables.
if (model.getModelType() == storm::jani::ModelType::MDP) { if (model.getModelType() == storm::jani::ModelType::MDP) {
// Determine how many nondeterminism variables we need. // Determine how many nondeterminism variables we need.
std::vector<storm::expressions::Variable> actionVariables;
std::vector<storm::expressions::Variable> orderedActionVariables;
std::set<storm::expressions::Variable> actionVariables;
std::map<uint64_t, uint64_t> actionIndexToVariableIndex; std::map<uint64_t, uint64_t> actionIndexToVariableIndex;
uint64_t maximalNumberOfEdgesPerAction = 0; uint64_t maximalNumberOfEdgesPerAction = 0;
for (auto const& action : automatonDd.actionIndexToEdges) { for (auto const& action : automatonDd.actionIndexToEdges) {
actionVariables.push_back(variables.actionVariablesMap.at(action.first));
actionIndexToVariableIndex[action.first] = actionVariables.size() - 1;
orderedActionVariables.push_back(variables.actionVariablesMap.at(action.first));
actionVariables.insert(orderedActionVariables.back());
actionIndexToVariableIndex[action.first] = orderedActionVariables.size() - 1;
maximalNumberOfEdgesPerAction = std::max(maximalNumberOfEdgesPerAction, static_cast<uint64_t>(action.second.size())); maximalNumberOfEdgesPerAction = std::max(maximalNumberOfEdgesPerAction, static_cast<uint64_t>(action.second.size()));
} }
uint64_t numberOfNondeterminismVariables = static_cast<uint64_t>(std::ceil(std::log2(maximalNumberOfEdgesPerAction))); uint64_t numberOfNondeterminismVariables = static_cast<uint64_t>(std::ceil(std::log2(maximalNumberOfEdgesPerAction)));
std::vector<storm::expressions::Variable> nondeterminismVariables(numberOfNondeterminismVariables);
std::copy(variables.nondeterminismVariables.begin(), variables.nondeterminismVariables.begin() + numberOfNondeterminismVariables, nondeterminismVariables.begin());
std::vector<storm::expressions::Variable> orderedNondeterminismVariables(numberOfNondeterminismVariables);
std::copy(variables.orderedNondeterminismVariables.begin(), variables.orderedNondeterminismVariables.begin() + numberOfNondeterminismVariables, orderedNondeterminismVariables.begin());
// Prepare result. // Prepare result.
storm::dd::Add<Type, ValueType> result = variables.manager->template getAddZero<ValueType>(); storm::dd::Add<Type, ValueType> result = variables.manager->template getAddZero<ValueType>();
@ -742,11 +755,11 @@ namespace storm {
uint64_t edgeIndex = 0; uint64_t edgeIndex = 0;
for (auto const& edge : action.second) { for (auto const& edge : action.second) {
edgesForAction += edge.transitionsDd * computeMissingGlobalVariableIdentities(edge, variables) * encodeIndex(edgeIndex, nondeterminismVariables, variables);
edgesForAction += edge.transitionsDd * computeMissingGlobalVariableIdentities(edge, variables) * encodeIndex(edgeIndex, orderedNondeterminismVariables, variables);
++edgeIndex; ++edgeIndex;
} }
result += edgesForAction * encodeAction<Type, ValueType>(actionIndexToVariableIndex.at(action.first), actionVariables, variables);
result += edgesForAction * encodeAction<Type, ValueType>(actionIndexToVariableIndex.at(action.first), orderedActionVariables, variables);
} }
return SystemDd<Type, ValueType>(result, result.sumAbstract(variables.columnMetaVariables), numberOfNondeterminismVariables); return SystemDd<Type, ValueType>(result, result.sumAbstract(variables.columnMetaVariables), numberOfNondeterminismVariables);
@ -780,7 +793,7 @@ namespace storm {
} else if (modelType == storm::jani::ModelType::CTMC) { } else if (modelType == storm::jani::ModelType::CTMC) {
return std::shared_ptr<storm::models::symbolic::Model<Type, ValueType>>(new storm::models::symbolic::Ctmc<Type, ValueType>(variables.manager, modelComponents.reachableStates, modelComponents.initialStates, modelComponents.transitionMatrix, variables.rowMetaVariables, variables.rowExpressionAdapter, variables.columnMetaVariables, variables.columnExpressionAdapter, variables.rowColumnMetaVariablePairs, std::map<std::string, storm::expressions::Expression>(), modelComponents.rewardModels)); return std::shared_ptr<storm::models::symbolic::Model<Type, ValueType>>(new storm::models::symbolic::Ctmc<Type, ValueType>(variables.manager, modelComponents.reachableStates, modelComponents.initialStates, modelComponents.transitionMatrix, variables.rowMetaVariables, variables.rowExpressionAdapter, variables.columnMetaVariables, variables.columnExpressionAdapter, variables.rowColumnMetaVariablePairs, std::map<std::string, storm::expressions::Expression>(), modelComponents.rewardModels));
} else if (modelType == storm::jani::ModelType::MDP) { } else if (modelType == storm::jani::ModelType::MDP) {
return std::shared_ptr<storm::models::symbolic::Model<Type, ValueType>>(new storm::models::symbolic::Mdp<Type, ValueType>(variables.manager, modelComponents.reachableStates, modelComponents.initialStates, modelComponents.transitionMatrix, variables.rowMetaVariables, variables.rowExpressionAdapter, variables.columnMetaVariables, variables.columnExpressionAdapter, variables.rowColumnMetaVariablePairs, variables.allNondeterminismVariables, std::map<std::string, storm::expressions::Expression>(), modelComponents.rewardModels));
return std::shared_ptr<storm::models::symbolic::Model<Type, ValueType>>(new storm::models::symbolic::Mdp<Type, ValueType>(variables.manager, modelComponents.reachableStates, modelComponents.initialStates, modelComponents.transitionMatrix, variables.rowMetaVariables, variables.rowExpressionAdapter, variables.columnMetaVariables, variables.columnExpressionAdapter, variables.rowColumnMetaVariablePairs, variables.nondeterminismVariables, std::map<std::string, storm::expressions::Expression>(), modelComponents.rewardModels));
} else { } else {
STORM_LOG_THROW(false, storm::exceptions::InvalidArgumentException, "Invalid model type."); STORM_LOG_THROW(false, storm::exceptions::InvalidArgumentException, "Invalid model type.");
} }
@ -788,13 +801,18 @@ namespace storm {
} }
template <storm::dd::DdType Type, typename ValueType> template <storm::dd::DdType Type, typename ValueType>
void postprocessSystemDd(storm::jani::Model const& model, SystemDd<Type, ValueType>& system, CompositionVariables<Type, ValueType> const& variables, typename DdJaniModelBuilder<Type, ValueType>::Options const& options) {
void postprocessSystemAndVariables(storm::jani::Model const& model, SystemDd<Type, ValueType>& system, CompositionVariables<Type, ValueType>& variables, typename DdJaniModelBuilder<Type, ValueType>::Options const& options) {
// Get rid of the nondeterminism variables that were not used.
for (uint64_t index = system.numberOfNondeterminismVariables; index < variables.orderedNondeterminismVariables.size(); ++index) {
variables.nondeterminismVariables.erase(variables.orderedNondeterminismVariables[index]);
}
variables.orderedNondeterminismVariables.resize(system.numberOfNondeterminismVariables);
// For DTMCs, we normalize each row to 1 (to account for non-determinism). // For DTMCs, we normalize each row to 1 (to account for non-determinism).
if (model.getModelType() == storm::jani::ModelType::DTMC) { if (model.getModelType() == storm::jani::ModelType::DTMC) {
system.transitionsDd = system.transitionsDd / system.stateActionDd; system.transitionsDd = system.transitionsDd / system.stateActionDd;
} }
// If we were asked to treat some states as terminal states, we cut away their transitions now. // If we were asked to treat some states as terminal states, we cut away their transitions now.
if (options.terminalStates || options.negatedTerminalStates) { if (options.terminalStates || options.negatedTerminalStates) {
std::map<storm::expressions::Variable, storm::expressions::Expression> constantsSubstitution = model.getConstantsSubstitution(); std::map<storm::expressions::Variable, storm::expressions::Expression> constantsSubstitution = model.getConstantsSubstitution();
@ -811,21 +829,68 @@ namespace storm {
terminalStatesBdd |= !variables.rowExpressionAdapter->translateExpression(negatedTerminalExpression).toBdd(); terminalStatesBdd |= !variables.rowExpressionAdapter->translateExpression(negatedTerminalExpression).toBdd();
} }
system.transitionMatrix *= (!terminalStatesBdd).template toAdd<ValueType>();
system.transitionsDd *= (!terminalStatesBdd).template toAdd<ValueType>();
} }
} }
template <storm::dd::DdType Type, typename ValueType> template <storm::dd::DdType Type, typename ValueType>
storm::dd::Bdd<Type> computeInitial(storm::jani::Model const& model, CompositionVariables<Type, ValueType> const& variables) {
storm::dd::Bdd<Type> initialStates = variables.rowExpressionAdapter->translateExpression( generationInfo.program.getInitialConstruct().getInitialStatesExpression()).toBdd();
for (auto const& metaVariable : generationInfo.rowMetaVariables) {
initialStates &= generationInfo.manager->getRange(metaVariable);
storm::dd::Bdd<Type> computeInitialStates(storm::jani::Model const& model, CompositionVariables<Type, ValueType> const& variables) {
storm::dd::Bdd<Type> initialStates = variables.rowExpressionAdapter->translateExpression(model.getInitialStatesExpression(true)).toBdd();
for (auto const& automaton : model.getAutomata()) {
initialStates &= variables.manager->getEncoding(variables.automatonToLocationVariableMap.at(automaton.getName()).first, automaton.getInitialLocationIndex());
}
for (auto const& metaVariable : variables.rowMetaVariables) {
initialStates &= variables.manager->getRange(metaVariable);
} }
return initialStates; return initialStates;
} }
template <storm::dd::DdType Type, typename ValueType>
void fixDeadlocks(storm::jani::ModelType const& modelType, storm::dd::Add<Type, ValueType>& transitionMatrix, storm::dd::Bdd<Type> const& transitionMatrixBdd, storm::dd::Bdd<Type> const& reachableStates, CompositionVariables<Type, ValueType> const& variables) {
// Detect deadlocks and 1) fix them if requested 2) throw an error otherwise.
storm::dd::Bdd<Type> statesWithTransition = transitionMatrixBdd.existsAbstract(variables.columnMetaVariables);
storm::dd::Add<Type, ValueType> deadlockStates = (reachableStates && !statesWithTransition).template toAdd<ValueType>();
if (!deadlockStates.isZero()) {
// If we need to fix deadlocks, we do so now.
if (!storm::settings::getModule<storm::settings::modules::MarkovChainSettings>().isDontFixDeadlocksSet()) {
STORM_LOG_INFO("Fixing deadlocks in " << deadlockStates.getNonZeroCount() << " states. The first three of these states are: ");
uint_fast64_t count = 0;
for (auto it = deadlockStates.begin(), ite = deadlockStates.end(); it != ite && count < 3; ++it, ++count) {
STORM_LOG_INFO((*it).first.toPrettyString(variables.rowMetaVariables) << std::endl);
}
// Create a global identity DD.
storm::dd::Add<Type, ValueType> globalIdentity = variables.manager->template getAddOne<ValueType>();
for (auto const& identity : variables.automatonToIdentityMap) {
globalIdentity *= identity.second;
}
for (auto const& variable : variables.allGlobalVariables) {
globalIdentity *= variables.variableToIdentityMap.at(variable);
}
if (modelType == storm::jani::ModelType::DTMC || modelType == storm::jani::ModelType::CTMC) {
// For DTMCs, we can simply add the identity of the global module for all deadlock states.
transitionMatrix += deadlockStates * globalIdentity;
} else if (modelType == storm::jani::ModelType::MDP) {
// For MDPs, however, we need to select an action associated with the self-loop, if we do not
// want to attach a lot of self-loops to the deadlock states.
storm::dd::Add<Type, ValueType> action = variables.manager->template getAddOne<ValueType>();
for (auto const& variable : variables.actionVariablesMap) {
action *= variables.manager->template getIdentity<ValueType>(variable.second);
}
for (auto const& variable : variables.orderedNondeterminismVariables) {
action *= variables.manager->template getIdentity<ValueType>(variable);
}
transitionMatrix += deadlockStates * globalIdentity * action;
}
} else {
STORM_LOG_THROW(false, storm::exceptions::InvalidArgumentException, "The model contains " << deadlockStates.getNonZeroCount() << " deadlock states. Please unset the option to not fix deadlocks, if you want to fix them automatically.");
}
}
}
template <storm::dd::DdType Type, typename ValueType> template <storm::dd::DdType Type, typename ValueType>
std::shared_ptr<storm::models::symbolic::Model<Type, ValueType>> DdJaniModelBuilder<Type, ValueType>::translate() { std::shared_ptr<storm::models::symbolic::Model<Type, ValueType>> DdJaniModelBuilder<Type, ValueType>::translate() {
// Create all necessary variables. // Create all necessary variables.
@ -840,12 +905,34 @@ namespace storm {
SystemDd<Type, ValueType> system = buildSystemDd(*this->model, globalAutomaton, variables); SystemDd<Type, ValueType> system = buildSystemDd(*this->model, globalAutomaton, variables);
// Postprocess the system. This modifies the systemDd in place. // Postprocess the system. This modifies the systemDd in place.
postprocessSystemDd(*this->model, system, variables, options);
postprocessSystemAndVariables(*this->model, system, variables, options);
// Start creating the model components.
ModelComponents<Type, ValueType> modelComponents; ModelComponents<Type, ValueType> modelComponents;
// Build initial states.
modelComponents.initialStates = computeInitialStates(*this->model, variables);
// Perform reachability analysis to obtain reachable states.
storm::dd::Bdd<Type> transitionMatrixBdd = system.transitionsDd.notZero();
if (this->model->getModelType() == storm::jani::ModelType::MDP) {
transitionMatrixBdd = transitionMatrixBdd.existsAbstract(variables.nondeterminismVariables);
}
transitionMatrixBdd.template toAdd<ValueType>().exportToDot("trans_before_reach.dot");
modelComponents.initialStates.template toAdd<ValueType>().exportToDot("initial.dot");
modelComponents.reachableStates = storm::utility::dd::computeReachableStates(modelComponents.initialStates, transitionMatrixBdd, variables.rowMetaVariables, variables.columnMetaVariables);
modelComponents.reachableStates.template toAdd<ValueType>().exportToDot("reach.dot");
// Cut transitions to reachable states.
storm::dd::Add<Type, ValueType> reachableStatesAdd = modelComponents.reachableStates.template toAdd<ValueType>();
modelComponents.transitionMatrix = system.transitionsDd * reachableStatesAdd;
system.transitionsDd.exportToDot("trans_full.dot");
system.stateActionDd *= reachableStatesAdd;
// Fix deadlocks if existing.
// fixDeadlocks(this->model->getModelType(), modelComponents.transitionMatrix, transitionMatrixBdd, modelComponents.reachableStates, variables);
// Finally, create the model.
return createModel(this->model->getModelType(), variables, modelComponents); return createModel(this->model->getModelType(), variables, modelComponents);
} }

51
src/builder/DdPrismModelBuilder.cpp
View File

@ -7,7 +7,6 @@
#include "src/models/symbolic/Mdp.h" #include "src/models/symbolic/Mdp.h"
#include "src/models/symbolic/StandardRewardModel.h" #include "src/models/symbolic/StandardRewardModel.h"
#include "src/storage/dd/DdManager.h"
#include "src/settings/SettingsManager.h" #include "src/settings/SettingsManager.h"
#include "src/exceptions/InvalidStateException.h" #include "src/exceptions/InvalidStateException.h"
@ -16,9 +15,11 @@
#include "src/utility/prism.h" #include "src/utility/prism.h"
#include "src/utility/math.h" #include "src/utility/math.h"
#include "src/utility/dd.h"
#include "src/storage/dd/DdManager.h"
#include "src/storage/prism/Program.h" #include "src/storage/prism/Program.h"
#include "src/storage/prism/Compositions.h" #include "src/storage/prism/Compositions.h"
#include "src/storage/dd/Add.h" #include "src/storage/dd/Add.h"
#include "src/storage/dd/cudd/CuddAddIterator.h" #include "src/storage/dd/cudd/CuddAddIterator.h"
#include "src/storage/dd/Bdd.h" #include "src/storage/dd/Bdd.h"
@ -1328,7 +1329,7 @@ namespace storm {
transitionMatrixBdd = transitionMatrixBdd.existsAbstract(generationInfo.allNondeterminismVariables); transitionMatrixBdd = transitionMatrixBdd.existsAbstract(generationInfo.allNondeterminismVariables);
} }
storm::dd::Bdd<Type> reachableStates = computeReachableStates(generationInfo, initialStates, transitionMatrixBdd);
storm::dd::Bdd<Type> reachableStates = storm::utility::dd::computeReachableStates<Type>(initialStates, transitionMatrixBdd, generationInfo.rowMetaVariables, generationInfo.columnMetaVariables);
storm::dd::Add<Type, ValueType> reachableStatesAdd = reachableStates.template toAdd<ValueType>(); storm::dd::Add<Type, ValueType> reachableStatesAdd = reachableStates.template toAdd<ValueType>();
transitionMatrix *= reachableStatesAdd; transitionMatrix *= reachableStatesAdd;
stateActionDd *= reachableStatesAdd; stateActionDd *= reachableStatesAdd;
@ -1347,17 +1348,23 @@ namespace storm {
STORM_LOG_INFO((*it).first.toPrettyString(generationInfo.rowMetaVariables) << std::endl); STORM_LOG_INFO((*it).first.toPrettyString(generationInfo.rowMetaVariables) << std::endl);
} }
if (program.getModelType() == storm::prism::Program::ModelType::DTMC) {
if (program.getModelType() == storm::prism::Program::ModelType::DTMC || program.getModelType() == storm::prism::Program::ModelType::CTMC) {
storm::dd::Add<Type, ValueType> identity = globalModule.identity;
// Make sure that global variables do not change along the introduced self-loops.
for (auto const& var : generationInfo.allGlobalVariables) {
identity *= generationInfo.variableToIdentityMap.at(var);
}
// For DTMCs, we can simply add the identity of the global module for all deadlock states. // For DTMCs, we can simply add the identity of the global module for all deadlock states.
transitionMatrix += deadlockStates * globalModule.identity;
transitionMatrix += deadlockStates * identity;
} else if (program.getModelType() == storm::prism::Program::ModelType::MDP) { } else if (program.getModelType() == storm::prism::Program::ModelType::MDP) {
// For MDPs, however, we need to select an action associated with the self-loop, if we do not // For MDPs, however, we need to select an action associated with the self-loop, if we do not
// want to attach a lot of self-loops to the deadlock states. // want to attach a lot of self-loops to the deadlock states.
storm::dd::Add<Type, ValueType> action = generationInfo.manager->template getAddOne<ValueType>(); storm::dd::Add<Type, ValueType> action = generationInfo.manager->template getAddOne<ValueType>();
std::for_each(generationInfo.allNondeterminismVariables.begin(), generationInfo.allNondeterminismVariables.end(),
[&action, &generationInfo] (storm::expressions::Variable const& metaVariable) {
action *= generationInfo.manager->template getIdentity<ValueType>(metaVariable);
});
for (auto const& metaVariable : generationInfo.allNondeterminismVariables) {
action *= generationInfo.manager->template getIdentity<ValueType>(metaVariable);
}
// Make sure that global variables do not change along the introduced self-loops. // Make sure that global variables do not change along the introduced self-loops.
for (auto const& var : generationInfo.allGlobalVariables) { for (auto const& var : generationInfo.allGlobalVariables) {
action *= generationInfo.variableToIdentityMap.at(var); action *= generationInfo.variableToIdentityMap.at(var);
@ -1421,32 +1428,6 @@ namespace storm {
return initialStates; return initialStates;
} }
template <storm::dd::DdType Type, typename ValueType>
storm::dd::Bdd<Type> DdPrismModelBuilder<Type, ValueType>::computeReachableStates(GenerationInformation& generationInfo, storm::dd::Bdd<Type> const& initialStates, storm::dd::Bdd<Type> const& transitionBdd) {
storm::dd::Bdd<Type> reachableStates = initialStates;
// Perform the BFS to discover all reachable states.
bool changed = true;
uint_fast64_t iteration = 0;
do {
STORM_LOG_TRACE("Iteration " << iteration << " of reachability analysis.");
changed = false;
storm::dd::Bdd<Type> tmp = reachableStates.relationalProduct(transitionBdd, generationInfo.rowMetaVariables, generationInfo.columnMetaVariables);
storm::dd::Bdd<Type> newReachableStates = tmp && (!reachableStates);
// Check whether new states were indeed discovered.
if (!newReachableStates.isZero()) {
changed = true;
}
reachableStates |= newReachableStates;
++iteration;
} while (changed);
return reachableStates;
}
// Explicitly instantiate the symbolic model builder. // Explicitly instantiate the symbolic model builder.
template class DdPrismModelBuilder<storm::dd::DdType::CUDD>; template class DdPrismModelBuilder<storm::dd::DdType::CUDD>;
template class DdPrismModelBuilder<storm::dd::DdType::Sylvan>; template class DdPrismModelBuilder<storm::dd::DdType::Sylvan>;

2
src/builder/DdPrismModelBuilder.h
View File

@ -256,8 +256,6 @@ namespace storm {
static SystemResult createSystemDecisionDiagram(GenerationInformation& generationInfo); static SystemResult createSystemDecisionDiagram(GenerationInformation& generationInfo);
static storm::dd::Bdd<Type> createInitialStatesDecisionDiagram(GenerationInformation& generationInfo); static storm::dd::Bdd<Type> createInitialStatesDecisionDiagram(GenerationInformation& generationInfo);
static storm::dd::Bdd<Type> computeReachableStates(GenerationInformation& generationInfo, storm::dd::Bdd<Type> const& initialStates, storm::dd::Bdd<Type> const& transitions);
// This member holds the program that was most recently translated (if any). // This member holds the program that was most recently translated (if any).
boost::optional<storm::prism::Program> preparedProgram; boost::optional<storm::prism::Program> preparedProgram;

9
src/parser/JaniParser.cpp
View File

@ -104,10 +104,12 @@ namespace storm {
// TODO something. // TODO something.
} else if(variableStructure.at("type") == "bool") { } else if(variableStructure.at("type") == "bool") {
STORM_LOG_THROW(initExpr.hasBooleanType(), storm::exceptions::InvalidJaniException, "Initial value for Boolean variable " << name << " (scope: " << scopeDescription << ") should have Boolean type."); STORM_LOG_THROW(initExpr.hasBooleanType(), storm::exceptions::InvalidJaniException, "Initial value for Boolean variable " << name << " (scope: " << scopeDescription << ") should have Boolean type.");
return std::make_shared<storm::jani::BooleanVariable>(name, expressionManager->declareBooleanVariable(exprManagerName), initExpr);
// TODO: reenable and put initExpr in the place where it belongs.
// return std::make_shared<storm::jani::BooleanVariable>(name, expressionManager->declareBooleanVariable(exprManagerName), initExpr);
} else if(variableStructure.at("type") == "int") { } else if(variableStructure.at("type") == "int") {
STORM_LOG_THROW(initExpr.hasIntegerType(), storm::exceptions::InvalidJaniException, "Initial value for interger variable " << name << " (scope: " << scopeDescription << ") should have integer type."); STORM_LOG_THROW(initExpr.hasIntegerType(), storm::exceptions::InvalidJaniException, "Initial value for interger variable " << name << " (scope: " << scopeDescription << ") should have integer type.");
return std::make_shared<storm::jani::UnboundedIntegerVariable>(name, expressionManager->declareIntegerVariable(exprManagerName), initExpr);
// TODO: reenable and put initExpr in the place where it belongs.
// return std::make_shared<storm::jani::UnboundedIntegerVariable>(name, expressionManager->declareIntegerVariable(exprManagerName), initExpr);
} else { } else {
// TODO clocks. // TODO clocks.
STORM_LOG_THROW(false, storm::exceptions::InvalidJaniException, "Unknown type description " << variableStructure.at("type").dump() << " for Variable '" << name << "' (scope: " << scopeDescription << ")"); STORM_LOG_THROW(false, storm::exceptions::InvalidJaniException, "Unknown type description " << variableStructure.at("type").dump() << " for Variable '" << name << "' (scope: " << scopeDescription << ")");
@ -129,7 +131,8 @@ namespace storm {
if(basictype == "int") { if(basictype == "int") {
STORM_LOG_THROW(lowerboundExpr.hasIntegerType(), storm::exceptions::InvalidJaniException, "Lower bound for bounded integer variable " << name << "(scope: " << scopeDescription << ") must be integer-typed"); STORM_LOG_THROW(lowerboundExpr.hasIntegerType(), storm::exceptions::InvalidJaniException, "Lower bound for bounded integer variable " << name << "(scope: " << scopeDescription << ") must be integer-typed");
STORM_LOG_THROW(upperboundExpr.hasIntegerType(), storm::exceptions::InvalidJaniException, "Upper bound for bounded integer variable " << name << "(scope: " << scopeDescription << ") must be integer-typed"); STORM_LOG_THROW(upperboundExpr.hasIntegerType(), storm::exceptions::InvalidJaniException, "Upper bound for bounded integer variable " << name << "(scope: " << scopeDescription << ") must be integer-typed");
return std::make_shared<storm::jani::BoundedIntegerVariable>(name, expressionManager->declareIntegerVariable(exprManagerName), lowerboundExpr, upperboundExpr, initExpr);
// TODO: reenable and put initExpr in the place where it belongs.
// return std::make_shared<storm::jani::BoundedIntegerVariable>(name, expressionManager->declareIntegerVariable(exprManagerName), lowerboundExpr, upperboundExpr, initExpr);
} else { } else {
STORM_LOG_THROW(false, storm::exceptions::InvalidJaniException, "Unsupported base " << basictype << " for bounded variable " << name << "(scope: " << scopeDescription << ") "); STORM_LOG_THROW(false, storm::exceptions::InvalidJaniException, "Unsupported base " << basictype << " for bounded variable " << name << "(scope: " << scopeDescription << ") ");
} }

44
src/storage/jani/Exporter.cpp
View File

@ -88,10 +88,6 @@ namespace storm {
out << ","; out << ",";
clearLine(out); clearLine(out);
appendIndent(out, indent); appendIndent(out, indent);
appendField(out, "initial-value");
appendValue(out, expressionToString(variable.getInitialValue()));
clearLine(out);
appendIndent(out, indent);
out << "}"; out << "}";
} }
@ -137,10 +133,6 @@ namespace storm {
appendBoundedIntegerVariableType(out, variable, indent + 2); appendBoundedIntegerVariableType(out, variable, indent + 2);
out << ","; out << ",";
clearLine(out); clearLine(out);
appendIndent(out, indent + 1);
appendField(out, "initial-value");
appendValue(out, expressionToString(variable.getInitialValue()));
clearLine(out);
appendIndent(out, indent); appendIndent(out, indent);
out << "}"; out << "}";
} }
@ -159,10 +151,6 @@ namespace storm {
appendValue(out, "int"); appendValue(out, "int");
out << ","; out << ",";
clearLine(out); clearLine(out);
appendIndent(out, indent + 1);
appendField(out, "initial-value");
appendValue(out, expressionToString(variable.getInitialValue()));
clearLine(out);
appendIndent(out, indent); appendIndent(out, indent);
out << "}"; out << "}";
} }
@ -359,6 +347,21 @@ namespace storm {
appendField(out, "initial-location"); appendField(out, "initial-location");
appendValue(out, std::to_string(automaton.getInitialLocationIndex())); appendValue(out, std::to_string(automaton.getInitialLocationIndex()));
clearLine(out); clearLine(out);
if (automaton.hasInitialStatesExpression()) {
appendIndent(out, indent + 1);
appendField(out, "initial-states");
clearLine(out);
appendIndent(out, indent + 2);
out << "{";
clearLine(out);
appendIndent(out, indent + 3);
appendField(out, "exp");
appendValue(out, expressionToString(automaton.getInitialStatesExpression()));
clearLine(out);
appendIndent(out, indent + 2);
out << "}";
clearLine(out);
}
appendEdges(out, model, automaton, indent + 1); appendEdges(out, model, automaton, indent + 1);
@ -401,6 +404,23 @@ namespace storm {
clearLine(out); clearLine(out);
appendVariables(out, model.getGlobalVariables(), 1); appendVariables(out, model.getGlobalVariables(), 1);
clearLine(out); clearLine(out);
if (model.hasInitialStatesExpression()) {
appendIndent(out, 1);
appendField(out, "initial-states");
clearLine(out);
appendIndent(out, 2);
out << "{";
clearLine(out);
appendIndent(out, 3);
appendField(out, "exp");
appendValue(out, expressionToString(model.getInitialStatesExpression()));
clearLine(out);
appendIndent(out, 2);
out << "}";
clearLine(out);
}
appendAutomata(out, model, 1); appendAutomata(out, model, 1);
clearLine(out); clearLine(out);
out << "}" << std::endl; out << "}" << std::endl;

35
src/storage/prism/Program.cpp
View File

@ -1494,7 +1494,8 @@ namespace storm {
default: modelType = storm::jani::ModelType::UNDEFINED; default: modelType = storm::jani::ModelType::UNDEFINED;
} }
storm::jani::Model janiModel("jani_from_prism", modelType, 1, manager); storm::jani::Model janiModel("jani_from_prism", modelType, 1, manager);
storm::expressions::Expression globalInitialStatesExpression;
// Add all constants of the PRISM program to the JANI model. // Add all constants of the PRISM program to the JANI model.
for (auto const& constant : constants) { for (auto const& constant : constants) {
janiModel.addConstant(storm::jani::Constant(constant.getName(), constant.getExpressionVariable(), constant.isDefined() ? boost::optional<storm::expressions::Expression>(constant.getExpression()) : boost::none)); janiModel.addConstant(storm::jani::Constant(constant.getName(), constant.getExpressionVariable(), constant.isDefined() ? boost::optional<storm::expressions::Expression>(constant.getExpression()) : boost::none));
@ -1502,10 +1503,14 @@ namespace storm {
// Add all global variables of the PRISM program to the JANI model. // Add all global variables of the PRISM program to the JANI model.
for (auto const& variable : globalBooleanVariables) { for (auto const& variable : globalBooleanVariables) {
janiModel.addBooleanVariable(storm::jani::BooleanVariable(variable.getName(), variable.getExpressionVariable(), variable.getInitialValueExpression()));
janiModel.addBooleanVariable(storm::jani::BooleanVariable(variable.getName(), variable.getExpressionVariable()));
storm::expressions::Expression variableInitialExpression = storm::expressions::iff(variable.getExpressionVariable(), variable.getInitialValueExpression());
globalInitialStatesExpression = globalInitialStatesExpression.isInitialized() ? globalInitialStatesExpression && variableInitialExpression : variableInitialExpression;
} }
for (auto const& variable : globalIntegerVariables) { for (auto const& variable : globalIntegerVariables) {
janiModel.addBoundedIntegerVariable(storm::jani::BoundedIntegerVariable(variable.getName(), variable.getExpressionVariable(), variable.getLowerBoundExpression(), variable.getUpperBoundExpression(), variable.getInitialValueExpression()));
janiModel.addBoundedIntegerVariable(storm::jani::BoundedIntegerVariable(variable.getName(), variable.getExpressionVariable(), variable.getLowerBoundExpression(), variable.getUpperBoundExpression()));
storm::expressions::Expression variableInitialExpression = variable.getExpressionVariable() == variable.getInitialValueExpression();
globalInitialStatesExpression = globalInitialStatesExpression.isInitialized() ? globalInitialStatesExpression && variableInitialExpression : variableInitialExpression;
} }
// Add all actions of the PRISM program to the JANI model. // Add all actions of the PRISM program to the JANI model.
@ -1545,29 +1550,42 @@ namespace storm {
// previously built mapping to make variables global that are read by more than one module. // previously built mapping to make variables global that are read by more than one module.
for (auto const& module : modules) { for (auto const& module : modules) {
storm::jani::Automaton automaton(module.getName()); storm::jani::Automaton automaton(module.getName());
storm::expressions::Expression initialStatesExpression;
for (auto const& variable : module.getBooleanVariables()) { for (auto const& variable : module.getBooleanVariables()) {
storm::jani::BooleanVariable newBooleanVariable(variable.getName(), variable.getExpressionVariable(), variable.getInitialValueExpression());
storm::jani::BooleanVariable newBooleanVariable(variable.getName(), variable.getExpressionVariable());
std::set<uint_fast64_t> const& accessingModuleIndices = variablesToAccessingModuleIndices[variable.getExpressionVariable()]; std::set<uint_fast64_t> const& accessingModuleIndices = variablesToAccessingModuleIndices[variable.getExpressionVariable()];
// If there is exactly one module reading and writing the variable, we can make the variable local to this module. // If there is exactly one module reading and writing the variable, we can make the variable local to this module.
if (accessingModuleIndices.size() == 1) { if (accessingModuleIndices.size() == 1) {
automaton.addBooleanVariable(newBooleanVariable); automaton.addBooleanVariable(newBooleanVariable);
} else { // if (accessingModuleIndices.size() > 1) {
storm::expressions::Expression variableInitialExpression = storm::expressions::iff(variable.getExpressionVariable(), variable.getInitialValueExpression());
initialStatesExpression = initialStatesExpression.isInitialized() ? initialStatesExpression && variableInitialExpression : variableInitialExpression;
} else if (accessingModuleIndices.size() > 1) {
// Otherwise, we need to make it global. // Otherwise, we need to make it global.
janiModel.addBooleanVariable(newBooleanVariable); janiModel.addBooleanVariable(newBooleanVariable);
storm::expressions::Expression variableInitialExpression = storm::expressions::iff(variable.getExpressionVariable(), variable.getInitialValueExpression());
globalInitialStatesExpression = globalInitialStatesExpression.isInitialized() ? globalInitialStatesExpression && variableInitialExpression : variableInitialExpression;
} }
} }
for (auto const& variable : module.getIntegerVariables()) { for (auto const& variable : module.getIntegerVariables()) {
storm::jani::BoundedIntegerVariable newIntegerVariable(variable.getName(), variable.getExpressionVariable(), variable.getLowerBoundExpression(), variable.getUpperBoundExpression(), variable.getInitialValueExpression());
storm::jani::BoundedIntegerVariable newIntegerVariable(variable.getName(), variable.getExpressionVariable(), variable.getLowerBoundExpression(), variable.getUpperBoundExpression());
std::set<uint_fast64_t> const& accessingModuleIndices = variablesToAccessingModuleIndices[variable.getExpressionVariable()]; std::set<uint_fast64_t> const& accessingModuleIndices = variablesToAccessingModuleIndices[variable.getExpressionVariable()];
// If there is exactly one module reading and writing the variable, we can make the variable local to this module. // If there is exactly one module reading and writing the variable, we can make the variable local to this module.
if (accessingModuleIndices.size() == 1) { if (accessingModuleIndices.size() == 1) {
automaton.addBoundedIntegerVariable(newIntegerVariable); automaton.addBoundedIntegerVariable(newIntegerVariable);
} else { //if (accessingModuleIndices.size() > 1) {
storm::expressions::Expression variableInitialExpression = variable.getExpressionVariable() == variable.getInitialValueExpression();
initialStatesExpression = initialStatesExpression.isInitialized() ? initialStatesExpression && variableInitialExpression : variableInitialExpression;
} else if (accessingModuleIndices.size() > 1) {
// Otherwise, we need to make it global. // Otherwise, we need to make it global.
janiModel.addBoundedIntegerVariable(newIntegerVariable); janiModel.addBoundedIntegerVariable(newIntegerVariable);
storm::expressions::Expression variableInitialExpression = variable.getExpressionVariable() == variable.getInitialValueExpression();
globalInitialStatesExpression = globalInitialStatesExpression.isInitialized() ? globalInitialStatesExpression && variableInitialExpression : variableInitialExpression;
} }
} }
// Set the proper expression characterizing the initial values of the automaton's variables.
automaton.setInitialStatesExpression(initialStatesExpression);
// Create a single location that will have all the edges. // Create a single location that will have all the edges.
uint64_t onlyLocation = automaton.addLocation(storm::jani::Location("l")); uint64_t onlyLocation = automaton.addLocation(storm::jani::Location("l"));
automaton.setInitialLocation(onlyLocation); automaton.setInitialLocation(onlyLocation);
@ -1603,6 +1621,9 @@ namespace storm {
janiModel.addAutomaton(automaton); janiModel.addAutomaton(automaton);
} }
// Set the proper expression characterizing the initial values of the global variables.
janiModel.setInitialStatesExpression(globalInitialStatesExpression);
// Set the standard system composition. This is possible, because we reject non-standard compositions anyway. // Set the standard system composition. This is possible, because we reject non-standard compositions anyway.
janiModel.setSystemComposition(janiModel.getStandardSystemComposition()); janiModel.setSystemComposition(janiModel.getStandardSystemComposition());

44
src/utility/dd.cpp
View File

@ -0,0 +1,44 @@
#include "src/utility/dd.h"
#include "src/storage/dd/Add.h"
#include "src/storage/dd/Bdd.h"
#include "src/utility/macros.h"
namespace storm {
namespace utility {
namespace dd {
template <storm::dd::DdType Type>
storm::dd::Bdd<Type> computeReachableStates(storm::dd::Bdd<Type> const& initialStates, storm::dd::Bdd<Type> const& transitions, std::set<storm::expressions::Variable> const& rowMetaVariables, std::set<storm::expressions::Variable> const& columnMetaVariables) {
storm::dd::Bdd<Type> reachableStates = initialStates;
// Perform the BFS to discover all reachable states.
bool changed = true;
uint_fast64_t iteration = 0;
do {
STORM_LOG_TRACE("Iteration " << iteration << " of reachability analysis.");
changed = false;
storm::dd::Bdd<Type> tmp = reachableStates.relationalProduct(transitions, rowMetaVariables, columnMetaVariables);
storm::dd::Bdd<Type> newReachableStates = tmp && (!reachableStates);
// Check whether new states were indeed discovered.
if (!newReachableStates.isZero()) {
changed = true;
}
reachableStates |= newReachableStates;
++iteration;
} while (changed);
return reachableStates;
}
template storm::dd::Bdd<storm::dd::DdType::CUDD> computeReachableStates(storm::dd::Bdd<storm::dd::DdType::CUDD> const& initialStates, storm::dd::Bdd<storm::dd::DdType::CUDD> const& transitions, std::set<storm::expressions::Variable> const& rowMetaVariables, std::set<storm::expressions::Variable> const& columnMetaVariables);
template storm::dd::Bdd<storm::dd::DdType::Sylvan> computeReachableStates(storm::dd::Bdd<storm::dd::DdType::Sylvan> const& initialStates, storm::dd::Bdd<storm::dd::DdType::Sylvan> const& transitions, std::set<storm::expressions::Variable> const& rowMetaVariables, std::set<storm::expressions::Variable> const& columnMetaVariables);
}
}
}

24
src/utility/dd.h
View File

@ -0,0 +1,24 @@
#pragma once
#include <set>
#include "src/storage/dd/DdType.h"
namespace storm {
namespace expressions {
class Variable;
}
namespace dd {
template<storm::dd::DdType Type>
class Bdd;
}
namespace utility {
namespace dd {
template <storm::dd::DdType Type>
storm::dd::Bdd<Type> computeReachableStates(storm::dd::Bdd<Type> const& initialStates, storm::dd::Bdd<Type> const& transitions, std::set<storm::expressions::Variable> const& rowMetaVariables, std::set<storm::expressions::Variable> const& columnMetaVariables);
}
}
}

24
test/functional/builder/DdJaniModelBuilderTest.cpp
View File

@ -76,8 +76,12 @@ TEST(DdJaniModelBuilderTest_Cudd, Dtmc) {
auto t2 = std::chrono::high_resolution_clock::now(); auto t2 = std::chrono::high_resolution_clock::now();
std::cout << "die: " << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count() << std::endl; std::cout << "die: " << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count() << std::endl;
// EXPECT_EQ(13ul, model->getNumberOfStates());
// EXPECT_EQ(20ul, model->getNumberOfTransitions());
model->getTransitionMatrix().exportToDot("trans.dot");
std::cout << "nnz: " << model->getTransitionMatrix().getNonZeroCount() << std::endl;
std::cout << "nodes: " << model->getTransitionMatrix().getNodeCount() << std::endl;
std::cout << "vars: " << model->getTransitionMatrix().getContainedMetaVariables().size() << std::endl;
EXPECT_EQ(13ul, model->getNumberOfStates());
EXPECT_EQ(20ul, model->getNumberOfTransitions());
program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/brp-16-2.pm"); program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/brp-16-2.pm");
janiModel = program.toJani(); janiModel = program.toJani();
@ -86,8 +90,8 @@ TEST(DdJaniModelBuilderTest_Cudd, Dtmc) {
model = builder.translate(); model = builder.translate();
t2 = std::chrono::high_resolution_clock::now(); t2 = std::chrono::high_resolution_clock::now();
std::cout << "brp: " << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count() << std::endl; std::cout << "brp: " << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count() << std::endl;
// EXPECT_EQ(677ul, model->getNumberOfStates());
// EXPECT_EQ(867ul, model->getNumberOfTransitions());
EXPECT_EQ(677ul, model->getNumberOfStates());
EXPECT_EQ(867ul, model->getNumberOfTransitions());
program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/crowds-5-5.pm"); program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/crowds-5-5.pm");
janiModel = program.toJani(); janiModel = program.toJani();
@ -96,8 +100,8 @@ TEST(DdJaniModelBuilderTest_Cudd, Dtmc) {
model = builder.translate(); model = builder.translate();
t2 = std::chrono::high_resolution_clock::now(); t2 = std::chrono::high_resolution_clock::now();
std::cout << "crowds: " << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count() << std::endl; std::cout << "crowds: " << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count() << std::endl;
// EXPECT_EQ(8607ul, model->getNumberOfStates());
// EXPECT_EQ(15113ul, model->getNumberOfTransitions());
EXPECT_EQ(8607ul, model->getNumberOfStates());
EXPECT_EQ(15113ul, model->getNumberOfTransitions());
program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/leader-3-5.pm"); program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/leader-3-5.pm");
janiModel = program.toJani(); janiModel = program.toJani();
@ -106,8 +110,8 @@ TEST(DdJaniModelBuilderTest_Cudd, Dtmc) {
model = builder.translate(); model = builder.translate();
t2 = std::chrono::high_resolution_clock::now(); t2 = std::chrono::high_resolution_clock::now();
std::cout << "lead: " << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count() << std::endl; std::cout << "lead: " << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count() << std::endl;
// EXPECT_EQ(273ul, model->getNumberOfStates());
// EXPECT_EQ(397ul, model->getNumberOfTransitions());
EXPECT_EQ(273ul, model->getNumberOfStates());
EXPECT_EQ(397ul, model->getNumberOfTransitions());
program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/nand-5-2.pm"); program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/nand-5-2.pm");
janiModel = program.toJani(); janiModel = program.toJani();
@ -116,8 +120,8 @@ TEST(DdJaniModelBuilderTest_Cudd, Dtmc) {
model = builder.translate(); model = builder.translate();
t2 = std::chrono::high_resolution_clock::now(); t2 = std::chrono::high_resolution_clock::now();
std::cout << "nand: " << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count() << std::endl; std::cout << "nand: " << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count() << std::endl;
// EXPECT_EQ(1728ul, model->getNumberOfStates());
// EXPECT_EQ(2505ul, model->getNumberOfTransitions());
EXPECT_EQ(1728ul, model->getNumberOfStates());
EXPECT_EQ(2505ul, model->getNumberOfTransitions());
} }
//TEST(DdPrismModelBuilderTest_Cudd, Dtmc) { //TEST(DdPrismModelBuilderTest_Cudd, Dtmc) {

6
test/functional/builder/DdPrismModelBuilderTest.cpp
View File

@ -57,9 +57,13 @@ TEST(DdPrismModelBuilderTest_Cudd, Dtmc) {
storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/die.pm"); storm::prism::Program program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/die.pm");
std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().translateProgram(program); std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().translateProgram(program);
model->getTransitionMatrix().exportToDot("trans_prism.dot");
std::cout << "nnz: " << model->getTransitionMatrix().getNonZeroCount() << std::endl;
std::cout << "nodes: " << model->getTransitionMatrix().getNodeCount() << std::endl;
std::cout << "vars: " << model->getTransitionMatrix().getContainedMetaVariables().size() << std::endl;
EXPECT_EQ(13ul, model->getNumberOfStates()); EXPECT_EQ(13ul, model->getNumberOfStates());
EXPECT_EQ(20ul, model->getNumberOfTransitions()); EXPECT_EQ(20ul, model->getNumberOfTransitions());
program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/brp-16-2.pm"); program = storm::parser::PrismParser::parse(STORM_CPP_TESTS_BASE_PATH "/functional/builder/brp-16-2.pm");
model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().translateProgram(program); model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().translateProgram(program);
EXPECT_EQ(677ul, model->getNumberOfStates()); EXPECT_EQ(677ul, model->getNumberOfStates());

Write Preview
Loading…
Cancel
Save