simgrid::mc::Checker* checker;
switch (algo) {
case CheckerAlgorithm::CommDeterminism:
- checker = simgrid::mc::createCommunicationDeterminismChecker();
+ checker = simgrid::mc::createCommunicationDeterminismChecker(session);
break;
case CheckerAlgorithm::UDPOR:
- checker = simgrid::mc::createUdporChecker();
+ checker = simgrid::mc::createUdporChecker(session);
break;
case CheckerAlgorithm::Safety:
- checker = simgrid::mc::createSafetyChecker();
+ checker = simgrid::mc::createSafetyChecker(session);
break;
case CheckerAlgorithm::Liveness:
- checker = simgrid::mc::createLivenessChecker();
+ checker = simgrid::mc::createLivenessChecker(session);
break;
default:
* have all the necessary features). */
// abstract
class Checker {
+ Session* session_;
+
public:
- explicit Checker() = default;
+ explicit Checker(Session* session) : session_(session) {}
// No copy:
Checker(Checker const&) = delete;
/** Log additional information about the state of the model-checker */
virtual void log_state() = 0;
+
+ Session* get_session() { return session_; }
};
// External constructors so that the types (and the types of their content) remain hidden
-XBT_PUBLIC Checker* createLivenessChecker();
-XBT_PUBLIC Checker* createSafetyChecker();
-XBT_PUBLIC Checker* createCommunicationDeterminismChecker();
-XBT_PUBLIC Checker* createUdporChecker();
+XBT_PUBLIC Checker* createLivenessChecker(Session* session);
+XBT_PUBLIC Checker* createSafetyChecker(Session* session);
+XBT_PUBLIC Checker* createCommunicationDeterminismChecker(Session* session);
+XBT_PUBLIC Checker* createUdporChecker(Session* session);
} // namespace mc
} // namespace simgrid
}
}
-CommunicationDeterminismChecker::CommunicationDeterminismChecker() : Checker() {}
+CommunicationDeterminismChecker::CommunicationDeterminismChecker(Session* session) : Checker(session) {}
CommunicationDeterminismChecker::~CommunicationDeterminismChecker() = default;
this->real_run();
}
-Checker* createCommunicationDeterminismChecker()
+Checker* createCommunicationDeterminismChecker(Session* session)
{
- return new CommunicationDeterminismChecker();
+ return new CommunicationDeterminismChecker(session);
}
} // namespace mc
class XBT_PRIVATE CommunicationDeterminismChecker : public Checker {
public:
- explicit CommunicationDeterminismChecker();
+ explicit CommunicationDeterminismChecker(Session* session);
~CommunicationDeterminismChecker() override;
void run() override;
RecordTrace get_record_trace() override;
}
}
-LivenessChecker::LivenessChecker() : Checker()
-{
-}
+LivenessChecker::LivenessChecker(Session* session) : Checker(session) {}
RecordTrace LivenessChecker::get_record_trace() // override
{
api::get().log_state();
}
-Checker* createLivenessChecker()
+Checker* createLivenessChecker(Session* session)
{
- return new LivenessChecker();
+ return new LivenessChecker(session);
}
} // namespace mc
class XBT_PRIVATE LivenessChecker : public Checker {
public:
- explicit LivenessChecker();
+ explicit LivenessChecker(Session* session);
void run() override;
RecordTrace get_record_trace() override;
std::vector<std::string> get_textual_trace() override;
}
}
-SafetyChecker::SafetyChecker() : Checker()
+SafetyChecker::SafetyChecker(Session* session) : Checker(session)
{
reductionMode_ = reduction_mode;
if (_sg_mc_termination)
stack_.push_back(std::move(initial_state));
}
-Checker* createSafetyChecker()
+Checker* createSafetyChecker(Session* session)
{
- return new SafetyChecker();
+ return new SafetyChecker(session);
}
} // namespace mc
ReductionMode reductionMode_ = ReductionMode::unset;
public:
- explicit SafetyChecker();
+ explicit SafetyChecker(Session* session);
void run() override;
RecordTrace get_record_trace() override;
std::vector<std::string> get_textual_trace() override;
namespace simgrid {
namespace mc {
-UdporChecker::UdporChecker() : Checker() {}
+UdporChecker::UdporChecker(Session* session) : Checker(session) {}
void UdporChecker::run() {}
void UdporChecker::log_state() {}
-Checker* createUdporChecker()
+Checker* createUdporChecker(Session* session)
{
- return new UdporChecker();
+ return new UdporChecker(session);
}
} // namespace mc
class XBT_PRIVATE UdporChecker : public Checker {
public:
- explicit UdporChecker();
+ explicit UdporChecker(Session* session);
void run() override;
RecordTrace get_record_trace() override;
std::vector<std::string> get_textual_trace() override;
class XBT_PRIVATE Snapshot final : public AddressSpace {
public:
/* Initialization */
- Snapshot(int num_state, RemoteProcess* get_remote_simulation = &mc_model_checker->get_remote_process());
+ Snapshot(int num_state, RemoteProcess* process = &mc_model_checker->get_remote_process());
/* Regular use */
bool on_heap(const void* address) const
ReadOptions options = ReadOptions::none()) const override;
Region* get_region(const void* addr) const;
Region* get_region(const void* addr, Region* hinted_region) const;
- void restore(RemoteProcess* get_remote_simulation) const;
+ void restore(RemoteProcess* process) const;
// To be private
int num_state_;
private:
void add_region(RegionType type, ObjectInformation* object_info, void* start_addr, std::size_t size);
- void snapshot_regions(RemoteProcess* get_remote_simulation);
- void snapshot_stacks(RemoteProcess* get_remote_simulation);
+ void snapshot_regions(RemoteProcess* process);
+ void snapshot_stacks(RemoteProcess* process);
};
} // namespace mc
} // namespace simgrid