X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/26af220e017a088b56105b2f21fadecf7d6e2a88..81c638173fb96d986d183561433ac408f0ea5fcf:/src/mc/mc_request.cpp

diff --git a/src/mc/mc_request.cpp b/src/mc/mc_request.cpp
index c3de6850aa..979166090a 100644
--- a/src/mc/mc_request.cpp
+++ b/src/mc/mc_request.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2008-2014. The SimGrid Team.
+/* Copyright (c) 2008-2015. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -10,6 +10,9 @@
 #include "mc_safety.h"
 #include "mc_private.h"
 #include "mc_smx.h"
+#include "mc_xbt.hpp"
+
+using simgrid::mc::remote;
 
 extern "C" {
 
@@ -232,7 +235,7 @@ static char *buff_size_to_string(size_t buff_size)
 
 char *MC_request_to_string(smx_simcall_t req, int value, e_mc_request_type_t request_type)
 {
-  bool use_remote_comm = false;
+  bool use_remote_comm = true;
   switch(request_type) {
   case MC_REQUEST_SIMIX:
     use_remote_comm = true;
@@ -254,7 +257,7 @@ char *MC_request_to_string(smx_simcall_t req, int value, e_mc_request_type_t req
     type = "iSend";
     char* p = pointer_to_string(simcall_comm_isend__get__src_buff(req));
     char* bs = buff_size_to_string(simcall_comm_isend__get__src_buff_size(req));
-    if (issuer->smx_host)
+    if (issuer->host)
       args =
           bprintf("src=(%lu)%s (%s), buff=%s, size=%s", issuer->pid,
                   MC_smx_process_get_host_name(issuer),
@@ -275,13 +278,13 @@ char *MC_request_to_string(smx_simcall_t req, int value, e_mc_request_type_t req
     // size_t size = size_pointer ? *size_pointer : 0;
     size_t size = 0;
     if (remote_size)
-      MC_process_read_simple(&mc_model_checker->process(), &size,
-        remote_size, sizeof(size));
+      mc_model_checker->process().read_bytes(&size, sizeof(size),
+        remote(remote_size));
 
     type = "iRecv";
     char* p = pointer_to_string(simcall_comm_irecv__get__dst_buff(req));
     char* bs = buff_size_to_string(size);
-    if (issuer->smx_host)
+    if (issuer->host)
       args =
           bprintf("dst=(%lu)%s (%s), buff=%s, size=%s", issuer->pid,
                   MC_smx_process_get_host_name(issuer),
@@ -311,8 +314,8 @@ char *MC_request_to_string(smx_simcall_t req, int value, e_mc_request_type_t req
       s_smx_synchro_t synchro;
       smx_synchro_t act;
       if (use_remote_comm) {
-        MC_process_read_simple(&mc_model_checker->process(), &synchro,
-          remote_act, sizeof(synchro));
+        mc_model_checker->process().read_bytes(&synchro,
+          sizeof(synchro), remote(remote_act));
         act = &synchro;
       } else
         act = remote_act;
@@ -336,8 +339,8 @@ char *MC_request_to_string(smx_simcall_t req, int value, e_mc_request_type_t req
     s_smx_synchro_t synchro;
       smx_synchro_t act;
       if (use_remote_comm) {
-        MC_process_read_simple(&mc_model_checker->process(), &synchro,
-          remote_act, sizeof(synchro));
+        mc_model_checker->process().read_bytes(&synchro,
+          sizeof(synchro), remote(remote_act));
         act = &synchro;
       } else
         act = remote_act;
@@ -368,12 +371,12 @@ char *MC_request_to_string(smx_simcall_t req, int value, e_mc_request_type_t req
   case SIMCALL_COMM_WAITANY: {
     type = "WaitAny";
     s_xbt_dynar_t comms;
-    MC_process_read_simple(&mc_model_checker->process(),
-      &comms,  simcall_comm_waitany__get__comms(req), sizeof(comms));
+    mc_model_checker->process().read_bytes(
+      &comms, sizeof(comms), remote(simcall_comm_waitany__get__comms(req)));
     if (!xbt_dynar_is_empty(&comms)) {
       smx_synchro_t remote_sync;
-      MC_process_read_dynar_element(&mc_model_checker->process(),
-        &remote_sync, simcall_comm_waitany__get__comms(req), value,
+      read_element(mc_model_checker->process(),
+        &remote_sync, remote(simcall_comm_waitany__get__comms(req)), value,
         sizeof(remote_sync));
       char* p = pointer_to_string(remote_sync);
       args = bprintf("comm=%s (%d of %lu)",
@@ -392,21 +395,29 @@ char *MC_request_to_string(smx_simcall_t req, int value, e_mc_request_type_t req
     } else {
       type = "TestAny";
       args =
-          bprintf("(%d of %lu)", value + 1,
-                  MC_process_read_dynar_length(&mc_model_checker->process(),
+          bprintf("(%d of %zu)", value + 1,
+                  read_length(mc_model_checker->process(),
                     simcall_comm_testany__get__comms(req)));
     }
     break;
 
+  case SIMCALL_MUTEX_TRYLOCK:
   case SIMCALL_MUTEX_LOCK: {
-    type = "Mutex LOCK";
+    if (req->call == SIMCALL_MUTEX_LOCK)
+      type = "Mutex LOCK";
+    else
+      type = "Mutex TRYLOCK";
 
     s_smx_mutex_t mutex;
-    MC_process_read_simple(&mc_model_checker->process(), &mutex,
-      simcall_mutex_lock__get__mutex(req), sizeof(mutex));
+    mc_model_checker->process().read_bytes(&mutex, sizeof(mutex),
+      remote(
+        req->call == SIMCALL_MUTEX_LOCK
+        ? simcall_mutex_lock__get__mutex(req)
+        : simcall_mutex_trylock__get__mutex(req)
+      ));
     s_xbt_swag_t mutex_sleeping;
-    MC_process_read_simple(&mc_model_checker->process(), &mutex_sleeping,
-      mutex.sleeping, sizeof(mutex_sleeping));
+    mc_model_checker->process().read_bytes(&mutex_sleeping, sizeof(mutex_sleeping),
+      remote(mutex.sleeping));
 
     args = bprintf("locked = %d, owner = %d, sleeping = %d",
       mutex.locked,
@@ -458,14 +469,14 @@ unsigned int MC_request_testany_fail(smx_simcall_t req)
 
   // Read the dynar:
   s_xbt_dynar_t comms;
-  MC_process_read_simple(&mc_model_checker->process(),
-    &comms, simcall_comm_testany__get__comms(req), sizeof(comms));
+  mc_model_checker->process().read_bytes(
+    &comms, sizeof(comms), remote(simcall_comm_testany__get__comms(req)));
 
   // Read ther dynar buffer:
   size_t buffer_size = comms.elmsize * comms.used;
   char buffer[buffer_size];
-  MC_process_read_simple(&mc_model_checker->process(),
-    buffer, comms.data, buffer_size);
+  mc_model_checker->process().read_bytes(
+    buffer, buffer_size, remote(comms.data));
 
   // Iterate over the elements:
   assert(comms.elmsize == sizeof(smx_synchro_t));
@@ -473,13 +484,13 @@ unsigned int MC_request_testany_fail(smx_simcall_t req)
   for (cursor=0; cursor != comms.used; ++cursor) {
 
     // Get the element:
-    smx_synchro_t remote_action;
+    smx_synchro_t remote_action = NULL;
     memcpy(&remote_action, buffer + comms.elmsize * cursor, sizeof(remote_action));
 
     // Dereference the pointer:
     s_smx_synchro_t action;
-    MC_process_read_simple(&mc_model_checker->process(),
-      &action, remote_action, sizeof(action));
+    mc_model_checker->process().read_bytes(
+      &action, sizeof(action), remote(remote_action));
 
     // Finally so something useful about it:
     if (action.comm.src_proc && action.comm.dst_proc)
@@ -500,15 +511,17 @@ int MC_request_is_enabled_by_idx(smx_simcall_t req, unsigned int idx)
     break;
 
   case SIMCALL_COMM_WAITANY: {
-    MC_process_read_dynar_element(
-      &mc_model_checker->process(), &remote_act, simcall_comm_waitany__get__comms(req),
+    read_element(
+      mc_model_checker->process(), &remote_act,
+      remote(simcall_comm_waitany__get__comms(req)),
       idx, sizeof(remote_act));
     }
     break;
 
   case SIMCALL_COMM_TESTANY: {
-    MC_process_read_dynar_element(
-      &mc_model_checker->process(), &remote_act, simcall_comm_testany__get__comms(req),
+    read_element(
+      mc_model_checker->process(), &remote_act,
+      remote(simcall_comm_testany__get__comms(req)),
       idx, sizeof(remote_act));
     }
     break;
@@ -518,8 +531,8 @@ int MC_request_is_enabled_by_idx(smx_simcall_t req, unsigned int idx)
   }
 
   s_smx_synchro_t synchro;
-  MC_process_read_simple(&mc_model_checker->process(),
-    &synchro, remote_act, sizeof(synchro));
+  mc_model_checker->process().read_bytes(
+    &synchro, sizeof(synchro), remote(remote_act));
   return synchro.comm.src_proc && synchro.comm.dst_proc;
 }
 
@@ -536,7 +549,7 @@ char *MC_request_get_dot_output(smx_simcall_t req, int value)
 
   switch (req->call) {
   case SIMCALL_COMM_ISEND:
-    if (issuer->smx_host)
+    if (issuer->host)
       label =
           bprintf("[(%lu)%s] iSend", issuer->pid,
                   MC_smx_process_get_host_name(issuer));
@@ -545,7 +558,7 @@ char *MC_request_get_dot_output(smx_simcall_t req, int value)
     break;
 
   case SIMCALL_COMM_IRECV:
-    if (issuer->smx_host)
+    if (issuer->host)
       label =
           bprintf("[(%lu)%s] iRecv", issuer->pid,
                   MC_smx_process_get_host_name(issuer));
@@ -555,7 +568,7 @@ char *MC_request_get_dot_output(smx_simcall_t req, int value)
 
   case SIMCALL_COMM_WAIT: {
     if (value == -1) {
-      if (issuer->smx_host)
+      if (issuer->host)
         label =
             bprintf("[(%lu)%s] WaitTimeout", issuer->pid,
                     MC_smx_process_get_host_name(issuer));
@@ -564,12 +577,12 @@ char *MC_request_get_dot_output(smx_simcall_t req, int value)
     } else {
       smx_synchro_t remote_act = simcall_comm_wait__get__comm(req);
       s_smx_synchro_t synchro;
-      MC_process_read_simple(&mc_model_checker->process(), &synchro,
-        remote_act, sizeof(synchro));
+      mc_model_checker->process().read_bytes(&synchro,
+        sizeof(synchro), remote(remote_act));
 
       smx_process_t src_proc = MC_smx_resolve_process(synchro.comm.src_proc);
       smx_process_t dst_proc = MC_smx_resolve_process(synchro.comm.dst_proc);
-      if (issuer->smx_host)
+      if (issuer->host)
         label =
             bprintf("[(%lu)%s] Wait [(%lu)->(%lu)]", issuer->pid,
                     MC_smx_process_get_host_name(issuer),
@@ -587,17 +600,17 @@ char *MC_request_get_dot_output(smx_simcall_t req, int value)
   case SIMCALL_COMM_TEST: {
     smx_synchro_t remote_act = simcall_comm_test__get__comm(req);
     s_smx_synchro_t synchro;
-    MC_process_read_simple(&mc_model_checker->process(), &synchro,
-      remote_act, sizeof(synchro));
+    mc_model_checker->process().read_bytes(&synchro,
+      sizeof(synchro), remote(remote_act));
     if (synchro.comm.src_proc == NULL || synchro.comm.dst_proc == NULL) {
-      if (issuer->smx_host)
+      if (issuer->host)
         label =
             bprintf("[(%lu)%s] Test FALSE", issuer->pid,
                     MC_smx_process_get_host_name(issuer));
       else
         label = bprintf("[(%lu)] Test FALSE", issuer->pid);
     } else {
-      if (issuer->smx_host)
+      if (issuer->host)
         label =
             bprintf("[(%lu)%s] Test TRUE", issuer->pid,
                     MC_smx_process_get_host_name(issuer));
@@ -608,9 +621,9 @@ char *MC_request_get_dot_output(smx_simcall_t req, int value)
   }
 
   case SIMCALL_COMM_WAITANY: {
-    unsigned long comms_size = MC_process_read_dynar_length(
-      &mc_model_checker->process(), simcall_comm_waitany__get__comms(req));
-    if (issuer->smx_host)
+    unsigned long comms_size = read_length(
+      mc_model_checker->process(), remote(simcall_comm_waitany__get__comms(req)));
+    if (issuer->host)
       label =
           bprintf("[(%lu)%s] WaitAny [%d of %lu]", issuer->pid,
                   MC_smx_process_get_host_name(issuer), value + 1,
@@ -624,14 +637,14 @@ char *MC_request_get_dot_output(smx_simcall_t req, int value)
 
   case SIMCALL_COMM_TESTANY:
     if (value == -1) {
-      if (issuer->smx_host)
+      if (issuer->host)
         label =
             bprintf("[(%lu)%s] TestAny FALSE", issuer->pid,
                     MC_smx_process_get_host_name(issuer));
       else
         label = bprintf("[(%lu)] TestAny FALSE", issuer->pid);
     } else {
-      if (issuer->smx_host)
+      if (issuer->host)
         label =
             bprintf("[(%lu)%s] TestAny TRUE [%d of %lu]", issuer->pid,
                     MC_smx_process_get_host_name(issuer), value + 1,
@@ -644,12 +657,16 @@ char *MC_request_get_dot_output(smx_simcall_t req, int value)
     }
     break;
 
+  case SIMCALL_MUTEX_TRYLOCK:
+    label = bprintf("[(%lu)] Mutex TRYLOCK", issuer->pid);
+    break;
+
   case SIMCALL_MUTEX_LOCK:
-    label = bprintf("[(%lu)] Mutex LOCK", req->issuer->pid);
+    label = bprintf("[(%lu)] Mutex LOCK", issuer->pid);
     break;
 
   case SIMCALL_MC_RANDOM:
-    if (issuer->smx_host)
+    if (issuer->host)
       label =
           bprintf("[(%lu)%s] MC_RANDOM (%d)", issuer->pid,
                   MC_smx_process_get_host_name(issuer), value);
@@ -658,7 +675,7 @@ char *MC_request_get_dot_output(smx_simcall_t req, int value)
     break;
 
   case SIMCALL_MC_SNAPSHOT:
-    if (issuer->smx_host)
+    if (issuer->host)
       label =
           bprintf("[(%lu)%s] MC_SNAPSHOT", issuer->pid,
                   MC_smx_process_get_host_name(issuer));
@@ -667,7 +684,7 @@ char *MC_request_get_dot_output(smx_simcall_t req, int value)
     break;
 
   case SIMCALL_MC_COMPARE_SNAPSHOTS:
-    if (issuer->smx_host)
+    if (issuer->host)
       label =
           bprintf("[(%lu)%s] MC_COMPARE_SNAPSHOTS", issuer->pid,
                   MC_smx_process_get_host_name(issuer));