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

first version of sound value iteration

main
dehnert 8 years ago
parent
ec61e110f2
commit
d25cc4b05f
30 changed files with 654 additions and 99 deletions
Split View
  1. 12
      src/storm/exceptions/InvalidSolverSettingsException.h
  2. 12
      src/storm/exceptions/UnmetRequirementException.h
  3. 5
      src/storm/modelchecker/prctl/helper/HybridMdpPrctlHelper.cpp
  4. 15
      src/storm/modelchecker/prctl/helper/SparseMdpPrctlHelper.cpp
  5. 4
      src/storm/modelchecker/prctl/helper/SymbolicMdpPrctlHelper.cpp
  6. 9
      src/storm/settings/modules/EigenEquationSolverSettings.cpp
  7. 2
      src/storm/settings/modules/EigenEquationSolverSettings.h
  8. 6
      src/storm/settings/modules/GeneralSettings.cpp
  9. 14
      src/storm/settings/modules/GeneralSettings.h
  10. 14
      src/storm/settings/modules/NativeEquationSolverSettings.cpp
  11. 4
      src/storm/settings/modules/NativeEquationSolverSettings.h
  12. 43
      src/storm/solver/EigenLinearEquationSolver.cpp
  13. 11
      src/storm/solver/EigenLinearEquationSolver.h
  14. 4
      src/storm/solver/EliminationLinearEquationSolver.cpp
  15. 4
      src/storm/solver/EliminationLinearEquationSolver.h
  16. 29
      src/storm/solver/GmmxxLinearEquationSolver.cpp
  17. 10
      src/storm/solver/GmmxxLinearEquationSolver.h
  18. 139
      src/storm/solver/IterativeMinMaxLinearEquationSolver.cpp
  19. 7
      src/storm/solver/IterativeMinMaxLinearEquationSolver.h
  20. 35
      src/storm/solver/LinearEquationSolver.cpp
  21. 37
      src/storm/solver/LinearEquationSolver.h
  22. 48
      src/storm/solver/LinearEquationSolverRequirements.cpp
  23. 35
      src/storm/solver/LinearEquationSolverRequirements.h
  24. 20
      src/storm/solver/MinMaxLinearEquationSolver.cpp
  25. 20
      src/storm/solver/MinMaxLinearEquationSolver.h
  26. 64
      src/storm/solver/MinMaxLinearEquationSolverRequirements.cpp
  27. 37
      src/storm/solver/MinMaxLinearEquationSolverRequirements.h
  28. 97
      src/storm/solver/NativeLinearEquationSolver.cpp
  29. 12
      src/storm/solver/NativeLinearEquationSolver.h
  30. 4
      src/storm/solver/SymbolicMinMaxLinearEquationSolver.cpp

12
src/storm/exceptions/InvalidSolverSettingsException.h
View File

@ -0,0 +1,12 @@
#pragma once
#include "storm/exceptions/BaseException.h"
#include "storm/exceptions/ExceptionMacros.h"
namespace storm {
namespace exceptions {
STORM_NEW_EXCEPTION(InvalidSolverSettingsException)
} // namespace exceptions
} // namespace storm

12
src/storm/exceptions/UnmetRequirementException.h
View File

@ -0,0 +1,12 @@
#pragma once
#include "storm/exceptions/BaseException.h"
#include "storm/exceptions/ExceptionMacros.h"
namespace storm {
namespace exceptions {
STORM_NEW_EXCEPTION(UnmetRequirementException)
} // namespace exceptions
} // namespace storm

5
src/storm/modelchecker/prctl/helper/HybridMdpPrctlHelper.cpp
View File

@ -117,7 +117,7 @@ namespace storm {
STORM_LOG_DEBUG("Computing valid scheduler hint, because the solver requires it.");
initialScheduler = computeValidInitialSchedulerForUntilProbabilities<ValueType>(explicitRepresentation.first, explicitRepresentation.second);
requirements.set(storm::solver::MinMaxLinearEquationSolverRequirements::Element::ValidInitialScheduler, false);
requirements.clearValidInitialScheduler();
}
STORM_LOG_THROW(requirements.empty(), storm::exceptions::UncheckedRequirementException, "Cannot establish requirements for solver.");
}
@ -126,6 +126,7 @@ namespace storm {
if (initialScheduler) {
solver->setInitialScheduler(std::move(initialScheduler.get()));
}
solver->setBounds(storm::utility::zero<ValueType>(), storm::utility::one<ValueType>());
solver->setRequirementsChecked();
solver->solveEquations(dir, x, explicitRepresentation.second);
@ -357,7 +358,7 @@ namespace storm {
if (requirements.requires(storm::solver::MinMaxLinearEquationSolverRequirements::Element::ValidInitialScheduler)) {
STORM_LOG_DEBUG("Computing valid scheduler, because the solver requires it.");
requireInitialScheduler = true;
requirements.set(storm::solver::MinMaxLinearEquationSolverRequirements::Element::ValidInitialScheduler, false);
requirements.clearValidInitialScheduler();
}
STORM_LOG_THROW(requirements.empty(), storm::exceptions::UncheckedRequirementException, "Cannot establish requirements for solver.");
}

15
src/storm/modelchecker/prctl/helper/SparseMdpPrctlHelper.cpp
View File

@ -207,7 +207,7 @@ namespace storm {
if (requirements.requires(storm::solver::MinMaxLinearEquationSolverRequirements::Element::ValidInitialScheduler)) {
STORM_LOG_DEBUG("Computing valid scheduler, because the solver requires it.");
result.schedulerHint = computeValidSchedulerHint(type, transitionMatrix, backwardTransitions, maybeStates, phiStates, targetStates);
requirements.set(storm::solver::MinMaxLinearEquationSolverRequirements::Element::ValidInitialScheduler, false);
requirements.clearValidInitialScheduler();
}
STORM_LOG_THROW(requirements.empty(), storm::exceptions::UncheckedRequirementException, "There are unchecked requirements of the solver.");
}
@ -215,15 +215,14 @@ namespace storm {
bool skipEcWithinMaybeStatesCheck = dir == storm::OptimizationDirection::Minimize || (hint.isExplicitModelCheckerHint() && hint.asExplicitModelCheckerHint<ValueType>().getNoEndComponentsInMaybeStates());
extractHintInformationForMaybeStates(result, transitionMatrix, backwardTransitions, maybeStates, selectedChoices, hint, skipEcWithinMaybeStatesCheck);
result.lowerResultBound = storm::utility::zero<ValueType>();
if (type == storm::solver::EquationSystemType::UntilProbabilities) {
// Only set bounds if we did not obtain them from the hint.
if (!result.hasLowerResultBound()) {
result.lowerResultBound = storm::utility::zero<ValueType>();
}
if (!result.hasUpperResultBound() && type == storm::solver::EquationSystemType::UntilProbabilities) {
result.upperResultBound = storm::utility::one<ValueType>();
} else if (type == storm::solver::EquationSystemType::ReachabilityRewards) {
// Intentionally left empty.
} else {
STORM_LOG_ASSERT(false, "Unexpected equation system type.");
}
return result;
}

4
src/storm/modelchecker/prctl/helper/SymbolicMdpPrctlHelper.cpp
View File

@ -88,7 +88,7 @@ namespace storm {
if (requirements.requires(storm::solver::MinMaxLinearEquationSolverRequirements::Element::ValidInitialScheduler)) {
STORM_LOG_DEBUG("Computing valid scheduler, because the solver requires it.");
initialScheduler = computeValidSchedulerHint(storm::solver::EquationSystemType::UntilProbabilities, model, transitionMatrix, maybeStates, statesWithProbability01.second);
requirements.set(storm::solver::MinMaxLinearEquationSolverRequirements::Element::ValidInitialScheduler, false);
requirements.clearValidInitialScheduler();
}
STORM_LOG_THROW(requirements.empty(), storm::exceptions::UncheckedRequirementException, "Could not establish requirements of solver.");
}
@ -247,7 +247,7 @@ namespace storm {
if (requirements.requires(storm::solver::MinMaxLinearEquationSolverRequirements::Element::ValidInitialScheduler)) {
STORM_LOG_DEBUG("Computing valid scheduler, because the solver requires it.");
initialScheduler = computeValidSchedulerHint(storm::solver::EquationSystemType::ReachabilityRewards, model, transitionMatrix, maybeStates, targetStates);
requirements.set(storm::solver::MinMaxLinearEquationSolverRequirements::Element::ValidInitialScheduler, false);
requirements.clearValidInitialScheduler();
}
STORM_LOG_THROW(requirements.empty(), storm::exceptions::UncheckedRequirementException, "Could not establish requirements of solver.");
}

9
src/storm/settings/modules/EigenEquationSolverSettings.cpp
View File

@ -106,6 +106,15 @@ namespace storm {
return true;
}
std::ostream& operator<<(std::ostream& out, EigenEquationSolverSettings::LinearEquationMethod const& method) {
switch (method) {
case EigenEquationSolverSettings::LinearEquationMethod::BiCGSTAB: out << "bicgstab"; break;
case EigenEquationSolverSettings::LinearEquationMethod::GMRES: out << "gmres"; break;
case EigenEquationSolverSettings::LinearEquationMethod::DGMRES: out << "dgmres"; break;
case EigenEquationSolverSettings::LinearEquationMethod::SparseLU: out << "sparselu"; break;
}
}
} // namespace modules
} // namespace settings
} // namespace storm

2
src/storm/settings/modules/EigenEquationSolverSettings.h
View File

@ -110,6 +110,8 @@ namespace storm {
static const std::string restartOptionName;
};
std::ostream& operator<<(std::ostream& out, EigenEquationSolverSettings::LinearEquationMethod const& method);
} // namespace modules
} // namespace settings
} // namespace storm

6
src/storm/settings/modules/GeneralSettings.cpp
View File

@ -30,6 +30,7 @@ namespace storm {
const std::string GeneralSettings::bisimulationOptionShortName = "bisim";
const std::string GeneralSettings::parametricOptionName = "parametric";
const std::string GeneralSettings::exactOptionName = "exact";
const std::string GeneralSettings::soundOptionName = "sound";
GeneralSettings::GeneralSettings() : ModuleSettings(moduleName) {
this->addOption(storm::settings::OptionBuilder(moduleName, helpOptionName, false, "Shows all available options, arguments and descriptions.").setShortName(helpOptionShortName)
@ -43,6 +44,7 @@ namespace storm {
this->addOption(storm::settings::OptionBuilder(moduleName, bisimulationOptionName, false, "Sets whether to perform bisimulation minimization.").setShortName(bisimulationOptionShortName).build());
this->addOption(storm::settings::OptionBuilder(moduleName, parametricOptionName, false, "Sets whether to enable parametric model checking.").build());
this->addOption(storm::settings::OptionBuilder(moduleName, exactOptionName, false, "Sets whether to enable exact model checking.").build());
this->addOption(storm::settings::OptionBuilder(moduleName, soundOptionName, false, "Sets whether to force sound model checking.").build());
}
bool GeneralSettings::isHelpSet() const {
@ -86,6 +88,10 @@ namespace storm {
return this->getOption(exactOptionName).getHasOptionBeenSet();
}
bool GeneralSettings::isSoundSet() const {
return this->getOption(soundOptionName).getHasOptionBeenSet();
}
void GeneralSettings::finalize() {
// Intentionally left empty.
}

14
src/storm/settings/modules/GeneralSettings.h
View File

@ -84,20 +84,20 @@ namespace storm {
* @return True iff the option was set.
*/
bool isParametricSet() const;
/*!
* Retrieves whether a min/max equation solving technique has been set.
* Retrieves whether the option enabling exact model checking is set.
*
* @return True iff an equation solving technique has been set.
* @return True iff the option was set.
*/
bool isMinMaxEquationSolvingTechniqueSet() const;
bool isExactSet() const;
/*!
* Retrieves whether the option enabling exact model checking is set.
* Retrieves whether the option forcing soundnet is set.
*
* @return True iff the option was set.
*/
bool isExactSet() const;
bool isSoundSet() const;
bool check() const override;
void finalize() override;
@ -121,8 +121,8 @@ namespace storm {
static const std::string bisimulationOptionName;
static const std::string bisimulationOptionShortName;
static const std::string parametricOptionName;
static const std::string exactOptionName;
static const std::string soundOptionName;
};
} // namespace modules

14
src/storm/settings/modules/NativeEquationSolverSettings.cpp
View File

@ -25,7 +25,7 @@ namespace storm {
const std::string NativeEquationSolverSettings::powerMethodMultiplicationStyleOptionName = "powmult";
NativeEquationSolverSettings::NativeEquationSolverSettings() : ModuleSettings(moduleName) {
std::vector<std::string> methods = { "jacobi", "gaussseidel", "sor", "walkerchae", "power", "spower" };
std::vector<std::string> methods = { "jacobi", "gaussseidel", "sor", "walkerchae", "power" };
this->addOption(storm::settings::OptionBuilder(moduleName, techniqueOptionName, true, "The method to be used for solving linear equation systems with the native engine.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the method to use.").addValidatorString(ArgumentValidatorFactory::createMultipleChoiceValidator(methods)).setDefaultValueString("jacobi").build()).build());
this->addOption(storm::settings::OptionBuilder(moduleName, maximalIterationsOptionName, false, "The maximal number of iterations to perform before iterative solving is aborted.").setShortName(maximalIterationsOptionShortName).addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("count", "The maximal iteration count.").setDefaultValueUnsignedInteger(20000).build()).build());
@ -61,8 +61,6 @@ namespace storm {
return NativeEquationSolverSettings::LinearEquationMethod::WalkerChae;
} else if (linearEquationSystemTechniqueAsString == "power") {
return NativeEquationSolverSettings::LinearEquationMethod::Power;
} else if (linearEquationSystemTechniqueAsString == "spower") {
return NativeEquationSolverSettings::LinearEquationMethod::SoundPower;
}
STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown solution technique '" << linearEquationSystemTechniqueAsString << "' selected.");
}
@ -114,6 +112,16 @@ namespace storm {
return true;
}
std::ostream& operator<<(std::ostream& out, NativeEquationSolverSettings::LinearEquationMethod const& method) {
switch (method) {
case NativeEquationSolverSettings::LinearEquationMethod::Jacobi: out << "jacobi"; break;
case NativeEquationSolverSettings::LinearEquationMethod::GaussSeidel: out << "gaussseidel"; break;
case NativeEquationSolverSettings::LinearEquationMethod::SOR: out << "sor"; break;
case NativeEquationSolverSettings::LinearEquationMethod::WalkerChae: out << "walkerchae"; break;
case NativeEquationSolverSettings::LinearEquationMethod::Power: out << "power"; break;
}
}
} // namespace modules
} // namespace settings
} // namespace storm

4
src/storm/settings/modules/NativeEquationSolverSettings.h
View File

@ -15,7 +15,7 @@ namespace storm {
class NativeEquationSolverSettings : public ModuleSettings {
public:
// An enumeration of all available methods for solving linear equations.
enum class LinearEquationMethod { Jacobi, GaussSeidel, SOR, WalkerChae, Power, SoundPower };
enum class LinearEquationMethod { Jacobi, GaussSeidel, SOR, WalkerChae, Power };
// An enumeration of all available convergence criteria.
enum class ConvergenceCriterion { Absolute, Relative };
@ -118,6 +118,8 @@ namespace storm {
static const std::string powerMethodMultiplicationStyleOptionName;
};
std::ostream& operator<<(std::ostream& out, NativeEquationSolverSettings::LinearEquationMethod const& method);
} // namespace modules
} // namespace settings
} // namespace storm

43
src/storm/solver/EigenLinearEquationSolver.cpp
View File

@ -3,6 +3,7 @@
#include "storm/adapters/EigenAdapter.h"
#include "storm/settings/SettingsManager.h"
#include "storm/settings/modules/GeneralSettings.h"
#include "storm/settings/modules/EigenEquationSolverSettings.h"
#include "storm/utility/vector.h"
@ -16,12 +17,7 @@ namespace storm {
EigenLinearEquationSolverSettings<ValueType>::EigenLinearEquationSolverSettings() {
// Get the settings object to customize linear solving.
storm::settings::modules::EigenEquationSolverSettings const& settings = storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>();
// Get appropriate settings.
maximalNumberOfIterations = settings.getMaximalIterationCount();
precision = settings.getPrecision();
restart = settings.getRestartIterationCount();
// Determine the method to be used.
storm::settings::modules::EigenEquationSolverSettings::LinearEquationMethod methodAsSetting = settings.getLinearEquationSystemMethod();
if (methodAsSetting == storm::settings::modules::EigenEquationSolverSettings::LinearEquationMethod::BiCGSTAB) {
@ -33,7 +29,7 @@ namespace storm {
} else if (methodAsSetting == storm::settings::modules::EigenEquationSolverSettings::LinearEquationMethod::GMRES) {
method = SolutionMethod::GMRES;
}
// Check which preconditioner to use.
storm::settings::modules::EigenEquationSolverSettings::PreconditioningMethod preconditionAsSetting = settings.getPreconditioningMethod();
if (preconditionAsSetting == storm::settings::modules::EigenEquationSolverSettings::PreconditioningMethod::Ilu) {
@ -43,11 +39,22 @@ namespace storm {
} else if (preconditionAsSetting == storm::settings::modules::EigenEquationSolverSettings::PreconditioningMethod::None) {
preconditioner = Preconditioner::None;
}
// Get appropriate settings.
maximalNumberOfIterations = settings.getMaximalIterationCount();
precision = settings.getPrecision();
restart = settings.getRestartIterationCount();
// Finally force soundness and potentially overwrite some other settings.
this->setForceSoundness(storm::settings::getModule<storm::settings::modules::GeneralSettings>().isSoundSet());
}
template<typename ValueType>
void EigenLinearEquationSolverSettings<ValueType>::setSolutionMethod(SolutionMethod const& method) {
this->method = method;
// Make sure we switch the method if we have to guarantee soundness.
this->setForceSoundness(forceSoundness);
}
template<typename ValueType>
@ -69,6 +76,15 @@ namespace storm {
void EigenLinearEquationSolverSettings<ValueType>::setNumberOfIterationsUntilRestart(uint64_t restart) {
this->restart = restart;
}
template<typename ValueType>
void EigenLinearEquationSolverSettings<ValueType>::setForceSoundness(bool value) {
forceSoundness = value;
if (value) {
STORM_LOG_WARN_COND(method != SolutionMethod::SparseLU, "To guarantee soundness, the equation solving technique has been switched to '" << storm::settings::modules::EigenEquationSolverSettings:: LinearEquationMethod::SparseLU << "'.");
method = SolutionMethod::SparseLU;
}
}
template<typename ValueType>
typename EigenLinearEquationSolverSettings<ValueType>::SolutionMethod EigenLinearEquationSolverSettings<ValueType>::getSolutionMethod() const {
@ -95,6 +111,11 @@ namespace storm {
return restart;
}
template<typename ValueType>
bool EigenLinearEquationSolverSettings<ValueType>::getForceSoundness() const {
return forceSoundness;
}
#ifdef STORM_HAVE_CARL
EigenLinearEquationSolverSettings<storm::RationalNumber>::EigenLinearEquationSolverSettings() {
// Intentionally left empty.
@ -135,7 +156,7 @@ namespace storm {
}
template<typename ValueType>
bool EigenLinearEquationSolver<ValueType>::solveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
bool EigenLinearEquationSolver<ValueType>::internalSolveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
// Map the input vectors to Eigen's format.
auto eigenX = StormEigen::Matrix<ValueType, StormEigen::Dynamic, 1>::Map(x.data(), x.size());
auto eigenB = StormEigen::Matrix<ValueType, StormEigen::Dynamic, 1>::Map(b.data(), b.size());
@ -306,7 +327,7 @@ namespace storm {
template<typename ValueType>
LinearEquationSolverProblemFormat EigenLinearEquationSolver<ValueType>::getEquationProblemFormat() const {
LinearEquationSolverProblemFormat::EquationSystem;
return LinearEquationSolverProblemFormat::EquationSystem;
}
template<typename ValueType>
@ -327,7 +348,7 @@ namespace storm {
#ifdef STORM_HAVE_CARL
// Specialization for storm::RationalNumber
template<>
bool EigenLinearEquationSolver<storm::RationalNumber>::solveEquations(std::vector<storm::RationalNumber>& x, std::vector<storm::RationalNumber> const& b) const {
bool EigenLinearEquationSolver<storm::RationalNumber>::internalSolveEquations(std::vector<storm::RationalNumber>& x, std::vector<storm::RationalNumber> const& b) const {
STORM_LOG_INFO("Solving linear equation system (" << x.size() << " rows) with with rational numbers using LU factorization (Eigen library).");
// Map the input vectors to Eigen's format.
@ -342,7 +363,7 @@ namespace storm {
// Specialization for storm::RationalFunction
template<>
bool EigenLinearEquationSolver<storm::RationalFunction>::solveEquations(std::vector<storm::RationalFunction>& x, std::vector<storm::RationalFunction> const& b) const {
bool EigenLinearEquationSolver<storm::RationalFunction>::internalSolveEquations(std::vector<storm::RationalFunction>& x, std::vector<storm::RationalFunction> const& b) const {
STORM_LOG_INFO("Solving linear equation system (" << x.size() << " rows) with rational functions using LU factorization (Eigen library).");
// Map the input vectors to Eigen's format.

11
src/storm/solver/EigenLinearEquationSolver.h
View File

@ -25,14 +25,17 @@ namespace storm {
void setPrecision(ValueType precision);
void setMaximalNumberOfIterations(uint64_t maximalNumberOfIterations);
void setNumberOfIterationsUntilRestart(uint64_t restart);
void setForceSoundness(bool value);
SolutionMethod getSolutionMethod() const;
Preconditioner getPreconditioner() const;
ValueType getPrecision() const;
uint64_t getMaximalNumberOfIterations() const;
uint64_t getNumberOfIterationsUntilRestart() const;
bool getForceSoundness() const;
private:
bool forceSoundness;
SolutionMethod method;
Preconditioner preconditioner;
double precision;
@ -67,14 +70,16 @@ namespace storm {
virtual void setMatrix(storm::storage::SparseMatrix<ValueType> const& A) override;
virtual void setMatrix(storm::storage::SparseMatrix<ValueType>&& A) override;
virtual bool solveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const override;
virtual void multiply(std::vector<ValueType>& x, std::vector<ValueType> const* b, std::vector<ValueType>& result) const override;
EigenLinearEquationSolverSettings<ValueType>& getSettings();
EigenLinearEquationSolverSettings<ValueType> const& getSettings() const;
virtual LinearEquationSolverProblemFormat getEquationProblemFormat() const override;
protected:
virtual bool internalSolveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const override;
private:
virtual uint64_t getMatrixRowCount() const override;
virtual uint64_t getMatrixColumnCount() const override;

4
src/storm/solver/EliminationLinearEquationSolver.cpp
View File

@ -63,9 +63,9 @@ namespace storm {
}
template<typename ValueType>
bool EliminationLinearEquationSolver<ValueType>::solveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
bool EliminationLinearEquationSolver<ValueType>::internalSolveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
// FIXME: This solver will not work for all input systems. More concretely, the current implementation will
// not work for systems that have a 0 on the diagonal. This is not a restriction of this technique in general
// not work for systems that have a 1 on the diagonal. This is not a restriction of this technique in general
// but arbitrary matrices require pivoting, which is not currently implemented.
STORM_LOG_INFO("Solving linear equation system (" << x.size() << " rows) with elimination");

4
src/storm/solver/EliminationLinearEquationSolver.h
View File

@ -33,13 +33,15 @@ namespace storm {
virtual void setMatrix(storm::storage::SparseMatrix<ValueType> const& A) override;
virtual void setMatrix(storm::storage::SparseMatrix<ValueType>&& A) override;
virtual bool solveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const override;
virtual void multiply(std::vector<ValueType>& x, std::vector<ValueType> const* b, std::vector<ValueType>& result) const override;
EliminationLinearEquationSolverSettings<ValueType>& getSettings();
EliminationLinearEquationSolverSettings<ValueType> const& getSettings() const;
virtual LinearEquationSolverProblemFormat getEquationProblemFormat() const override;
protected:
virtual bool internalSolveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const override;
private:
void initializeSettings();

29
src/storm/solver/GmmxxLinearEquationSolver.cpp
View File

@ -3,17 +3,19 @@
#include <cmath>
#include <utility>
#include "storm/settings/SettingsManager.h"
#include "storm/settings/modules/GeneralSettings.h"
#include "storm/settings/modules/GmmxxEquationSolverSettings.h"
#include "storm/adapters/GmmxxAdapter.h"
#include "storm/solver/GmmxxMultiplier.h"
#include "storm/solver/NativeLinearEquationSolver.h"
#include "storm/settings/SettingsManager.h"
#include "storm/utility/vector.h"
#include "storm/utility/constants.h"
#include "storm/exceptions/InvalidStateException.h"
#include "storm/settings/modules/GmmxxEquationSolverSettings.h"
#include "storm/solver/NativeLinearEquationSolver.h"
#include "storm/exceptions/InvalidSolverSettingsException.h"
#include "storm/utility/gmm.h"
#include "storm/utility/vector.h"
@ -49,11 +51,17 @@ namespace storm {
} else if (preconditionAsSetting == storm::settings::modules::GmmxxEquationSolverSettings::PreconditioningMethod::None) {
preconditioner = Preconditioner::None;
}
// Finally force soundness and potentially overwrite some other settings.
this->setForceSoundness(storm::settings::getModule<storm::settings::modules::GeneralSettings>().isSoundSet());
}
template<typename ValueType>
void GmmxxLinearEquationSolverSettings<ValueType>::setSolutionMethod(SolutionMethod const& method) {
this->method = method;
// Make sure we switch the method if we have to guarantee soundness.
this->setForceSoundness(forceSoundness);
}
template<typename ValueType>
@ -76,6 +84,12 @@ namespace storm {
this->restart = restart;
}
template<typename ValueType>
void GmmxxLinearEquationSolverSettings<ValueType>::setForceSoundness(bool value) {
STORM_LOG_THROW(!value, storm::exceptions::InvalidSolverSettingsException, "Solver cannot guarantee soundness, please choose a different equation solver.");
forceSoundness = value;
}
template<typename ValueType>
typename GmmxxLinearEquationSolverSettings<ValueType>::SolutionMethod GmmxxLinearEquationSolverSettings<ValueType>::getSolutionMethod() const {
return method;
@ -101,6 +115,11 @@ namespace storm {
return restart;
}
template<typename ValueType>
bool GmmxxLinearEquationSolverSettings<ValueType>::getForceSoundness() const {
return forceSoundness;
}
template<typename ValueType>
GmmxxLinearEquationSolver<ValueType>::GmmxxLinearEquationSolver(GmmxxLinearEquationSolverSettings<ValueType> const& settings) : settings(settings) {
// Intentionally left empty.
@ -129,7 +148,7 @@ namespace storm {
}
template<typename ValueType>
bool GmmxxLinearEquationSolver<ValueType>::solveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
bool GmmxxLinearEquationSolver<ValueType>::internalSolveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
auto method = this->getSettings().getSolutionMethod();
auto preconditioner = this->getSettings().getPreconditioner();
STORM_LOG_INFO("Solving linear equation system (" << x.size() << " rows) with Gmmxx linear equation solver with method '" << method << "' and preconditioner '" << preconditioner << "' (max. " << this->getSettings().getMaximalNumberOfIterations() << " iterations).");

10
src/storm/solver/GmmxxLinearEquationSolver.h
View File

@ -19,7 +19,6 @@ namespace storm {
enum class Preconditioner {
Ilu, Diagonal, None
};
friend std::ostream& operator<<(std::ostream& out, Preconditioner const& preconditioner) {
switch (preconditioner) {
@ -51,14 +50,19 @@ namespace storm {
void setPrecision(ValueType precision);
void setMaximalNumberOfIterations(uint64_t maximalNumberOfIterations);
void setNumberOfIterationsUntilRestart(uint64_t restart);
void setForceSoundness(bool value);
SolutionMethod getSolutionMethod() const;
Preconditioner getPreconditioner() const;
ValueType getPrecision() const;
uint64_t getMaximalNumberOfIterations() const;
uint64_t getNumberOfIterationsUntilRestart() const;
bool getForceSoundness() const;
private:
// Whether or not we are forced to be sound.
bool forceSoundness;
// The method to use for solving linear equation systems.
SolutionMethod method;
@ -88,7 +92,6 @@ namespace storm {
virtual void setMatrix(storm::storage::SparseMatrix<ValueType> const& A) override;
virtual void setMatrix(storm::storage::SparseMatrix<ValueType>&& A) override;
virtual bool solveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const override;
virtual void multiply(std::vector<ValueType>& x, std::vector<ValueType> const* b, std::vector<ValueType>& result) const override;
virtual void multiplyAndReduce(OptimizationDirection const& dir, std::vector<uint64_t> const& rowGroupIndices, std::vector<ValueType>& x, std::vector<ValueType> const* b, std::vector<ValueType>& result, std::vector<uint_fast64_t>* choices = nullptr) const override;
virtual bool supportsGaussSeidelMultiplication() const override;
@ -102,6 +105,9 @@ namespace storm {
virtual void clearCache() const override;
protected:
virtual bool internalSolveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const override;
private:
virtual uint64_t getMatrixRowCount() const override;
virtual uint64_t getMatrixColumnCount() const override;

139
src/storm/solver/IterativeMinMaxLinearEquationSolver.cpp
View File

@ -1,12 +1,14 @@
#include "storm/solver/IterativeMinMaxLinearEquationSolver.h"
#include "storm/settings/SettingsManager.h"
#include "storm/settings/modules/GeneralSettings.h"
#include "storm/settings/modules/MinMaxEquationSolverSettings.h"
#include "storm/utility/vector.h"
#include "storm/utility/macros.h"
#include "storm/exceptions/InvalidSettingsException.h"
#include "storm/exceptions/InvalidStateException.h"
#include "storm/exceptions/UnmetRequirementException.h"
namespace storm {
namespace solver {
@ -22,6 +24,9 @@ namespace storm {
valueIterationMultiplicationStyle = minMaxSettings.getValueIterationMultiplicationStyle();
setSolutionMethod(minMaxSettings.getMinMaxEquationSolvingMethod());
// Finally force soundness and potentially overwrite some other settings.
this->setForceSoundness(storm::settings::getModule<storm::settings::modules::GeneralSettings>().isSoundSet());
}
template<typename ValueType>
@ -60,6 +65,11 @@ namespace storm {
this->valueIterationMultiplicationStyle = value;
}
template<typename ValueType>
void IterativeMinMaxLinearEquationSolverSettings<ValueType>::setForceSoundness(bool value) {
this->forceSoundness = value;
}
template<typename ValueType>
typename IterativeMinMaxLinearEquationSolverSettings<ValueType>::SolutionMethod const& IterativeMinMaxLinearEquationSolverSettings<ValueType>::getSolutionMethod() const {
return solutionMethod;
@ -84,6 +94,11 @@ namespace storm {
MultiplicationStyle IterativeMinMaxLinearEquationSolverSettings<ValueType>::getValueIterationMultiplicationStyle() const {
return valueIterationMultiplicationStyle;
}
template<typename ValueType>
bool IterativeMinMaxLinearEquationSolverSettings<ValueType>::getForceSoundness() const {
return forceSoundness;
}
template<typename ValueType>
IterativeMinMaxLinearEquationSolver<ValueType>::IterativeMinMaxLinearEquationSolver(std::unique_ptr<LinearEquationSolverFactory<ValueType>>&& linearEquationSolverFactory, IterativeMinMaxLinearEquationSolverSettings<ValueType> const& settings) : StandardMinMaxLinearEquationSolver<ValueType>(std::move(linearEquationSolverFactory)), settings(settings) {
@ -104,7 +119,11 @@ namespace storm {
bool IterativeMinMaxLinearEquationSolver<ValueType>::internalSolveEquations(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
switch (this->getSettings().getSolutionMethod()) {
case IterativeMinMaxLinearEquationSolverSettings<ValueType>::SolutionMethod::ValueIteration:
return solveEquationsValueIteration(dir, x, b);
if (this->getSettings().getForceSoundness()) {
return solveEquationsSoundValueIteration(dir, x, b);
} else {
return solveEquationsValueIteration(dir, x, b);
}
case IterativeMinMaxLinearEquationSolverSettings<ValueType>::SolutionMethod::PolicyIteration:
return solveEquationsPolicyIteration(dir, x, b);
case IterativeMinMaxLinearEquationSolverSettings<ValueType>::SolutionMethod::Acyclic:
@ -229,20 +248,32 @@ namespace storm {
template<typename ValueType>
MinMaxLinearEquationSolverRequirements IterativeMinMaxLinearEquationSolver<ValueType>::getRequirements(EquationSystemType const& equationSystemType, boost::optional<storm::solver::OptimizationDirection> const& direction) const {
MinMaxLinearEquationSolverRequirements requirements;
// Start by copying the requirements of the linear equation solver.
MinMaxLinearEquationSolverRequirements requirements(this->linearEquationSolverFactory->getRequirements());
// If we will use sound value iteration, we require no ECs and an upper bound.
if (this->getSettings().getSolutionMethod() == IterativeMinMaxLinearEquationSolverSettings<ValueType>::SolutionMethod::ValueIteration && this->getSettings().getForceSoundness()) {
requirements.requireNoEndComponents();
requirements.requireGlobalUpperBound();
}
// Then add our requirements on top of that.
if (equationSystemType == EquationSystemType::UntilProbabilities) {
if (this->getSettings().getSolutionMethod() == IterativeMinMaxLinearEquationSolverSettings<ValueType>::SolutionMethod::PolicyIteration) {
if (!direction || direction.get() == OptimizationDirection::Maximize) {
requirements.set(MinMaxLinearEquationSolverRequirements::Element::ValidInitialScheduler);
requirements.requireValidInitialScheduler();
}
}
} else if (equationSystemType == EquationSystemType::ReachabilityRewards) {
if (!direction || direction.get() == OptimizationDirection::Minimize) {
requirements.set(MinMaxLinearEquationSolverRequirements::Element::ValidInitialScheduler);
requirements.requireValidInitialScheduler();
}
}
if (this->getSettings().getSolutionMethod() == IterativeMinMaxLinearEquationSolverSettings<ValueType>::SolutionMethod::ValueIteration && this->getSettings().getForceSoundness()) {
requirements.requireGlobalUpperBound();
}
return requirements;
}
@ -330,6 +361,105 @@ namespace storm {
return status == Status::Converged || status == Status::TerminatedEarly;
}
template<typename ValueType>
bool IterativeMinMaxLinearEquationSolver<ValueType>::solveEquationsSoundValueIteration(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
STORM_LOG_THROW(this->hasUpperBound(), storm::exceptions::UnmetRequirementException, "Solver requires upper bound, but none was given.");
if (!this->linEqSolverA) {
this->linEqSolverA = this->linearEquationSolverFactory->create(*this->A);
this->linEqSolverA->setCachingEnabled(true);
}
if (!auxiliaryRowGroupVector) {
auxiliaryRowGroupVector = std::make_unique<std::vector<ValueType>>(this->A->getRowGroupCount());
}
if (this->hasInitialScheduler()) {
// Resolve the nondeterminism according to the initial scheduler.
bool convertToEquationSystem = this->linearEquationSolverFactory->getEquationProblemFormat() == LinearEquationSolverProblemFormat::EquationSystem;
storm::storage::SparseMatrix<ValueType> submatrix = this->A->selectRowsFromRowGroups(this->getInitialScheduler(), convertToEquationSystem);
if (convertToEquationSystem) {
submatrix.convertToEquationSystem();
}
storm::utility::vector::selectVectorValues<ValueType>(*auxiliaryRowGroupVector, this->getInitialScheduler(), this->A->getRowGroupIndices(), b);
// Solve the resulting equation system.
auto submatrixSolver = this->linearEquationSolverFactory->create(std::move(submatrix));
submatrixSolver->setCachingEnabled(true);
if (this->lowerBound) {
submatrixSolver->setLowerBound(this->lowerBound.get());
}
if (this->upperBound) {
submatrixSolver->setUpperBound(this->upperBound.get());
}
submatrixSolver->solveEquations(x, *auxiliaryRowGroupVector);
}
// Allow aliased multiplications.
bool useGaussSeidelMultiplication = this->linEqSolverA->supportsGaussSeidelMultiplication() && settings.getValueIterationMultiplicationStyle() == storm::solver::MultiplicationStyle::GaussSeidel;
std::vector<ValueType>* lowerX = &x;
std::vector<ValueType>* upperX = this->auxiliaryRowGroupVector.get();
std::vector<ValueType>* tmp;
if (!useGaussSeidelMultiplication) {
auxiliaryRowGroupVector2 = std::make_unique<std::vector<ValueType>>(lowerX->size());
tmp = auxiliaryRowGroupVector2.get();
}
// Proceed with the iterations as long as the method did not converge or reach the maximum number of iterations.
uint64_t iterations = 0;
Status status = Status::InProgress;
while (status == Status::InProgress && iterations < this->getSettings().getMaximalNumberOfIterations()) {
// Compute x' = min/max(A*x + b).
if (useGaussSeidelMultiplication) {
this->linEqSolverA->multiplyAndReduceGaussSeidel(dir, this->A->getRowGroupIndices(), *lowerX, &b);
this->linEqSolverA->multiplyAndReduceGaussSeidel(dir, this->A->getRowGroupIndices(), *upperX, &b);
} else {
this->linEqSolverA->multiplyAndReduce(dir, this->A->getRowGroupIndices(), *lowerX, &b, *tmp);
std::swap(lowerX, tmp);
this->linEqSolverA->multiplyAndReduce(dir, this->A->getRowGroupIndices(), *upperX, &b, *tmp);
std::swap(upperX, tmp);
}
// Determine whether the method converged.
if (storm::utility::vector::equalModuloPrecision<ValueType>(*lowerX, *upperX, storm::utility::convertNumber<ValueType>(2.0) * this->getSettings().getPrecision(), false)) {
status = Status::Converged;
}
// Update environment variables.
++iterations;
}
if (status != Status::Converged) {
status = Status::MaximalIterationsExceeded;
}
reportStatus(status, iterations);
// We take the means of the lower and upper bound so we guarantee the desired precision.
storm::utility::vector::applyPointwise(*lowerX, *upperX, *lowerX, [] (ValueType const& a, ValueType const& b) { return (a + b) / storm::utility::convertNumber<ValueType>(2.0); });
// Since we shuffled the pointer around, we need to write the actual results to the input/output vector x.
if (&x == tmp) {
std::swap(x, *tmp);
} else if (&x == this->auxiliaryRowGroupVector.get()) {
std::swap(x, *this->auxiliaryRowGroupVector);
}
// If requested, we store the scheduler for retrieval.
if (this->isTrackSchedulerSet()) {
this->schedulerChoices = std::vector<uint_fast64_t>(this->A->getRowGroupCount());
this->linEqSolverA->multiplyAndReduce(dir, this->A->getRowGroupIndices(), x, &b, *this->auxiliaryRowGroupVector, &this->schedulerChoices.get());
}
if (!this->isCachingEnabled()) {
clearCache();
}
return status == Status::Converged;
}
template<typename ValueType>
bool IterativeMinMaxLinearEquationSolver<ValueType>::solveEquationsAcyclic(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
uint64_t numGroups = this->A->getRowGroupCount();
@ -473,6 +603,7 @@ namespace storm {
template<typename ValueType>
void IterativeMinMaxLinearEquationSolver<ValueType>::clearCache() const {
auxiliaryRowGroupVector.reset();
auxiliaryRowGroupVector2.reset();
rowGroupOrdering.reset();
StandardMinMaxLinearEquationSolver<ValueType>::clearCache();
}

7
src/storm/solver/IterativeMinMaxLinearEquationSolver.h
View File

@ -23,14 +23,17 @@ namespace storm {
void setRelativeTerminationCriterion(bool value);
void setPrecision(ValueType precision);
void setValueIterationMultiplicationStyle(MultiplicationStyle value);
void setForceSoundness(bool value);
SolutionMethod const& getSolutionMethod() const;
uint64_t getMaximalNumberOfIterations() const;
ValueType getPrecision() const;
bool getRelativeTerminationCriterion() const;
MultiplicationStyle getValueIterationMultiplicationStyle() const;
bool getForceSoundness() const;
private:
bool forceSoundness;
SolutionMethod solutionMethod;
uint64_t maximalNumberOfIterations;
ValueType precision;
@ -60,6 +63,7 @@ namespace storm {
private:
bool solveEquationsPolicyIteration(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b) const;
bool solveEquationsValueIteration(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b) const;
bool solveEquationsSoundValueIteration(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b) const;
bool solveEquationsAcyclic(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b) const;
bool valueImproved(OptimizationDirection dir, ValueType const& value1, ValueType const& value2) const;
@ -72,6 +76,7 @@ namespace storm {
// possibly cached data
mutable std::unique_ptr<std::vector<ValueType>> auxiliaryRowGroupVector; // A.rowGroupCount() entries
mutable std::unique_ptr<std::vector<ValueType>> auxiliaryRowGroupVector2; // A.rowGroupCount() entries
mutable std::unique_ptr<std::vector<uint64_t>> rowGroupOrdering; // A.rowGroupCount() entries
Status updateStatusIfNotConverged(Status status, std::vector<ValueType> const& x, uint64_t iterations) const;

35
src/storm/solver/LinearEquationSolver.cpp
View File

@ -23,6 +23,11 @@ namespace storm {
// Intentionally left empty.
}
template<typename ValueType>
bool LinearEquationSolver<ValueType>::solveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
return this->internalSolveEquations(x, b);
}
template<typename ValueType>
void LinearEquationSolver<ValueType>::repeatedMultiply(std::vector<ValueType>& x, std::vector<ValueType> const* b, uint_fast64_t n) const {
if (!cachedRowVector) {
@ -101,6 +106,11 @@ namespace storm {
STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "This solver does not support the function 'multiplyAndReduceGaussSeidel'.");
}
template<typename ValueType>
LinearEquationSolverRequirements LinearEquationSolver<ValueType>::getRequirements() const {
return LinearEquationSolverRequirements();
}
template<typename ValueType>
void LinearEquationSolver<ValueType>::setCachingEnabled(bool value) const {
if(cachingEnabled && !value) {
@ -136,6 +146,26 @@ namespace storm {
setUpperBound(upper);
}
template<typename ValueType>
bool LinearEquationSolver<ValueType>::hasLowerBound() const {
return static_cast<bool>(lowerBound);
}
template<typename ValueType>
bool LinearEquationSolver<ValueType>::hasUpperBound() const {
return static_cast<bool>(upperBound);
}
template<typename ValueType>
ValueType const& LinearEquationSolver<ValueType>::getLowerBound() const {
return lowerBound.get();
}
template<typename ValueType>
ValueType const& LinearEquationSolver<ValueType>::getUpperBound() const {
return upperBound.get();
}
template<typename ValueType>
std::unique_ptr<LinearEquationSolver<ValueType>> LinearEquationSolverFactory<ValueType>::create(storm::storage::SparseMatrix<ValueType> const& matrix) const {
std::unique_ptr<LinearEquationSolver<ValueType>> solver = this->create();
@ -155,6 +185,11 @@ namespace storm {
return this->create()->getEquationProblemFormat();
}
template<typename ValueType>
LinearEquationSolverRequirements LinearEquationSolverFactory<ValueType>::getRequirements() const {
return this->create()->getRequirements();
}
template<typename ValueType>
std::unique_ptr<LinearEquationSolver<ValueType>> GeneralLinearEquationSolverFactory<ValueType>::create() const {
EquationSolverType equationSolver = storm::settings::getModule<storm::settings::modules::CoreSettings>().getEquationSolver();

37
src/storm/solver/LinearEquationSolver.h
View File

@ -7,6 +7,7 @@
#include "storm/solver/AbstractEquationSolver.h"
#include "storm/solver/MultiplicationStyle.h"
#include "storm/solver/LinearEquationSolverProblemFormat.h"
#include "storm/solver/LinearEquationSolverRequirements.h"
#include "storm/solver/OptimizationDirection.h"
#include "storm/utility/VectorHelper.h"
@ -47,7 +48,7 @@ namespace storm {
*
* @return true
*/
virtual bool solveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const = 0;
bool solveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const;
/*!
* Performs on matrix-vector multiplication x' = A*x + b.
@ -127,6 +128,12 @@ namespace storm {
*/
virtual LinearEquationSolverProblemFormat getEquationProblemFormat() const = 0;
/*!
* Retrieves the requirements of the solver under the current settings. Note that these requirements only
* apply to solving linear equations and not to the matrix vector multiplications.
*/
virtual LinearEquationSolverRequirements getRequirements() const;
/*!
* Sets whether some of the generated data during solver calls should be cached.
* This possibly increases the runtime of subsequent calls but also increases memory consumption.
@ -153,12 +160,34 @@ namespace storm {
*/
void setUpperBound(ValueType const& value);
/*!
* Retrieves the lower bound (if there is any).
*/
ValueType const& getLowerBound() const;
/*!
* Retrieves the lower bound (if there is any).
*/
ValueType const& getUpperBound() const;
/*!
* Retrieves whether this solver has a lower bound.
*/
bool hasLowerBound() const;
/*!
* Retrieves whether this solver has an upper bound.
*/
bool hasUpperBound() const;
/*!
* Sets bounds for the solution that can potentially be used by the solver.
*/
void setBounds(ValueType const& lower, ValueType const& upper);
protected:
virtual bool internalSolveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const = 0;
// auxiliary storage. If set, this vector has getMatrixRowCount() entries.
mutable std::unique_ptr<std::vector<ValueType>> cachedRowVector;
@ -220,6 +249,12 @@ namespace storm {
* Retrieves the problem format that the solver expects if it was created with the current settings.
*/
virtual LinearEquationSolverProblemFormat getEquationProblemFormat() const;
/*!
* Retrieves the requirements of the solver if it was created with the current settings. Note that these
* requirements only apply to solving linear equations and not to the matrix vector multiplications.
*/
LinearEquationSolverRequirements getRequirements() const;
};
template<typename ValueType>

48
src/storm/solver/LinearEquationSolverRequirements.cpp
View File

@ -0,0 +1,48 @@
#include "storm/solver/LinearEquationSolverRequirements.h"
namespace storm {
namespace solver {
LinearEquationSolverRequirements::LinearEquationSolverRequirements() : globalLowerBound(false), globalUpperBound(false) {
// Intentionally left empty.
}
LinearEquationSolverRequirements& LinearEquationSolverRequirements::requireGlobalLowerBound() {
globalLowerBound = true;
return *this;
}
LinearEquationSolverRequirements& LinearEquationSolverRequirements::requireGlobalUpperBound() {
globalUpperBound = true;
return *this;
}
bool LinearEquationSolverRequirements::requiresGlobalLowerBound() const {
return globalLowerBound;
}
bool LinearEquationSolverRequirements::requiresGlobalUpperBound() const {
return globalUpperBound;
}
bool LinearEquationSolverRequirements::requires(Element const& element) const {
switch (element) {
case Element::GlobalLowerBound: return globalLowerBound; break;
case Element::GlobalUpperBound: return globalUpperBound; break;
}
}
void LinearEquationSolverRequirements::clearGlobalLowerBound() {
globalLowerBound = false;
}
void LinearEquationSolverRequirements::clearGlobalUpperBound() {
globalUpperBound = false;
}
bool LinearEquationSolverRequirements::empty() const {
return !globalLowerBound && !globalUpperBound;
}
}
}

35
src/storm/solver/LinearEquationSolverRequirements.h
View File

@ -0,0 +1,35 @@
#pragma once
namespace storm {
namespace solver {
class LinearEquationSolverRequirements {
public:
// The different requirements a solver can have.
enum class Element {
// Requirements that are related to bounds for the actual solution.
GlobalLowerBound,
GlobalUpperBound
};
LinearEquationSolverRequirements();
LinearEquationSolverRequirements& requireGlobalLowerBound();
LinearEquationSolverRequirements& requireGlobalUpperBound();
bool requiresGlobalLowerBound() const;
bool requiresGlobalUpperBound() const;
bool requires(Element const& element) const;
void clearGlobalLowerBound();
void clearGlobalUpperBound();
bool empty() const;
private:
bool globalLowerBound;
bool globalUpperBound;
};
}
}

20
src/storm/solver/MinMaxLinearEquationSolver.cpp
View File

@ -127,6 +127,26 @@ namespace storm {
setUpperBound(upper);
}
template<typename ValueType>
bool MinMaxLinearEquationSolver<ValueType>::hasUpperBound() const {
return static_cast<bool>(upperBound);
}
template<typename ValueType>
bool MinMaxLinearEquationSolver<ValueType>::hasLowerBound() const {
return static_cast<bool>(lowerBound);
}
template<typename ValueType>
ValueType const& MinMaxLinearEquationSolver<ValueType>::getUpperBound() const {
return upperBound.get();
}
template<typename ValueType>
ValueType const& MinMaxLinearEquationSolver<ValueType>::getLowerBound() const {
return lowerBound.get();
}
template<typename ValueType>
void MinMaxLinearEquationSolver<ValueType>::setInitialScheduler(std::vector<uint_fast64_t>&& choices) {
initialScheduler = std::move(choices);

20
src/storm/solver/MinMaxLinearEquationSolver.h
View File

@ -150,7 +150,27 @@ namespace storm {
* Sets bounds for the solution that can potentially used by the solver.
*/
void setBounds(ValueType const& lower, ValueType const& upper);
/*!
* Retrieves whether the solver has an upper bound.
*/
bool hasUpperBound() const;
/*!
* Retrieves whether the solver has a lower bound.
*/
bool hasLowerBound() const;
/*!
* Retrieves the upper bound (if this solver has any).
*/
ValueType const& getUpperBound() const;
/*!
* Retrieves the upper bound (if this solver has any).
*/
ValueType const& getLowerBound() const;
/*!
* Sets a valid initial scheduler that is required by some solvers (see requirements of solvers).
*/

64
src/storm/solver/MinMaxLinearEquationSolverRequirements.cpp
View File

@ -3,58 +3,74 @@
namespace storm {
namespace solver {
MinMaxLinearEquationSolverRequirements::MinMaxLinearEquationSolverRequirements() : noEndComponents(false), noZeroRewardEndComponents(false), validInitialScheduler(false), globalLowerBound(false), globalUpperBound(false) {
MinMaxLinearEquationSolverRequirements::MinMaxLinearEquationSolverRequirements(LinearEquationSolverRequirements const& linearEquationSolverRequirements) : noEndComponents(false), validInitialScheduler(false), globalLowerBound(linearEquationSolverRequirements.requiresGlobalLowerBound()), globalUpperBound(linearEquationSolverRequirements.requiresGlobalUpperBound()) {
// Intentionally left empty.
}
MinMaxLinearEquationSolverRequirements& MinMaxLinearEquationSolverRequirements::setNoEndComponents(bool value) {
noEndComponents = value;
MinMaxLinearEquationSolverRequirements& MinMaxLinearEquationSolverRequirements::requireNoEndComponents() {
noEndComponents = true;
return *this;
}
MinMaxLinearEquationSolverRequirements& MinMaxLinearEquationSolverRequirements::setNoZeroRewardEndComponents(bool value) {
noZeroRewardEndComponents = value;
MinMaxLinearEquationSolverRequirements& MinMaxLinearEquationSolverRequirements::requireValidInitialScheduler() {
validInitialScheduler = true;
return *this;
}
MinMaxLinearEquationSolverRequirements& MinMaxLinearEquationSolverRequirements::setValidInitialScheduler(bool value) {
validInitialScheduler = value;
MinMaxLinearEquationSolverRequirements& MinMaxLinearEquationSolverRequirements::requireGlobalLowerBound() {
globalLowerBound = true;
return *this;
}
MinMaxLinearEquationSolverRequirements& MinMaxLinearEquationSolverRequirements::setGlobalLowerBound(bool value) {
globalLowerBound = value;
MinMaxLinearEquationSolverRequirements& MinMaxLinearEquationSolverRequirements::requireGlobalUpperBound() {
globalUpperBound = true;
return *this;
}
MinMaxLinearEquationSolverRequirements& MinMaxLinearEquationSolverRequirements::setGlobalUpperBound(bool value) {
globalUpperBound = value;
return *this;
bool MinMaxLinearEquationSolverRequirements::requiresNoEndComponents() const {
return noEndComponents;
}
MinMaxLinearEquationSolverRequirements& MinMaxLinearEquationSolverRequirements::set(Element const& element, bool value) {
switch (element) {
case Element::NoEndComponents: noEndComponents = value; break;
case Element::NoZeroRewardEndComponents: noZeroRewardEndComponents = value; break;
case Element::ValidInitialScheduler: validInitialScheduler = value; break;
case Element::GlobalLowerBound: globalLowerBound = value; break;
case Element::GlobalUpperBound: globalUpperBound = value; break;
}
return *this;
bool MinMaxLinearEquationSolverRequirements::requiresValidIntialScheduler() const {
return validInitialScheduler;
}
bool MinMaxLinearEquationSolverRequirements::requiresGlobalLowerBound() const {
return globalLowerBound;
}
bool MinMaxLinearEquationSolverRequirements::requiresGlobalUpperBound() const {
return globalUpperBound;
}
bool MinMaxLinearEquationSolverRequirements::requires(Element const& element) {
bool MinMaxLinearEquationSolverRequirements::requires(Element const& element) const {
switch (element) {
case Element::NoEndComponents: return noEndComponents; break;
case Element::NoZeroRewardEndComponents: return noZeroRewardEndComponents; break;
case Element::ValidInitialScheduler: return validInitialScheduler; break;
case Element::GlobalLowerBound: return globalLowerBound; break;
case Element::GlobalUpperBound: return globalUpperBound; break;
}
}
void MinMaxLinearEquationSolverRequirements::clearNoEndComponents() {
noEndComponents = false;
validInitialScheduler = false;
}
void MinMaxLinearEquationSolverRequirements::clearValidInitialScheduler() {
validInitialScheduler = false;
}
void MinMaxLinearEquationSolverRequirements::clearGlobalLowerBound() {
globalLowerBound = false;
}
void MinMaxLinearEquationSolverRequirements::clearGlobalUpperBound() {
globalUpperBound = false;
}
bool MinMaxLinearEquationSolverRequirements::empty() const {
return !noEndComponents && !noZeroRewardEndComponents && !validInitialScheduler && !globalLowerBound && !globalUpperBound;
return !noEndComponents && !validInitialScheduler && !globalLowerBound && !globalUpperBound;
}
}

37
src/storm/solver/MinMaxLinearEquationSolverRequirements.h
View File

@ -1,30 +1,47 @@
#pragma once
#include "storm/solver/LinearEquationSolverRequirements.h"
namespace storm {
namespace solver {
class MinMaxLinearEquationSolverRequirements {
public:
// The different requirements a solver can have.
enum class Element {
NoEndComponents, NoZeroRewardEndComponents, ValidInitialScheduler, GlobalLowerBound, GlobalUpperBound
// Requirements that are related to the graph structure of the system. Note that the requirements in this
// category are to be interpreted incrementally in the following sense: whenever the system has no end
// components then automatically both requirements are fulfilled.
NoEndComponents,
ValidInitialScheduler,
// Requirements that are related to bounds for the actual solution.
GlobalLowerBound,
GlobalUpperBound
};
MinMaxLinearEquationSolverRequirements();
MinMaxLinearEquationSolverRequirements(LinearEquationSolverRequirements const& linearEquationSolverRequirements = LinearEquationSolverRequirements());
MinMaxLinearEquationSolverRequirements& setNoEndComponents(bool value = true);
MinMaxLinearEquationSolverRequirements& setNoZeroRewardEndComponents(bool value = true);
MinMaxLinearEquationSolverRequirements& setValidInitialScheduler(bool value = true);
MinMaxLinearEquationSolverRequirements& setGlobalLowerBound(bool value = true);
MinMaxLinearEquationSolverRequirements& setGlobalUpperBound(bool value = true);
MinMaxLinearEquationSolverRequirements& set(Element const& element, bool value = true);
MinMaxLinearEquationSolverRequirements& requireNoEndComponents();
MinMaxLinearEquationSolverRequirements& requireValidInitialScheduler();
MinMaxLinearEquationSolverRequirements& requireGlobalLowerBound();
MinMaxLinearEquationSolverRequirements& requireGlobalUpperBound();
bool requiresNoEndComponents() const;
bool requiresValidIntialScheduler() const;
bool requiresGlobalLowerBound() const;
bool requiresGlobalUpperBound() const;
bool requires(Element const& element) const;
bool requires(Element const& element);
void clearNoEndComponents();
void clearValidInitialScheduler();
void clearGlobalLowerBound();
void clearGlobalUpperBound();
bool empty() const;
private:
bool noEndComponents;
bool noZeroRewardEndComponents;
bool validInitialScheduler;
bool globalLowerBound;
bool globalUpperBound;

97
src/storm/solver/NativeLinearEquationSolver.cpp
View File

@ -3,12 +3,14 @@
#include <utility>
#include "storm/settings/SettingsManager.h"
#include "storm/settings/modules/GeneralSettings.h"
#include "storm/settings/modules/NativeEquationSolverSettings.h"
#include "storm/utility/constants.h"
#include "storm/utility/vector.h"
#include "storm/exceptions/InvalidStateException.h"
#include "storm/exceptions/InvalidSettingsException.h"
#include "storm/exceptions/UnmetRequirementException.h"
namespace storm {
namespace solver {
@ -28,22 +30,26 @@ namespace storm {
method = SolutionMethod::WalkerChae;
} else if (methodAsSetting == storm::settings::modules::NativeEquationSolverSettings::LinearEquationMethod::Power) {
method = SolutionMethod::Power;
} else if (methodAsSetting == storm::settings::modules::NativeEquationSolverSettings::LinearEquationMethod::SoundPower) {
method = SolutionMethod::SoundPower;
} else {
STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "The selected solution technique is invalid for this solver.");
}
maximalNumberOfIterations = settings.getMaximalIterationCount();
precision = settings.getPrecision();
relative = settings.getConvergenceCriterion() == storm::settings::modules::NativeEquationSolverSettings::ConvergenceCriterion::Relative;
omega = settings.getOmega();
multiplicationStyle = settings.getPowerMethodMultiplicationStyle();
// Finally force soundness and potentially overwrite some other settings.
this->setForceSoundness(storm::settings::getModule<storm::settings::modules::GeneralSettings>().isSoundSet());
}
template<typename ValueType>
void NativeLinearEquationSolverSettings<ValueType>::setSolutionMethod(SolutionMethod const& method) {
this->method = method;
// Make sure we switch the method if we have to guarantee soundness.
this->setForceSoundness(forceSoundness);
}
template<typename ValueType>
@ -71,6 +77,15 @@ namespace storm {
this->multiplicationStyle = value;
}
template<typename ValueType>
void NativeLinearEquationSolverSettings<ValueType>::setForceSoundness(bool value) {
forceSoundness = value;
if (forceSoundness) {
STORM_LOG_WARN_COND(method != SolutionMethod::Power, "To guarantee soundness, the equation solving technique has been switched to '" << storm::settings::modules::NativeEquationSolverSettings::LinearEquationMethod::Power << "'.");
method = SolutionMethod::Power;
}
}
template<typename ValueType>
typename NativeLinearEquationSolverSettings<ValueType>::SolutionMethod NativeLinearEquationSolverSettings<ValueType>::getSolutionMethod() const {
return method;
@ -101,6 +116,11 @@ namespace storm {
return multiplicationStyle;
}
template<typename ValueType>
bool NativeLinearEquationSolverSettings<ValueType>::getForceSoundness() const {
return forceSoundness;
}
template<typename ValueType>
NativeLinearEquationSolver<ValueType>::NativeLinearEquationSolver(NativeLinearEquationSolverSettings<ValueType> const& settings) : localA(nullptr), A(nullptr), settings(settings) {
// Intentionally left empty.
@ -410,11 +430,69 @@ namespace storm {
template<typename ValueType>
bool NativeLinearEquationSolver<ValueType>::solveEquationsSoundPower(std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
// TODO
STORM_LOG_THROW(this->hasUpperBound(), storm::exceptions::UnmetRequirementException, "Solver requires upper bound, but none was given.");
STORM_LOG_INFO("Solving linear equation system (" << x.size() << " rows) with NativeLinearEquationSolver (SoundPower)");
std::vector<ValueType>* lowerX = &x;
if (!this->cachedRowVector) {
this->cachedRowVector = std::make_unique<std::vector<ValueType>>(getMatrixRowCount(), this->getUpperBound());
}
std::vector<ValueType>* upperX = this->cachedRowVector.get();
bool useGaussSeidelMultiplication = this->getSettings().getPowerMethodMultiplicationStyle() == storm::solver::MultiplicationStyle::GaussSeidel;
std::vector<ValueType>* tmp;
if (!useGaussSeidelMultiplication) {
cachedRowVector2 = std::make_unique<std::vector<ValueType>>(x.size());
tmp = cachedRowVector2.get();
}
bool converged = false;
uint64_t iterations = 0;
while (!converged && iterations < this->getSettings().getMaximalNumberOfIterations()) {
if (useGaussSeidelMultiplication) {
this->multiplier.multAddGaussSeidelBackward(*this->A, *lowerX, &b);
this->multiplier.multAddGaussSeidelBackward(*this->A, *upperX, &b);
} else {
this->multiplier.multAdd(*this->A, *lowerX, &b, *tmp);
std::swap(tmp, lowerX);
this->multiplier.multAdd(*this->A, *upperX, &b, *tmp);
std::swap(tmp, upperX);
}
// Now check if the process already converged within our precision. Note that we double the target
// precision here. Doing so, we need to take the means of the lower and upper values later to guarantee
// the original precision.
converged = storm::utility::vector::equalModuloPrecision<ValueType>(*lowerX, *upperX, storm::utility::convertNumber<ValueType>(2.0) * static_cast<ValueType>(this->getSettings().getPrecision()), false);
// Set up next iteration.
++iterations;
}
// We take the means of the lower and upper bound so we guarantee the desired precision.
storm::utility::vector::applyPointwise(*lowerX, *upperX, *lowerX, [] (ValueType const& a, ValueType const& b) { return (a + b) / storm::utility::convertNumber<ValueType>(2.0); });
// Since we shuffled the pointer around, we need to write the actual results to the input/output vector x.
if (&x == tmp) {
std::swap(x, *tmp);
} else if (&x == this->cachedRowVector.get()) {
std::swap(x, *this->cachedRowVector);
}
if (!this->isCachingEnabled()) {
clearCache();
}
if (converged) {
STORM_LOG_INFO("Iterative solver converged in " << iterations << " iterations.");
} else {
STORM_LOG_WARN("Iterative solver did not converge in " << iterations << " iterations.");
}
return converged;
}
template<typename ValueType>
bool NativeLinearEquationSolver<ValueType>::solveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
bool NativeLinearEquationSolver<ValueType>::internalSolveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
if (this->getSettings().getSolutionMethod() == NativeLinearEquationSolverSettings<ValueType>::SolutionMethod::SOR || this->getSettings().getSolutionMethod() == NativeLinearEquationSolverSettings<ValueType>::SolutionMethod::GaussSeidel) {
return this->solveEquationsSOR(x, b, this->getSettings().getSolutionMethod() == NativeLinearEquationSolverSettings<ValueType>::SolutionMethod::SOR ? this->getSettings().getOmega() : storm::utility::one<ValueType>());
} else if (this->getSettings().getSolutionMethod() == NativeLinearEquationSolverSettings<ValueType>::SolutionMethod::Jacobi) {
@ -422,7 +500,11 @@ namespace storm {
} else if (this->getSettings().getSolutionMethod() == NativeLinearEquationSolverSettings<ValueType>::SolutionMethod::WalkerChae) {
return this->solveEquationsWalkerChae(x, b);
} else if (this->getSettings().getSolutionMethod() == NativeLinearEquationSolverSettings<ValueType>::SolutionMethod::Power) {
return this->solveEquationsPower(x, b);
if (this->getSettings().getForceSoundness()) {
return this->solveEquationsSoundPower(x, b);
} else {
return this->solveEquationsPower(x, b);
}
}
STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "Unknown solving technique.");
@ -495,7 +577,7 @@ namespace storm {
template<typename ValueType>
LinearEquationSolverProblemFormat NativeLinearEquationSolver<ValueType>::getEquationProblemFormat() const {
if (this->getSettings().getSolutionMethod() == NativeLinearEquationSolverSettings<ValueType>::SolutionMethod::Power || this->getSettings().getSolutionMethod() == NativeLinearEquationSolverSettings<ValueType>::SolutionMethod::SoundPower) {
if (this->getSettings().getSolutionMethod() == NativeLinearEquationSolverSettings<ValueType>::SolutionMethod::Power) {
return LinearEquationSolverProblemFormat::FixedPointSystem;
} else {
return LinearEquationSolverProblemFormat::EquationSystem;
@ -505,6 +587,7 @@ namespace storm {
template<typename ValueType>
void NativeLinearEquationSolver<ValueType>::clearCache() const {
jacobiDecomposition.reset();
cachedRowVector2.reset();
walkerChaeData.reset();
LinearEquationSolver<ValueType>::clearCache();
}

12
src/storm/solver/NativeLinearEquationSolver.h
View File

@ -14,7 +14,7 @@ namespace storm {
class NativeLinearEquationSolverSettings {
public:
enum class SolutionMethod {
Jacobi, GaussSeidel, SOR, WalkerChae, Power, SoundPower
Jacobi, GaussSeidel, SOR, WalkerChae, Power
};
NativeLinearEquationSolverSettings();
@ -25,15 +25,18 @@ namespace storm {
void setRelativeTerminationCriterion(bool value);
void setOmega(ValueType omega);
void setPowerMethodMultiplicationStyle(MultiplicationStyle value);
void setForceSoundness(bool value);
SolutionMethod getSolutionMethod() const;
ValueType getPrecision() const;
uint64_t getMaximalNumberOfIterations() const;
uint64_t getRelativeTerminationCriterion() const;
ValueType getOmega() const;
MultiplicationStyle getPowerMethodMultiplicationStyle() const;
bool getForceSoundness() const;
private:
bool forceSoundness;
SolutionMethod method;
double precision;
bool relative;
@ -55,7 +58,6 @@ namespace storm {
virtual void setMatrix(storm::storage::SparseMatrix<ValueType> const& A) override;
virtual void setMatrix(storm::storage::SparseMatrix<ValueType>&& A) override;
virtual bool solveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const override;
virtual void multiply(std::vector<ValueType>& x, std::vector<ValueType> const* b, std::vector<ValueType>& result) const override;
virtual void multiplyAndReduce(OptimizationDirection const& dir, std::vector<uint64_t> const& rowGroupIndices, std::vector<ValueType>& x, std::vector<ValueType> const* b, std::vector<ValueType>& result, std::vector<uint_fast64_t>* choices = nullptr) const override;
virtual bool supportsGaussSeidelMultiplication() const override;
@ -69,6 +71,9 @@ namespace storm {
virtual void clearCache() const override;
protected:
virtual bool internalSolveEquations(std::vector<ValueType>& x, std::vector<ValueType> const& b) const override;
private:
virtual uint64_t getMatrixRowCount() const override;
virtual uint64_t getMatrixColumnCount() const override;
@ -95,6 +100,7 @@ namespace storm {
// cached auxiliary data
mutable std::unique_ptr<std::pair<storm::storage::SparseMatrix<ValueType>, std::vector<ValueType>>> jacobiDecomposition;
mutable std::unique_ptr<std::vector<ValueType>> cachedRowVector2; // A.getRowCount() rows
struct WalkerChaeData {
WalkerChaeData(storm::storage::SparseMatrix<ValueType> const& originalMatrix, std::vector<ValueType> const& originalB);

4
src/storm/solver/SymbolicMinMaxLinearEquationSolver.cpp
View File

@ -263,12 +263,12 @@ namespace storm {
if (equationSystemType == EquationSystemType::UntilProbabilities) {
if (this->getSettings().getSolutionMethod() == SymbolicMinMaxLinearEquationSolverSettings<ValueType>::SolutionMethod::PolicyIteration) {
if (!direction || direction.get() == OptimizationDirection::Maximize) {
requirements.set(MinMaxLinearEquationSolverRequirements::Element::ValidInitialScheduler);
requirements.requireValidInitialScheduler();
}
}
} else if (equationSystemType == EquationSystemType::ReachabilityRewards) {
if (!direction || direction.get() == OptimizationDirection::Minimize) {
requirements.set(MinMaxLinearEquationSolverRequirements::Element::ValidInitialScheduler);
requirements.requireValidInitialScheduler();
}
}

Write Preview
|||||||
100:0
Loading…
Cancel
Save