Better progress info

Former-commit-id: 2045babf36

src/storm/modelchecker/multiobjective/pcaa/SparseMdpRewardBoundedPcaaWeightVectorChecker.cpp

@@ -5,6 +5,7 @@
 #include "storm/models/sparse/StandardRewardModel.h"
 #include "storm/utility/macros.h"
 #include "storm/utility/vector.h"
+#include "storm/utility/ProgressMeasurement.h"
 #include "storm/logic/Formulas.h"
 #include "storm/solver/MinMaxLinearEquationSolver.h"
 #include "storm/solver/LinearEquationSolver.h"
@@ -39,9 +40,8 @@ namespace storm {
             
             template <class SparseMdpModelType>
             void SparseMdpRewardBoundedPcaaWeightVectorChecker<SparseMdpModelType>::check(std::vector<ValueType> const& weightVector) {
-                STORM_LOG_DEBUG("Analyzing weight vector " << storm::utility::vector::toString(weightVector));
-
                 ++numChecks;
+                STORM_LOG_INFO("Analyzing weight vector #" << numChecks << ": "  << storm::utility::vector::toString(weightVector));
                 
                 // In case we want to export the cdf, we will collect the corresponding data
                 std::vector<std::vector<ValueType>> cdfData;
@@ -61,7 +61,10 @@ namespace storm {
                     STORM_PRINT_AND_LOG("Objective/Dimension/Epoch count is: " << this->objectives.size() << "/" << rewardUnfolding.getEpochManager().getDimensionCount() << "/" <<  epochOrder.size() << "."  << std::endl);
                 }
 
-
+                storm::utility::ProgressMeasurement progress("epochs");
+                progress.setMaxCount(epochOrder.size());
+                progress.startNewMeasurement(0);
+                uint64_t numCheckedEpochs = 0;
                 for (auto const& epoch : epochOrder) {
                     computeEpochSolution(epoch, weightVector, cachedData, precision);
                     if (storm::settings::getModule<storm::settings::modules::IOSettings>().isExportCdfSet() && !rewardUnfolding.getEpochManager().hasBottomDimension(epoch)) {
@@ -76,6 +79,8 @@ namespace storm {
                         cdfEntry.insert(cdfEntry.end(), solutionIt, solution.end());
                         cdfData.push_back(std::move(cdfEntry));
                     }
+                    ++numCheckedEpochs;
+                    progress.updateProgress(numCheckedEpochs);
                 }
                 
                 if (storm::settings::getModule<storm::settings::modules::IOSettings>().isExportCdfSet()) {

src/storm/modelchecker/prctl/helper/SparseMdpPrctlHelper.cpp

@@ -29,6 +29,7 @@
 #include "storm/settings/modules/CoreSettings.h"
 
 #include "storm/utility/Stopwatch.h"
+#include "storm/utility/ProgressMeasurement.h"
 
 #include "storm/exceptions/InvalidStateException.h"
 #include "storm/exceptions/InvalidPropertyException.h"
@@ -99,6 +100,10 @@ namespace storm {
                 if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isSoundSet()) {
                     precision = precision / storm::utility::convertNumber<ValueType>(epochCount);
                 }
+                storm::utility::ProgressMeasurement progress("epochs");
+                progress.setMaxCount(epochOrder.size());
+                progress.startNewMeasurement(0);
+                uint64_t numCheckedEpochs = 0;
                 for (auto const& epoch : epochOrder) {
                     swBuild.start();
                     auto& epochModel = rewardUnfolding.setCurrentEpoch(epoch);
@@ -196,6 +201,8 @@ namespace storm {
                         rewardUnfolding.setSolutionForCurrentEpoch(storm::utility::vector::filterVector(x, epochModel.epochInStates));
                     }
                     swCheck.stop();
+                    ++numCheckedEpochs;
+                    progress.updateProgress(numCheckedEpochs);
                 }
                 
                 std::map<storm::storage::sparse::state_type, ValueType> result;

src/storm/solver/AbstractEquationSolver.cpp

@@ -16,9 +16,9 @@ namespace storm {
         
         template<typename ValueType>
         AbstractEquationSolver<ValueType>::AbstractEquationSolver() {
-            auto const& generalSettings = storm::settings::getModule<storm::settings::modules::GeneralSettings>();
-            showProgressFlag = generalSettings.isVerboseSet();
-            showProgressDelay = generalSettings.getShowProgressDelay();
+            if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isVerboseSet()) {
+                this->progressMeasurement = storm::utility::ProgressMeasurement("iterations");
+            }
         }
         
         template<typename ValueType>
@@ -203,35 +203,29 @@ namespace storm {
         
         template<typename ValueType>
         bool AbstractEquationSolver<ValueType>::isShowProgressSet() const {
-            return showProgressFlag;
+            return this->progressMeasurement.is_initialized();
         }
         
         template<typename ValueType>
         uint64_t AbstractEquationSolver<ValueType>::getShowProgressDelay() const {
-            return showProgressDelay;
+            STORM_LOG_ASSERT(this->isShowProgressSet(), "Tried to get the progress message delay but progress is not shown.");
+            return this->progressMeasurement->getShowProgressDelay();
         }
         
         template<typename ValueType>
         void AbstractEquationSolver<ValueType>::startMeasureProgress(uint64_t startingIteration) const {
-            timeOfStart = std::chrono::high_resolution_clock::now();
-            timeOfLastMessage = timeOfStart;
-            iterationOfLastMessage = startingIteration;
+            if (this->isShowProgressSet()) {
+                this->progressMeasurement->startNewMeasurement(startingIteration);
+            }
         }
         
         template<typename ValueType>
         void AbstractEquationSolver<ValueType>::showProgressIterative(uint64_t iteration, boost::optional<uint64_t> const& bound) const {
             if (this->isShowProgressSet()) {
-                auto now = std::chrono::high_resolution_clock::now();
-                auto durationSinceLastMessage = static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(now - timeOfLastMessage).count());
-                if (durationSinceLastMessage >= this->getShowProgressDelay()) {
-                    uint64_t numberOfIterationsSinceLastMessage = iteration - iterationOfLastMessage;
-                    STORM_LOG_INFO("Completed " << iteration << " iterations "
-                                   << (bound ? "(out of " + std::to_string(bound.get()) + ") " : "")
-                                   << "in " << std::chrono::duration_cast<std::chrono::seconds>(now - timeOfStart).count() << "s (currently " << (static_cast<double>(numberOfIterationsSinceLastMessage) / durationSinceLastMessage) << " per second)."
-                                   );
-                    timeOfLastMessage = std::chrono::high_resolution_clock::now();
-                    iterationOfLastMessage = iteration;
+                if (bound) {
+                    this->progressMeasurement->setMaxCount(bound.get());
                 }
+                this->progressMeasurement->updateProgress(iteration);