X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/b83ad9c88af4715987015ddc91ac93ad749df428..0ff40b115c4a7f131b2ffab880faf600e96cfc06:/src/mc/mc_checkpoint.cpp

diff --git a/src/mc/mc_checkpoint.cpp b/src/mc/mc_checkpoint.cpp
index 84cdfd820a..abd51e2e77 100644
--- a/src/mc/mc_checkpoint.cpp
+++ b/src/mc/mc_checkpoint.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2008-2015. The SimGrid Team.
+/* Copyright (c) 2008-2017. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -6,36 +6,36 @@
 
 #include <unistd.h>
 
+#include <cstring>
+#include <dirent.h>
 #include <fcntl.h>
-#include <string.h>
 #include <link.h>
-#include <dirent.h>
 
 #ifndef WIN32
 #include <sys/mman.h>
 #endif
 
 #include "src/internal_config.h"
-#include "src/mc/mc_private.h"
-#include "src/smpi/private.h"
+#include "src/mc/mc_private.hpp"
+#include "src/smpi/include/private.hpp"
 #include "xbt/mmalloc.h"
 #include "xbt/module.h"
 
 #include "src/xbt/mmalloc/mmprivate.h"
 
-#include "src/simix/smx_private.h"
+#include "src/simix/smx_private.hpp"
 
 #include <libunwind.h>
 #include <libelf.h>
 
-#include "src/mc/mc_private.h"
+#include "src/mc/mc_private.hpp"
 #include <mc/mc.h>
 
 #include "src/mc/mc_hash.hpp"
-#include "src/mc/mc_mmu.h"
-#include "src/mc/mc_smx.h"
-#include "src/mc/mc_snapshot.h"
-#include "src/mc/mc_unw.h"
+#include "src/mc/mc_mmu.hpp"
+#include "src/mc/mc_smx.hpp"
+#include "src/mc/mc_snapshot.hpp"
+#include "src/mc/mc_unw.hpp"
 #include "src/mc/remote/mc_protocol.h"
 
 #include "src/mc/RegionSnapshot.hpp"
@@ -60,11 +60,6 @@ namespace mc {
 static void restore(mc_mem_region_t region)
 {
   switch(region->storage_type()) {
-  case simgrid::mc::StorageType::NoData:
-  default:
-    xbt_die("Storage type not supported");
-    break;
-
   case simgrid::mc::StorageType::Flat:
     mc_model_checker->process().write_bytes(region->flat_data().get(),
       region->size(), region->permanent_address());
@@ -78,6 +73,10 @@ static void restore(mc_mem_region_t region)
     for (auto& p : region->privatized_data())
       restore(&p);
     break;
+
+  default: // includes StorageType::NoData
+    xbt_die("Storage type not supported");
+    break;
   }
 }
 
@@ -89,21 +88,21 @@ RegionSnapshot privatized_region(
 {
   size_t process_count = MC_smpi_process_count();
 
-  // Read smpi_privatisation_regions from MCed:
-  smpi_privatisation_region_t remote_smpi_privatisation_regions;
+  // Read smpi_privatization_regions from MCed:
+  smpi_privatization_region_t remote_smpi_privatization_regions;
   mc_model_checker->process().read_variable(
-    "smpi_privatisation_regions",
-    &remote_smpi_privatisation_regions, sizeof(remote_smpi_privatisation_regions));
-  s_smpi_privatisation_region_t privatisation_regions[process_count];
+    "smpi_privatization_regions",
+    &remote_smpi_privatization_regions, sizeof(remote_smpi_privatization_regions));
+  s_smpi_privatization_region_t privatization_regions[process_count];
   mc_model_checker->process().read_bytes(
-    &privatisation_regions, sizeof(privatisation_regions),
-    remote(remote_smpi_privatisation_regions));
+    &privatization_regions, sizeof(privatization_regions),
+    remote(remote_smpi_privatization_regions));
 
   std::vector<simgrid::mc::RegionSnapshot> data;
   data.reserve(process_count);
   for (size_t i = 0; i < process_count; i++)
     data.push_back(simgrid::mc::region(region_type, start_addr,
-      privatisation_regions[i].address, size));
+      privatization_regions[i].address, size));
 
   simgrid::mc::RegionSnapshot region = simgrid::mc::RegionSnapshot(
     region_type, start_addr, permanent_addr, size);
@@ -122,7 +121,7 @@ void add_region(int index, simgrid::mc::Snapshot* snapshot,
   if (type == simgrid::mc::RegionType::Data)
     xbt_assert(object_info, "Missing object info for object.");
   else if (type == simgrid::mc::RegionType::Heap)
-    xbt_assert(!object_info, "Unexpected object info for heap region.");
+    xbt_assert(not object_info, "Unexpected object info for heap region.");
 
   simgrid::mc::RegionSnapshot region;
 #if HAVE_SMPI
@@ -142,7 +141,7 @@ void add_region(int index, simgrid::mc::Snapshot* snapshot,
   return;
 }
 
-static void get_memory_regions(simgrid::mc::Process* process, simgrid::mc::Snapshot* snapshot)
+static void get_memory_regions(simgrid::mc::RemoteClient* process, simgrid::mc::Snapshot* snapshot)
 {
   const size_t n = process->object_infos.size();
   snapshot->snapshot_regions.resize(n + 1);
@@ -201,9 +200,7 @@ void find_object_address(
 
     // This is the non-GNU_RELRO-part of the data segment:
     if (reg.prot == PROT_RW) {
-      xbt_assert(!result->start_rw,
-                 "Multiple read-write segments for %s, not supported",
-                 maps[i].pathname.c_str());
+      xbt_assert(not result->start_rw, "Multiple read-write segments for %s, not supported", maps[i].pathname.c_str());
       result->start_rw = (char*) reg.start_addr;
       result->end_rw = (char*) reg.end_addr;
 
@@ -217,8 +214,7 @@ void find_object_address(
 
     // This is the text segment:
     else if (reg.prot == PROT_RX) {
-      xbt_assert(!result->start_exec,
-                 "Multiple executable segments for %s, not supported",
+      xbt_assert(not result->start_exec, "Multiple executable segments for %s, not supported",
                  maps[i].pathname.c_str());
       result->start_exec = (char*) reg.start_addr;
       result->end_exec = (char*) reg.end_addr;
@@ -235,9 +231,7 @@ void find_object_address(
 
     // This is the GNU_RELRO-part of the data segment:
     else if (reg.prot == PROT_READ) {
-      xbt_assert(!result->start_ro,
-                 "Multiple read only segments for %s, not supported",
-                 maps[i].pathname.c_str());
+      xbt_assert(not result->start_ro, "Multiple read only segments for %s, not supported", maps[i].pathname.c_str());
       result->start_ro = (char*) reg.start_addr;
       result->end_ro = (char*) reg.end_addr;
     }
@@ -283,20 +277,17 @@ static bool valid_variable(simgrid::mc::Variable* var,
     return true;
 }
 
-static void fill_local_variables_values(mc_stack_frame_t stack_frame,
-                                           simgrid::mc::Frame* scope,
-                                           int process_index,
-                                           std::vector<s_local_variable>& result)
+static void fill_local_variables_values(mc_stack_frame_t stack_frame, simgrid::mc::Frame* scope, int process_index,
+                                        std::vector<s_local_variable_t>& result)
 {
-  simgrid::mc::Process* process = &mc_model_checker->process();
+  simgrid::mc::RemoteClient* process = &mc_model_checker->process();
 
-  if (!scope || !scope->range.contain(stack_frame->ip))
+  if (not scope || not scope->range.contain(stack_frame->ip))
     return;
 
-  for(simgrid::mc::Variable& current_variable :
-      scope->variables) {
+  for (simgrid::mc::Variable& current_variable : scope->variables) {
 
-    if (!valid_variable(&current_variable, scope, (void *) stack_frame->ip))
+    if (not valid_variable(&current_variable, scope, (void*)stack_frame->ip))
       continue;
 
     int region_type;
@@ -316,7 +307,7 @@ static void fill_local_variables_values(mc_stack_frame_t stack_frame,
 
     if (current_variable.address != nullptr)
       new_var.address = current_variable.address;
-    else if (!current_variable.location_list.empty()) {
+    else if (not current_variable.location_list.empty()) {
       simgrid::dwarf::Location location =
         simgrid::dwarf::resolve(
           current_variable.location_list,
@@ -325,7 +316,7 @@ static void fill_local_variables_values(mc_stack_frame_t stack_frame,
           (void *) stack_frame->frame_base,
           &mc_model_checker->process(), process_index);
 
-      if (!location.in_memory())
+      if (not location.in_memory())
         xbt_die("Cannot handle non-address variable");
       new_var.address = location.address();
 
@@ -336,15 +327,15 @@ static void fill_local_variables_values(mc_stack_frame_t stack_frame,
   }
 
   // Recursive processing of nested scopes:
-  for(simgrid::mc::Frame& nested_scope : scope->scopes)
+  for (simgrid::mc::Frame& nested_scope : scope->scopes)
     fill_local_variables_values(
       stack_frame, &nested_scope, process_index, result);
 }
 
-static std::vector<s_local_variable> 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,
+                                                                  int process_index)
 {
-  std::vector<s_local_variable> variables;
+  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);
   return variables;
@@ -352,7 +343,7 @@ static std::vector<s_local_variable> get_local_variables_values(
 
 static std::vector<s_mc_stack_frame_t> unwind_stack_frames(simgrid::mc::UnwindContext* stack_context)
 {
-  simgrid::mc::Process* process = &mc_model_checker->process();
+  simgrid::mc::RemoteClient* process = &mc_model_checker->process();
   std::vector<s_mc_stack_frame_t> result;
 
   unw_cursor_t c = stack_context->cursor();
@@ -408,7 +399,7 @@ static std::vector<s_mc_stack_frame_t> unwind_stack_frames(simgrid::mc::UnwindCo
   }
 
   return result;
-};
+}
 
 static std::vector<s_mc_snapshot_stack_t> take_snapshot_stacks(simgrid::mc::Snapshot* snapshot)
 {
@@ -444,7 +435,7 @@ static std::vector<s_mc_snapshot_stack_t> take_snapshot_stacks(simgrid::mc::Snap
 static void snapshot_handle_ignore(simgrid::mc::Snapshot* snapshot)
 {
   xbt_assert(snapshot->process());
-  
+
   // Copy the memory:
   for (auto const& region : mc_model_checker->process().ignored_regions()) {
     s_mc_snapshot_ignored_data_t ignored_data;
@@ -458,7 +449,7 @@ static void snapshot_handle_ignore(simgrid::mc::Snapshot* snapshot)
   }
 
   // Zero the memory:
-  for(auto const& region : mc_model_checker->process().ignored_regions())
+  for (auto const& region : mc_model_checker->process().ignored_regions())
     snapshot->process()->clear_bytes(remote(region.addr), region.size);
 
 }
@@ -515,7 +506,7 @@ static std::vector<s_fd_infos_t> get_current_fds(pid_t pid)
     link[res] = '\0';
 
 #if HAVE_SMPI
-    if(smpi_is_privatisation_file(link))
+    if(smpi_is_privatization_file(link))
       continue;
 #endif
 
@@ -560,11 +551,11 @@ std::shared_ptr<simgrid::mc::Snapshot> take_snapshot(int num_state)
 {
   XBT_DEBUG("Taking snapshot %i", num_state);
 
-  simgrid::mc::Process* mc_process = &mc_model_checker->process();
+  simgrid::mc::RemoteClient* mc_process = &mc_model_checker->process();
 
   std::shared_ptr<simgrid::mc::Snapshot> snapshot = std::make_shared<simgrid::mc::Snapshot>(mc_process, num_state);
 
-  for (auto& p : mc_model_checker->process().actors())
+  for (auto const& p : mc_model_checker->process().actors())
     snapshot->enabled_processes.insert(p.copy.getBuffer()->pid);
 
   snapshot_handle_ignore(snapshot.get());
@@ -593,19 +584,16 @@ std::shared_ptr<simgrid::mc::Snapshot> take_snapshot(int num_state)
 static inline
 void restore_snapshot_regions(simgrid::mc::Snapshot* snapshot)
 {
-  for(std::unique_ptr<s_mc_mem_region_t> const& region : snapshot->snapshot_regions) {
+  for (std::unique_ptr<s_mc_mem_region_t> const& region : snapshot->snapshot_regions) {
     // For privatized, variables we decided it was not necessary to take the snapshot:
     if (region)
       restore(region.get());
   }
 
 #if HAVE_SMPI
-  // TODO, send a message to implement this in the MCed process
   if(snapshot->privatization_index >= 0) {
     // Fix the privatization mmap:
-    s_mc_restore_message message;
-    message.type = MC_MESSAGE_RESTORE;
-    message.index = snapshot->privatization_index;
+    s_mc_message_restore message{MC_MESSAGE_RESTORE, snapshot->privatization_index};
     mc_model_checker->process().getChannel().send(message);
   }
 #endif
@@ -617,15 +605,14 @@ void restore_snapshot_fds(simgrid::mc::Snapshot* snapshot)
   xbt_die("FD snapshot not implemented in client/server mode.");
 
   for (auto const& fd : snapshot->current_fds) {
-    
+
     int new_fd = open(fd.filename.c_str(), fd.flags);
     if (new_fd < 0)
-      xbt_die("Could not reopen the file %s fo restoring the file descriptor",
-        fd.filename.c_str());
+      xbt_die("Could not reopen the file %s fo restoring the file descriptor", fd.filename.c_str());
     if (new_fd != fd.number) {
       dup2(new_fd, fd.number);
       close(new_fd);
-    };
+    }
     lseek(fd.number, fd.current_position, SEEK_SET);
   }
 }