add support for CancelException

[simgrid.git] / src / msg / msg_gos.cpp

diff --git a/src/msg/msg_gos.cpp b/src/msg/msg_gos.cpp
index 10e43af..8f3b098 100644 (file)
--- a/src/msg/msg_gos.cpp
+++ b/src/msg/msg_gos.cpp
@@ -45,7 +45,6 @@ msg_error_t MSG_parallel_task_execute_with_timeout(msg_task_t task, double timeo
   e_smx_state_t comp_state;
   msg_error_t status = MSG_OK;
 
-  TRACE_msg_task_execute_start(task);
 
   xbt_assert((not simdata->compute) && not task->simdata->isused,
              "This task is executed somewhere else. Go fix your code!");
@@ -53,10 +52,12 @@ msg_error_t MSG_parallel_task_execute_with_timeout(msg_task_t task, double timeo
   XBT_DEBUG("Computing on %s", MSG_process_get_name(MSG_process_self()));
 
   if (simdata->flops_amount <= 0.0 && not simdata->host_nb) {
-    TRACE_msg_task_execute_end(task);
     return MSG_OK;
   }
 
+  if (TRACE_actor_is_enabled())
+    simgrid::instr::Container::by_name(instr_pid(MSG_process_self()))->get_state("ACTOR_STATE")->push_event("execute");
+
   try {
     simdata->setUsed();
 
@@ -67,7 +68,7 @@ msg_error_t MSG_parallel_task_execute_with_timeout(msg_task_t task, double timeo
               simdata->bytes_parallel_amount, -1.0, timeout));
       XBT_DEBUG("Parallel execution action created: %p", simdata->compute.get());
       if (task->category != nullptr)
-        simcall_set_category(simdata->compute, task->category);
+        simgrid::simix::simcall([task] { task->simdata->compute->set_category(task->category); });
     } else {
       sg_host_t host   = MSG_process_get_host(MSG_process_self());
       simdata->compute = simgrid::simix::simcall([task, host] {
@@ -91,50 +92,17 @@ msg_error_t MSG_parallel_task_execute_with_timeout(msg_task_t task, double timeo
     status = MSG_HOST_FAILURE;
   } catch (simgrid::TimeoutError& e) {
     status = MSG_TIMEOUT;
-  } catch (xbt_ex& e) {
-    if (e.category == cancel_error)
-      status = MSG_TASK_CANCELED;
-    else
-      throw;
+  } catch (simgrid::CancelException& e) {
+    status = MSG_TASK_CANCELED;
   }
 
   /* action ended, set comm and compute = nullptr, the actions is already destroyed in the main function */
   simdata->flops_amount = 0.0;
   simdata->comm = nullptr;
   simdata->compute = nullptr;
-  TRACE_msg_task_execute_end(task);
-
-  return status;
-}
-
-/**
- * @brief Sleep for the specified number of seconds
- *
- * Makes the current process sleep until @a time seconds have elapsed.
- *
- * @param nb_sec a number of second
- */
-msg_error_t MSG_process_sleep(double nb_sec)
-{
-  msg_error_t status = MSG_OK;
 
-  try {
-    simgrid::s4u::this_actor::sleep_for(nb_sec);
-  } catch (simgrid::HostFailureException& e) {
-    status = MSG_HOST_FAILURE;
-  } catch (xbt_ex& e) {
-    if (e.category == cancel_error) {
-      XBT_DEBUG("According to the JAVA API, a sleep call should only deal with HostFailureException, I'm lost.");
-      // adsein: MSG_TASK_CANCELED is assigned when someone kills the process that made the sleep, this is not
-      // correct. For instance, when the node is turned off, the error should be MSG_HOST_FAILURE, which is by the way
-      // and according to the JAVA document, the only exception that can be triggered by MSG_Process_sleep call.
-      // To avoid possible impacts in the code, I just raised a host_failure exception for the moment in the JAVA code
-      // and did not change anythings at the C level.
-      // See comment in the jmsg_process.c file, function JNIEXPORT void JNICALL Java_org_simgrid_msg_Process_sleep(JNIEnv *env, jclass cls, jlong jmillis, jint jnanos)
-      status = MSG_TASK_CANCELED;
-    } else
-      throw;
-  }
+  if (TRACE_actor_is_enabled())
+    simgrid::instr::Container::by_name(instr_pid(MSG_process_self()))->get_state("ACTOR_STATE")->pop_event();
 
   return status;
 }
@@ -288,17 +256,13 @@ msg_error_t MSG_task_receive_ext_bounded(msg_task_t * task, const char *alias, d
     ret = MSG_HOST_FAILURE;
   } catch (simgrid::TimeoutError& e) {
     ret = MSG_TIMEOUT;
+  } catch (simgrid::CancelException& e) {
+    ret = MSG_HOST_FAILURE;
   } catch (xbt_ex& e) {
-    switch (e.category) {
-    case cancel_error:
-      ret = MSG_HOST_FAILURE;
-      break;
-    case network_error:
+    if (e.category == network_error)
       ret = MSG_TRANSFER_FAILURE;
-      break;
-    default:
+    else
       throw;
-    }
   }
 
   if (ret != MSG_HOST_FAILURE && ret != MSG_TRANSFER_FAILURE && ret != MSG_TIMEOUT) {
@@ -335,8 +299,9 @@ static inline msg_comm_t MSG_task_isend_internal(msg_task_t task, const char* al
     comm = new simgrid::msg::Comm(task, nullptr, act);
   }
 
-  if (TRACE_is_enabled())
-    simcall_set_category(act, task->category);
+  if (TRACE_is_enabled() && task->category != nullptr)
+    simgrid::simix::simcall([act, task] { act->set_category(task->category); });
+
   TRACE_msg_task_put_end();
 
   return comm;
@@ -775,23 +740,18 @@ msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char *alias, doubl
     comm = simcall_comm_isend(SIMIX_process_self(), mailbox->get_impl(), t_simdata->bytes_amount, t_simdata->rate, task,
                               sizeof(void*), nullptr, nullptr, nullptr, nullptr, 0);
     if (TRACE_is_enabled() && task->category != nullptr)
-      simcall_set_category(comm, task->category);
+      simgrid::simix::simcall([comm, task] { comm->set_category(task->category); });
     t_simdata->comm = boost::static_pointer_cast<simgrid::kernel::activity::CommImpl>(comm);
     simcall_comm_wait(comm, timeout);
   } catch (simgrid::TimeoutError& e) {
     ret = MSG_TIMEOUT;
-  }
-  catch (xbt_ex& e) {
-    switch (e.category) {
-    case cancel_error:
-      ret = MSG_HOST_FAILURE;
-      break;
-    case network_error:
+  } catch (simgrid::CancelException& e) {
+    ret = MSG_HOST_FAILURE;
+  } catch (xbt_ex& e) {
+    if (e.category == network_error)
       ret = MSG_TRANSFER_FAILURE;
-      break;
-    default:
+    else
       throw;
-    }
 
     /* If the send failed, it is not used anymore */
     t_simdata->setNotUsed();