Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
[mc] Get rid of the ugly "value" out parameter in MC_state_get_request()
[simgrid.git] / src / mc / mc_state.cpp
index 1a4b90a..a6f51d3 100644 (file)
@@ -69,7 +69,7 @@ RecordTraceElement State::getRecordElement() const
 }
 
 static inline smx_simcall_t MC_state_get_request_for_process(
-  simgrid::mc::State* state, int*value, smx_process_t process)
+  simgrid::mc::State* state, smx_process_t process)
 {
   simgrid::mc::ProcessState* procstate = &state->processStates[process->pid];
 
@@ -81,13 +81,13 @@ static inline smx_simcall_t MC_state_get_request_for_process(
   smx_simcall_t req = nullptr;
   switch (process->simcall.call) {
       case SIMCALL_COMM_WAITANY:
-        *value = -1;
+        state->req_num = -1;
         while (procstate->interleave_count <
               read_length(mc_model_checker->process(),
                 remote(simcall_comm_waitany__get__comms(&process->simcall)))) {
           if (simgrid::mc::request_is_enabled_by_idx(&process->simcall,
               procstate->interleave_count++)) {
-            *value = procstate->interleave_count - 1;
+            state->req_num = procstate->interleave_count - 1;
             break;
           }
         }
@@ -96,19 +96,19 @@ static inline smx_simcall_t MC_state_get_request_for_process(
             simgrid::mc::read_length(mc_model_checker->process(),
               simgrid::mc::remote(simcall_comm_waitany__get__comms(&process->simcall))))
           procstate->setDone();
-        if (*value != -1)
+        if (state->req_num != -1)
           req = &process->simcall;
         break;
 
       case SIMCALL_COMM_TESTANY: {
         unsigned start_count = procstate->interleave_count;
-        *value = -1;
+        state->req_num = -1;
         while (procstate->interleave_count <
                 read_length(mc_model_checker->process(),
                   remote(simcall_comm_testany__get__comms(&process->simcall))))
           if (simgrid::mc::request_is_enabled_by_idx(&process->simcall,
               procstate->interleave_count++)) {
-            *value = procstate->interleave_count - 1;
+            state->req_num = procstate->interleave_count - 1;
             break;
           }
 
@@ -117,7 +117,7 @@ static inline smx_simcall_t MC_state_get_request_for_process(
               remote(simcall_comm_testany__get__comms(&process->simcall))))
           procstate->setDone();
 
-        if (*value != -1 || start_count == 0)
+        if (state->req_num != -1 || start_count == 0)
            req = &process->simcall;
 
         break;
@@ -129,12 +129,12 @@ static inline smx_simcall_t MC_state_get_request_for_process(
         mc_model_checker->process().read_bytes(
           &act, sizeof(act), remote(remote_act));
         if (act.comm.src_proc && act.comm.dst_proc)
-          *value = 0;
+          state->req_num = 0;
         else if (act.comm.src_proc == nullptr && act.comm.type == SIMIX_COMM_READY
               && act.comm.detached == 1)
-          *value = 0;
+          state->req_num = 0;
         else
-          *value = -1;
+          state->req_num = -1;
         procstate->setDone();
         req = &process->simcall;
         break;
@@ -142,9 +142,9 @@ static inline smx_simcall_t MC_state_get_request_for_process(
 
       case SIMCALL_MC_RANDOM: {
         int min_value = simcall_mc_random__get__min(&process->simcall);
-        *value = procstate->interleave_count + min_value;
+        state->req_num = procstate->interleave_count + min_value;
         procstate->interleave_count++;
-        if (*value == simcall_mc_random__get__max(&process->simcall))
+        if (state->req_num == simcall_mc_random__get__max(&process->simcall))
           procstate->setDone();
         req = &process->simcall;
         break;
@@ -152,7 +152,7 @@ static inline smx_simcall_t MC_state_get_request_for_process(
 
       default:
         procstate->setDone();
-        *value = 0;
+        state->req_num = 0;
         req = &process->simcall;
         break;
   }
@@ -162,7 +162,6 @@ static inline smx_simcall_t MC_state_get_request_for_process(
   // Fetch the data of the request and translate it:
 
   state->executed_req = *req;
-  state->req_num = *value;
 
   /* The waitany and testany request are transformed into a wait or test request
    * over the corresponding communication action so it can be treated later by
@@ -174,7 +173,7 @@ static inline smx_simcall_t MC_state_get_request_for_process(
     smx_synchro_t remote_comm;
     read_element(mc_model_checker->process(),
       &remote_comm, remote(simcall_comm_waitany__get__comms(req)),
-      *value, sizeof(remote_comm));
+      state->req_num, sizeof(remote_comm));
     mc_model_checker->process().read(&state->internal_comm, remote(remote_comm));
     simcall_comm_wait__set__comm(&state->internal_req, &state->internal_comm);
     simcall_comm_wait__set__timeout(&state->internal_req, 0);
@@ -185,16 +184,16 @@ static inline smx_simcall_t MC_state_get_request_for_process(
     state->internal_req.call = SIMCALL_COMM_TEST;
     state->internal_req.issuer = req->issuer;
 
-    if (*value > 0) {
+    if (state->req_num > 0) {
       smx_synchro_t remote_comm;
       read_element(mc_model_checker->process(),
         &remote_comm, remote(simcall_comm_testany__get__comms(req)),
-        *value, sizeof(remote_comm));
+        state->req_num, sizeof(remote_comm));
       mc_model_checker->process().read(&state->internal_comm, remote(remote_comm));
     }
 
     simcall_comm_test__set__comm(&state->internal_req, &state->internal_comm);
-    simcall_comm_test__set__result(&state->internal_req, *value);
+    simcall_comm_test__set__result(&state->internal_req, state->req_num);
     break;
 
   case SIMCALL_COMM_WAIT:
@@ -221,10 +220,10 @@ static inline smx_simcall_t MC_state_get_request_for_process(
   return req;
 }
 
-smx_simcall_t MC_state_get_request(simgrid::mc::State* state, int *value)
+smx_simcall_t MC_state_get_request(simgrid::mc::State* state)
 {
   for (auto& p : mc_model_checker->process().simix_processes()) {
-    smx_simcall_t res = MC_state_get_request_for_process(state, value, &p.copy);
+    smx_simcall_t res = MC_state_get_request_for_process(state, &p.copy);
     if (res)
       return res;
   }