#include <type_traits>
#include <vector>
#include <memory>
+#include <string>
#include <sys/types.h>
#include <xbt/mmalloc.h>
#include "src/xbt/mmalloc/mmprivate.h"
-#include "src/mc/Channel.hpp"
+
+#include "src/mc/remote/Channel.hpp"
+#include "src/mc/remote/RemotePtr.hpp"
#include <simgrid/simix.h>
#include "src/simix/popping_private.h"
#include "src/xbt/memory_map.hpp"
-#include "src/mc/mc_forward.hpp"
-#include "src/mc/mc_base.h"
#include "src/mc/AddressSpace.hpp"
-#include "src/mc/mc_protocol.h"
#include "src/mc/ObjectInformation.hpp"
-
+#include "src/mc/mc_base.h"
+#include "src/mc/mc_forward.hpp"
+#include "src/mc/remote/mc_protocol.h"
namespace simgrid {
namespace mc {
-class SimixProcessInformation {
+class ActorInformation {
public:
/** MCed address of the process */
- void* address = nullptr;
- union {
- /** (Flat) Copy of the process data structure */
- struct s_smx_process copy;
- };
+ RemotePtr<simgrid::simix::ActorImpl> address = nullptr;
+ Remote<simgrid::simix::ActorImpl> copy;
+
/** Hostname (owned by `mc_modelchecker->hostnames`) */
const char* hostname = nullptr;
std::string name;
/** Representation of a process
*
- * This class is mixing a lot of differents responsabilities and is tied
- * to SIMIX. It should probably split into different classes.
+ * This class is mixing a lot of different responsibilities and is tied
+ * to SIMIX. It should probably be split into different classes.
*
- * Responsabilities:
+ * Responsibilities:
*
* - reading from the process memory (`AddressSpace`);
- * - accessing the system state of the porcess (heap, …);
+ * - accessing the system state of the process (heap, …);
* - storing the SIMIX state of the process;
* - privatization;
* - communication with the model-checked process;
const void* read_bytes(void* buffer, std::size_t size,
RemotePtr<void> address, int process_index = ProcessIndexAny,
ReadOptions options = ReadOptions::none()) const override;
+
void read_variable(const char* name, void* target, size_t size) const;
+ template<class T> void read_variable(const char* name, T* target) const
+ {
+ read_variable(name, target, sizeof(*target));
+ }
template<class T>
- T read_variable(const char *name) const
+ Remote<T> read_variable(const char *name) const
{
- static_assert(std::is_trivial<T>::value, "Cannot read a non-trivial type");
- T res;
- read_variable(name, &res, sizeof(T));
+ Remote<T> res;
+ read_variable(name, res.getBuffer(), sizeof(T));
return res;
}
- char* read_string(RemotePtr<void> address) const;
+
+ std::string read_string(RemotePtr<char> address) const;
+ std::string read_string(RemotePtr<char> address, std::size_t len) const
+ {
+ return AddressSpace::read_string(address, len);
+ }
// Write memory:
void write_bytes(const void* buffer, size_t len, RemotePtr<void> address);
this->refresh_heap();
return this->heap.get();
}
- malloc_info* get_malloc_info()
+ const malloc_info* get_malloc_info()
{
if (!(this->cache_flags_ & Process::cache_malloc))
this->refresh_malloc_info();
running_ = false;
}
- void reset_soft_dirty();
- void read_pagemap(uint64_t* pagemap, size_t start_page, size_t page_count);
-
bool privatized(ObjectInformation const& info) const
{
return privatized_ && info.executable();
void unignore_heap(void *address, size_t size);
void ignore_local_variable(const char *var_name, const char *frame_name);
- std::vector<simgrid::mc::SimixProcessInformation>& simix_processes();
- std::vector<simgrid::mc::SimixProcessInformation>& old_simix_processes();
+ std::vector<simgrid::mc::ActorInformation>& actors();
+ std::vector<simgrid::mc::ActorInformation>& dead_actors();
+
+ /** Get a local description of a remote SIMIX actor */
+ simgrid::mc::ActorInformation* resolveActorInfo(simgrid::mc::RemotePtr<simgrid::simix::ActorImpl> actor)
+ {
+ xbt_assert(mc_model_checker != nullptr);
+ if (!actor)
+ return nullptr;
+ this->refresh_simix();
+ for (auto& actor_info : this->smx_actors_infos)
+ if (actor_info.address == actor)
+ return &actor_info;
+ for (auto& actor_info : this->smx_dead_actors_infos)
+ if (actor_info.address == actor)
+ return &actor_info;
+ return nullptr;
+ }
+
+ /** Get a local copy of the SIMIX actor structure */
+ simgrid::simix::ActorImpl* resolveActor(simgrid::mc::RemotePtr<simgrid::simix::ActorImpl> process)
+ {
+ simgrid::mc::ActorInformation* actor_info = this->resolveActorInfo(process);
+ if (actor_info)
+ return actor_info->copy.getBuffer();
+ else
+ return nullptr;
+ }
+
+ void dumpStack();
private:
void init_memory_map_info();
RemotePtr<void> maestro_stack_start_, maestro_stack_end_;
int memory_file = -1;
std::vector<IgnoredRegion> ignored_regions_;
- int clear_refs_fd_ = -1;
- int pagemap_fd_ = -1;
bool privatized_ = false;
std::vector<s_stack_region_t> stack_areas_;
std::vector<IgnoredHeapRegion> ignored_heap_;
*
* See mc_smx.c.
*/
- std::vector<SimixProcessInformation> smx_process_infos;
+ std::vector<ActorInformation> smx_actors_infos;
/** Copy of `simix_global->process_to_destroy`
*
* See mc_smx.c.
*/
- std::vector<SimixProcessInformation> smx_old_process_infos;
+ std::vector<ActorInformation> smx_dead_actors_infos;
private:
/** State of the cache (which variables are up to date) */
*/
unw_addr_space_t unw_addr_space;
- /** Underlying libunwind addres-space
+ /** Underlying libunwind address-space
*
* The `find_proc_info`, `put_unwind_info`, `get_dyn_info_list_addr`
* operations of the native MC address space is currently delegated
