[i410e] rm ISimulation::compute ()

Merging branch 'i410e'  into 'main'.

See merge request !1276

Base/Progress/DelayedProgressCounter.cpp

@@ -14,12 +14,15 @@
 
 #include "Base/Progress/DelayedProgressCounter.h"
 #include "Base/Progress/ProgressHandler.h"
+#include <stdexcept>
 
-DelayedProgressCounter::DelayedProgressCounter(ProgressHandler* p_progress, size_t interval)
-    : m_progress(p_progress)
+DelayedProgressCounter::DelayedProgressCounter(ProgressHandler* progress, size_t interval)
+    : m_progress(progress)
     , m_interval(interval)
     , m_count(0)
 {
+    if (!progress->alive())
+        throw std::runtime_error("dead process (user interrupt?)");
 }
 
 void DelayedProgressCounter::stepProgress()

Base/Progress/DelayedProgressCounter.h

@@ -26,7 +26,7 @@ class ProgressHandler;
 
 class DelayedProgressCounter {
 public:
-    DelayedProgressCounter(ProgressHandler* p_progress, size_t interval);
+    DelayedProgressCounter(ProgressHandler* progress, size_t interval);
     ~DelayedProgressCounter() = default;
 
     //! Increments inner counter; at regular intervals updates progress handler.

Sim/Computation/ComputationStatus.h

-//  ************************************************************************************************
-//
-//  BornAgain: simulate and fit reflection and scattering
-//
-//! @file      Sim/Computation/ComputationStatus.h
-//! @brief     Defines and implements interface class ComputationStatus.
-//!
-//! @homepage  http://www.bornagainproject.org
-//! @license   GNU General Public License v3 or higher (see COPYING)
-//! @copyright Forschungszentrum Jülich GmbH 2018
-//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
-//
-//  ************************************************************************************************
-
-#ifdef SWIG
-#error no need to expose this header to Swig
-#endif // SWIG
-#ifndef BORNAGAIN_SIM_COMPUTATION_COMPUTATIONSTATUS_H
-#define BORNAGAIN_SIM_COMPUTATION_COMPUTATIONSTATUS_H
-
-#include <string>
-
-//! Completion status (flag and text) of a numeric computation.
-
-class ComputationStatus {
-public:
-    ComputationStatus()
-        : m_status(IDLE)
-    {
-    }
-
-    bool isCompleted() const { return m_status == COMPLETED; }
-    std::string errorMessage() const { return m_error_message; }
-
-    void setRunning() { m_status = RUNNING; }
-    void setCompleted() { m_status = COMPLETED; }
-    void setFailed(const std::string& message)
-    {
-        m_error_message = message;
-        m_status = FAILED;
-    }
-
-private:
-    enum ESimulationStatus { IDLE, RUNNING, COMPLETED, FAILED };
-
-    ESimulationStatus m_status;
-    std::string m_error_message;
-};
-
-#endif // BORNAGAIN_SIM_COMPUTATION_COMPUTATIONSTATUS_H

Sim/Computation/DWBAComputation.cpp

@@ -43,8 +43,6 @@ DWBAComputation::~DWBAComputation() = default;
 void DWBAComputation::runProtected()
 {
     for (auto it = m_begin_it; it != m_end_it; ++it) {
-        if (!m_progress->alive())
-            break;
         DiffuseElement& ele = *it;
 
         const Fluxes fluxes_in = m_re_sample.fluxesIn(ele.getKi());

Sim/Computation/IComputation.cpp

@@ -21,35 +21,13 @@ IComputation::IComputation(const ReSample& re_sample, const SimulationOptions& o
                            ProgressHandler& progress)
     : m_re_sample(re_sample)
     , m_options(options)
-    , m_progress(&progress)
+    , m_progress_counter(std::make_unique<DelayedProgressCounter>(&progress, 100))
 {
 }
 
 IComputation::~IComputation() = default;
 
-void IComputation::setProgressHandler(ProgressHandler* progress) const
-{
-    m_progress_counter = std::make_unique<DelayedProgressCounter>(progress, 100);
-}
-
 void IComputation::stepProgress() const
 {
-    if (m_progress_counter)
-        m_progress_counter->stepProgress();
-}
-
-void IComputation::compute()
-{
-    m_status.setRunning();
-    try {
-        if (!m_progress->alive())
-            return;
-        setProgressHandler(m_progress);
-
-        runProtected(); // <--- here the main work is done
-
-        m_status.setCompleted();
-    } catch (const std::exception& ex) {
-        m_status.setFailed(ex.what());
-    }
+    m_progress_counter->stepProgress();
 }

Sim/Computation/IComputation.h

@@ -18,11 +18,9 @@
 #ifndef BORNAGAIN_SIM_COMPUTATION_ICOMPUTATION_H
 #define BORNAGAIN_SIM_COMPUTATION_ICOMPUTATION_H
 
-#include "Sim/Computation/ComputationStatus.h"
 #include <memory>
 
 class DelayedProgressCounter;
-class MultiLayer;
 class ReSample;
 class ProgressHandler;
 class SimulationOptions;
@@ -38,26 +36,17 @@ public:
                  ProgressHandler& progress);
     virtual ~IComputation();
 
-    //! Calls runProtected(), catches exceptions, sets m_status.
-    void compute();
-
-    bool isCompleted() const { return m_status.isCompleted(); }
-    std::string errorMessage() const { return m_status.errorMessage(); }
+    //! Runs computation. May throw.
+    virtual void runProtected() = 0;
 
 protected:
-    void setProgressHandler(ProgressHandler* progress) const;
     void stepProgress() const;
 
     const ReSample& m_re_sample;
     const SimulationOptions& m_options;
-    ProgressHandler* m_progress;
 
 private:
-    //! Runs computation. May throw. To be called from runProtected(), which catches exceptions.
-    virtual void runProtected() = 0;
-
     mutable std::unique_ptr<DelayedProgressCounter> m_progress_counter;
-    ComputationStatus m_status;
 };
 
 #endif // BORNAGAIN_SIM_COMPUTATION_ICOMPUTATION_H

Sim/Simulation/ISimulation.cpp

@@ -25,6 +25,7 @@
 #include "Sim/Computation/IComputation.h"
 #include <gsl/gsl_errno.h>
 #include <iostream>
+#include <mutex>
 #include <thread>
 
 namespace {
@@ -130,7 +131,7 @@ SimulationResult ISimulation::simulate()
 
     prepareSimulation();
 
-    const auto re_sample = ReSample::make(*m_sample, options(), force_polarized());
+    const ReSample re_sample = ReSample::make(*m_sample, options(), force_polarized());
 
     const size_t total_size = numberOfElements();
     size_t param_combinations = distributionHandler().getTotalNumberOfSamples();
@@ -217,41 +218,44 @@ void ISimulation::runSingleSimulation(const ReSample& re_sample, size_t batch_st
 
     if (n_threads == 1) {
         // Run computation in current thread.
-        const auto& c = createComputation(re_sample, batch_start, batch_size);
-        c->compute(); // <---- here most work is done (unthreaded case)!
-        if (!c->isCompleted())
-            throw std::runtime_error("Unexpected error in simulation:\n" + c->errorMessage());
+        try {
+            const auto& c = createComputation(re_sample, batch_start, batch_size);
+            c->runProtected(); // <---- here most work is done (unthreaded case)!
+        } catch (const std::exception& ex) {
+            throw std::runtime_error(std::string("Unexpected error in simulation:\n") + ex.what());
+        }
 
     } else {
-        // Create batch computations.
-        std::vector<std::unique_ptr<IComputation>> computations;
+        // Launch computation threads.
+        std::vector<std::unique_ptr<std::thread>> threads;
+        std::vector<std::string> failure_messages;
+        std::mutex mutex;
         for (size_t i_thread = 0; i_thread < n_threads; ++i_thread) {
             const size_t thread_start = batch_start + startIndex(n_threads, i_thread, batch_size);
             const size_t thread_size = batchSize(n_threads, i_thread, batch_size);
             if (thread_size == 0)
                 break;
-            computations.emplace_back(createComputation(re_sample, thread_start, thread_size));
+            threads.emplace_back(new std::thread(
+                [this, &re_sample, &failure_messages, &mutex, thread_start, thread_size]() {
+                    try {
+                        const auto& c = createComputation(re_sample, thread_start, thread_size);
+                        c->runProtected(); // <---- here most work is done (threaded case)!
+                    } catch (const std::exception& ex) {
+                        mutex.lock();
+                        failure_messages.push_back(ex.what());
+                        mutex.unlock();
+                    }
+                }));
         }
 
-        // Run computations in several threads.
-        std::vector<std::unique_ptr<std::thread>> threads;
-        for (const auto& c : computations)
-            threads.emplace_back(new std::thread([&c]() {
-                c->compute(); // <---- here most work is done (threaded case)!
-            }));
-
         // Wait for threads to complete.
         for (auto& thread : threads)
             thread->join();
 
         // Check successful completion.
-        std::vector<std::string> failure_messages;
-        for (const auto& c : computations)
-            if (!c->isCompleted())
-                failure_messages.push_back(c->errorMessage());
         if (!failure_messages.empty())
-            throw std::runtime_error("Unexpected error in simulation thread(s):\n"
-                                     + BaseUtils::String::join(failure_messages, " --- "));
+            throw std::runtime_error("Unexpected error(s) in simulation thread(s):\n"
+                                     + BaseUtils::String::join(failure_messages, "\n"));
     }
 
     normalize(batch_start, batch_size);