// Read each page:
while (simgrid::mc::mmu::split((std::uintptr_t)addr).first != page_end) {
- void* snapshot_addr = mc_translate_address_region_chunked((uintptr_t)addr, region);
+ void* snapshot_addr = mc_translate_address_region((uintptr_t)addr, region);
void* next_page = (void*)simgrid::mc::mmu::join(simgrid::mc::mmu::split((std::uintptr_t)addr).first + 1, 0);
size_t readable = (char*)next_page - (char*)addr;
memcpy(dest, snapshot_addr, readable);
}
// Read the end:
- void* snapshot_addr = mc_translate_address_region_chunked((uintptr_t)addr, region);
+ void* snapshot_addr = mc_translate_address_region((uintptr_t)addr, region);
memcpy(dest, snapshot_addr, size);
return target;
// Using alloca() for large allocations may trigger stack overflow:
// use malloc if the buffer is too big.
bool stack_alloc = size < 64;
- void* buffer1a = nullptr;
- void* buffer2a = nullptr;
- if (region1 != nullptr && region1->storage_type() != simgrid::mc::StorageType::Flat)
- buffer1a = stack_alloc ? alloca(size) : ::operator new(size);
- if (region2 != nullptr && region2->storage_type() != simgrid::mc::StorageType::Flat)
- buffer2a = stack_alloc ? alloca(size) : ::operator new(size);
+ void* buffer1a = stack_alloc ? alloca(size) : ::operator new(size);
+ void* buffer2a = stack_alloc ? alloca(size) : ::operator new(size);
const void* buffer1 = MC_region_read(region1, buffer1a, addr1, size);
const void* buffer2 = MC_region_read(region2, buffer2a, addr2, size);
int res;
/************************************* Take Snapshot ************************************/
/****************************************************************************************/
-static void get_memory_regions(simgrid::mc::RemoteClient* process, simgrid::mc::Snapshot* snapshot)
+void simgrid::mc::Snapshot::snapshot_regions(simgrid::mc::RemoteClient* process)
{
- snapshot->snapshot_regions_.clear();
+ snapshot_regions_.clear();
for (auto const& object_info : process->object_infos)
- snapshot->add_region(simgrid::mc::RegionType::Data, object_info.get(), object_info->start_rw, object_info->start_rw,
- object_info->end_rw - object_info->start_rw);
+ add_region(simgrid::mc::RegionType::Data, object_info.get(), object_info->start_rw, object_info->start_rw,
+ object_info->end_rw - object_info->start_rw);
xbt_mheap_t heap = process->get_heap();
void* start_heap = heap->base;
void* end_heap = heap->breakval;
- snapshot->add_region(simgrid::mc::RegionType::Heap, nullptr, start_heap, start_heap,
- (char*)end_heap - (char*)start_heap);
- snapshot->heap_bytes_used_ = mmalloc_get_bytes_used_remote(heap->heaplimit, process->get_malloc_info());
- snapshot->privatization_index_ = simgrid::mc::ProcessIndexMissing;
-
-#if HAVE_SMPI
- if (mc_model_checker->process().privatized() && MC_smpi_process_count())
- // snapshot->privatization_index = smpi_loaded_page
- mc_model_checker->process().read_variable("smpi_loaded_page", &snapshot->privatization_index_,
- sizeof(snapshot->privatization_index_));
-#endif
+ add_region(simgrid::mc::RegionType::Heap, nullptr, start_heap, start_heap, (char*)end_heap - (char*)start_heap);
+ heap_bytes_used_ = mmalloc_get_bytes_used_remote(heap->heaplimit, process->get_malloc_info());
}
+
/** @brief Checks whether the variable is in scope for a given IP.
*
* A variable may be defined only from a given value of IP.
return true;
}
-static void fill_local_variables_values(mc_stack_frame_t stack_frame, simgrid::mc::Frame* scope, int process_index,
+static void fill_local_variables_values(mc_stack_frame_t stack_frame, simgrid::mc::Frame* scope,
std::vector<s_local_variable_t>& result)
{
if (not scope || not scope->range.contain(stack_frame->ip))
else if (not current_variable.location_list.empty()) {
simgrid::dwarf::Location location = simgrid::dwarf::resolve(
current_variable.location_list, current_variable.object_info, &(stack_frame->unw_cursor),
- (void*)stack_frame->frame_base, &mc_model_checker->process(), process_index);
+ (void*)stack_frame->frame_base, &mc_model_checker->process());
if (not location.in_memory())
xbt_die("Cannot handle non-address variable");
// Recursive processing of nested scopes:
for (simgrid::mc::Frame& nested_scope : scope->scopes)
- fill_local_variables_values(stack_frame, &nested_scope, process_index, result);
+ fill_local_variables_values(stack_frame, &nested_scope, result);
}
-static std::vector<s_local_variable_t> get_local_variables_values(std::vector<s_mc_stack_frame_t>& stack_frames,
- int process_index)
+static std::vector<s_local_variable_t> get_local_variables_values(std::vector<s_mc_stack_frame_t>& stack_frames)
{
std::vector<s_local_variable_t> variables;
for (s_mc_stack_frame_t& stack_frame : stack_frames)
- fill_local_variables_values(&stack_frame, stack_frame.frame, process_index, variables);
+ fill_local_variables_values(&stack_frame, stack_frame.frame, variables);
return variables;
}
return result;
}
-static void take_snapshot_stacks(simgrid::mc::Snapshot* snapshot)
+void simgrid::mc::Snapshot::snapshot_stacks(simgrid::mc::RemoteClient* process)
{
- for (auto const& stack : mc_model_checker->process().stack_areas()) {
+ for (auto const& stack : process->stack_areas()) {
s_mc_snapshot_stack_t st;
// Read the context from remote process:
st.context.initialize(&mc_model_checker->process(), &context);
st.stack_frames = unwind_stack_frames(&st.context);
- st.local_variables = get_local_variables_values(st.stack_frames, stack.process_index);
- st.process_index = stack.process_index;
+ st.local_variables = get_local_variables_values(st.stack_frames);
unw_word_t sp = st.stack_frames[0].sp;
- snapshot->stacks_.push_back(std::move(st));
+ stacks_.push_back(std::move(st));
size_t stack_size = (char*)stack.address + stack.size - (char*)sp;
- snapshot->stack_sizes_.push_back(stack_size);
+ stack_sizes_.push_back(stack_size);
}
}
ignored_data.start = (void*)region.addr;
ignored_data.data.resize(region.size);
// TODO, we should do this once per privatization segment:
- snapshot->process()->read_bytes(ignored_data.data.data(), region.size, remote(region.addr),
- simgrid::mc::ProcessIndexDisabled);
+ snapshot->process()->read_bytes(ignored_data.data.data(), region.size, remote(region.addr));
snapshot->ignored_data_.push_back(std::move(ignored_data));
}
, num_state_(_num_state)
, heap_bytes_used_(0)
, enabled_processes_()
- , privatization_index_(0)
, hash_(0)
{
- for (auto const& p : mc_model_checker->process().actors())
- enabled_processes_.insert(p.copy.getBuffer()->get_pid());
+ for (auto const& p : process->actors())
+ enabled_processes_.insert(p.copy.get_buffer()->get_pid());
snapshot_handle_ignore(this);
/* Save the std heap and the writable mapped pages of libsimgrid and binary */
- get_memory_regions(process, this);
+ snapshot_regions(process);
- to_ignore_ = mc_model_checker->process().ignored_heap();
+ to_ignore_ = process->ignored_heap();
if (_sg_mc_max_visited_states > 0 || not _sg_mc_property_file.get().empty()) {
- take_snapshot_stacks(this);
+ snapshot_stacks(process);
if (_sg_mc_hash)
hash_ = simgrid::mc::hash(*this);
}
else if (type == simgrid::mc::RegionType::Heap)
xbt_assert(not object_info, "Unexpected object info for heap region.");
- simgrid::mc::RegionSnapshot* region;
-#if HAVE_SMPI
- const bool privatization_aware = object_info && mc_model_checker->process().privatized(*object_info);
- if (privatization_aware && MC_smpi_process_count())
- region = new RegionPrivatized(type, start_addr, permanent_addr, size);
- else
-#endif
- region = simgrid::mc::region(type, start_addr, permanent_addr, size);
-
+ simgrid::mc::RegionSnapshot* region = simgrid::mc::region(type, start_addr, permanent_addr, size);
region->object_info(object_info);
snapshot_regions_.push_back(std::unique_ptr<simgrid::mc::RegionSnapshot>(std::move(region)));
}
-const void* Snapshot::read_bytes(void* buffer, std::size_t size, RemotePtr<void> address, int process_index,
- ReadOptions options) const
+const void* Snapshot::read_bytes(void* buffer, std::size_t size, RemotePtr<void> address, ReadOptions options) const
{
- RegionSnapshot* region = this->get_region((void*)address.address(), process_index);
+ RegionSnapshot* region = this->get_region((void*)address.address());
if (region) {
const void* res = MC_region_read(region, buffer, (void*)address.address(), size);
if (buffer == res || options & ReadOptions::lazy())
return buffer;
}
} else
- return this->process()->read_bytes(buffer, size, address, process_index, options);
+ return this->process()->read_bytes(buffer, size, address, options);
}
/** @brief Find the snapshoted region from a pointer
*
* @param addr Pointer
- * @param process_index rank requesting the region
* */
-RegionSnapshot* Snapshot::get_region(const void* addr, int process_index) const
+RegionSnapshot* Snapshot::get_region(const void* addr) const
{
size_t n = snapshot_regions_.size();
for (size_t i = 0; i != n; ++i) {
if (not(region && region->contain(simgrid::mc::remote(addr))))
continue;
- if (region->storage_type() == simgrid::mc::StorageType::Privatized) {
-#if HAVE_SMPI
- // Use the current process index of the snapshot:
- if (process_index == simgrid::mc::ProcessIndexDisabled)
- process_index = privatization_index_;
- xbt_assert(process_index >= 0, "Missing process index");
- xbt_assert(process_index < (int)region->privatized_data().size(), "Invalid process index");
-
- RegionSnapshot* priv_region = region->privatized_data()[process_index].get();
- xbt_assert(priv_region->contain(simgrid::mc::remote(addr)));
- return priv_region;
-#else
- xbt_die("Privatized region in a non SMPI build (this should not happen)");
-#endif
- }
-
return region;
}
}
/** @brief Find the snapshoted region from a pointer, with a hinted_region */
-RegionSnapshot* Snapshot::get_region(const void* addr, int process_index, RegionSnapshot* hinted_region) const
+RegionSnapshot* Snapshot::get_region(const void* addr, RegionSnapshot* hinted_region) const
{
if (hinted_region->contain(simgrid::mc::remote(addr)))
return hinted_region;
else
- return get_region(addr, process_index);
+ return get_region(addr);
}
-static inline void restore_snapshot_regions(simgrid::mc::Snapshot* snapshot)
+void Snapshot::restore(RemoteClient* process)
{
- for (std::unique_ptr<simgrid::mc::RegionSnapshot> const& region : snapshot->snapshot_regions_) {
- // For privatized, variables we decided it was not necessary to take the snapshot:
- if (region)
- region.get()->restore();
- }
+ XBT_DEBUG("Restore snapshot %i", num_state_);
-#if HAVE_SMPI
- if (snapshot->privatization_index_ >= 0) {
- // Fix the privatization mmap:
- s_mc_message_restore_t message{MC_MESSAGE_RESTORE, snapshot->privatization_index_};
- mc_model_checker->process().getChannel().send(message);
+ // Restore regions
+ for (std::unique_ptr<simgrid::mc::RegionSnapshot> const& region : snapshot_regions_) {
+ if (region) // privatized variables are not snapshoted
+ region.get()->restore();
}
-#endif
-}
-void restore_snapshot(std::shared_ptr<simgrid::mc::Snapshot> snapshot)
-{
- XBT_DEBUG("Restore snapshot %i", snapshot->num_state_);
- restore_snapshot_regions(snapshot.get());
- snapshot_ignore_restore(snapshot.get());
- mc_model_checker->process().clear_cache();
+ snapshot_ignore_restore(this);
+ process->clear_cache();
}
} // namespace mc
