X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/806504b9602a886e391b54e458b2c1f7f42d3afb..edde8f7fbc1b74a81551bf9eb7bac1935b999296:/src/simix/smx_smurf.c

diff --git a/src/simix/smx_smurf.c b/src/simix/smx_smurf.c
index 3d6bbf0659..f19303242c 100644
--- a/src/simix/smx_smurf.c
+++ b/src/simix/smx_smurf.c
@@ -5,100 +5,194 @@
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_smurf, simix,
                                 "Logging specific to SIMIX (SMURF)");
 
-static xbt_dynar_t req_vector;
-static xbt_os_mutex_t sync_req_vector;
-
-void SIMIX_request_init(void)
-{
-  sync_req_vector = xbt_os_mutex_init();
-  req_vector = xbt_dynar_new(sizeof(void *), NULL);
-}
-
-void SIMIX_request_destroy(void)
+XBT_INLINE smx_req_t SIMIX_req_mine()
 {
-  xbt_os_mutex_destroy(sync_req_vector);
-  xbt_dynar_free(&req_vector);
+  smx_process_t issuer = SIMIX_process_self();
+  return &issuer->request;
 }
 
-void SIMIX_request_push(smx_req_t req)
+/**
+ * \brief Makes the current process do a request to the kernel and yields
+ * until completion.
+ * \param self the current process
+ */
+void SIMIX_request_push(smx_process_t self)
 {
-  req->issuer = SIMIX_process_self();
-  if (req->issuer != simix_global->maestro_process){
-    if (_surf_parallel_contexts)
-      xbt_os_mutex_acquire(sync_req_vector);
-    xbt_dynar_set_as(req_vector, req->issuer->pid, smx_req_t, req);
-    if (_surf_parallel_contexts)
-      xbt_os_mutex_release(sync_req_vector);
-    req->issuer->request = req;
-    DEBUG2("Yield process '%s' on request of type %d", req->issuer->name, req->call);
-    SIMIX_process_yield();
+  if (self != simix_global->maestro_process) {
+    XBT_DEBUG("Yield process '%s' on request of type %s (%d)", self->name,
+        SIMIX_request_name(self->request.call), self->request.call);
+    SIMIX_process_yield(self);
   } else {
-    SIMIX_request_pre(req);
-  }
-}
-
-smx_req_t SIMIX_request_pop(void)
-{
-  smx_req_t request = NULL;
-  while (xbt_dynar_length(req_vector)){
-    request = xbt_dynar_pop_as(req_vector, smx_req_t);
-    if (request)
-      break;
+    SIMIX_request_pre(&self->request, 0);
   }
-
-  return request;
 }
 
 void SIMIX_request_answer(smx_req_t req)
 {
   if (req->issuer != simix_global->maestro_process){
-    req->issuer->request = NULL;    
-    xbt_swag_insert(req->issuer, simix_global->process_to_run);
+    XBT_DEBUG("Answer request %s (%d) issued by %s (%p)", SIMIX_request_name(req->call), req->call,
+        req->issuer->name, req->issuer);
+    req->issuer->request.call = REQ_NO_REQ;
+    xbt_dynar_push_as(simix_global->process_to_run, smx_process_t, req->issuer);
   }
 }
 
-int SIMIX_request_is_visible(smx_req_t req)
-{
-  return req->call == REQ_COMM_ISEND
-     || req->call == REQ_COMM_IRECV
-     || req->call == REQ_COMM_WAIT
-     || req->call == REQ_COMM_WAITANY
-     || req->call == REQ_COMM_TEST;
-}
-
-int SIMIX_request_is_enabled(smx_req_t req)
+void SIMIX_request_pre(smx_req_t req, int value)
 {
-  unsigned int index = 0;
-  smx_action_t act;
 
   switch (req->call) {
+    case REQ_COMM_TEST:
+      SIMIX_pre_comm_test(req);
+      break;
+
+    case REQ_COMM_TESTANY:
+      SIMIX_pre_comm_testany(req, value);
+      break;
 
     case REQ_COMM_WAIT:
-      /* FIXME: check also that src and dst processes are not suspended */
-      if (req->comm_wait.comm->comm.src_proc 
-         && req->comm_wait.comm->comm.dst_proc)
-        return TRUE;
-      return FALSE;
+      SIMIX_pre_comm_wait(req,
+          req->comm_wait.comm,
+          req->comm_wait.timeout,
+          value);
       break;
 
     case REQ_COMM_WAITANY:
-      xbt_dynar_foreach(req->comm_waitany.comms, index, act) {
-        if (act->comm.src_proc && act->comm.dst_proc){
-          return TRUE;
-        }
-      }
-      return FALSE;
+      SIMIX_pre_comm_waitany(req, value);
       break;
 
-    default:    
-      return TRUE;
-  }
-}
+    case REQ_COMM_SEND:
+    {
+      smx_action_t comm = SIMIX_comm_isend(
+          req->issuer,
+          req->comm_send.rdv,
+          req->comm_send.task_size,
+          req->comm_send.rate,
+          req->comm_send.src_buff,
+          req->comm_send.src_buff_size,
+          req->comm_send.match_fun,
+          req->comm_send.data,
+          0);
+      SIMIX_pre_comm_wait(req, comm, req->comm_send.timeout, 0);
+      break;
+    }
 
+    case REQ_COMM_ISEND:
+      req->comm_isend.result = SIMIX_comm_isend(
+          req->issuer,
+          req->comm_isend.rdv,
+          req->comm_isend.task_size,
+          req->comm_isend.rate,
+          req->comm_isend.src_buff,
+          req->comm_isend.src_buff_size,
+          req->comm_isend.match_fun,
+          req->comm_isend.data,
+          req->comm_isend.detached);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_COMM_RECV:
+    {
+      smx_action_t comm = SIMIX_comm_irecv(
+          req->issuer,
+          req->comm_recv.rdv,
+          req->comm_recv.dst_buff,
+          req->comm_recv.dst_buff_size,
+          req->comm_recv.match_fun,
+          req->comm_recv.data);
+      SIMIX_pre_comm_wait(req, comm, req->comm_recv.timeout, 0);
+      break;
+    }
 
-void SIMIX_request_pre(smx_req_t req)
-{
-  switch (req->call) {
+    case REQ_COMM_IRECV:
+      req->comm_irecv.result = SIMIX_comm_irecv(
+          req->issuer,
+          req->comm_irecv.rdv,
+          req->comm_irecv.dst_buff,
+          req->comm_irecv.dst_buff_size,
+          req->comm_irecv.match_fun,
+          req->comm_irecv.data);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_COMM_DESTROY:
+      SIMIX_comm_destroy(req->comm_destroy.comm);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_COMM_CANCEL:
+      SIMIX_comm_cancel(req->comm_cancel.comm);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_COMM_GET_REMAINS:
+      req->comm_get_remains.result =
+          SIMIX_comm_get_remains(req->comm_get_remains.comm);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_COMM_GET_STATE:
+      req->comm_get_state.result =
+          SIMIX_comm_get_state(req->comm_get_state.comm);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_COMM_GET_SRC_DATA:
+      req->comm_get_src_data.result = SIMIX_comm_get_src_data(req->comm_get_src_data.comm);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_COMM_GET_DST_DATA:
+      req->comm_get_dst_data.result = SIMIX_comm_get_dst_data(req->comm_get_dst_data.comm);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_COMM_GET_SRC_PROC:
+      req->comm_get_src_proc.result =
+          SIMIX_comm_get_src_proc(req->comm_get_src_proc.comm);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_COMM_GET_DST_PROC:
+      req->comm_get_dst_proc.result =
+          SIMIX_comm_get_dst_proc(req->comm_get_dst_proc.comm);
+      SIMIX_request_answer(req);
+      break;
+
+#ifdef HAVE_LATENCY_BOUND_TRACKING
+    case REQ_COMM_IS_LATENCY_BOUNDED:
+      req->comm_is_latency_bounded.result =
+          SIMIX_comm_is_latency_bounded(req->comm_is_latency_bounded.comm);
+      SIMIX_request_answer(req);
+      break;
+#endif
+
+    case REQ_RDV_CREATE:
+      req->rdv_create.result = SIMIX_rdv_create(req->rdv_create.name);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_RDV_DESTROY:
+      SIMIX_rdv_destroy(req->rdv_destroy.rdv);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_RDV_GEY_BY_NAME:
+      req->rdv_get_by_name.result =
+        SIMIX_rdv_get_by_name(req->rdv_get_by_name.name);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_RDV_COMM_COUNT_BY_HOST:
+      req->rdv_comm_count_by_host.result = SIMIX_rdv_comm_count_by_host(
+          req->rdv_comm_count_by_host.rdv,
+          req->rdv_comm_count_by_host.host);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_RDV_GET_HEAD:
+      req->rdv_get_head.result = SIMIX_rdv_get_head(req->rdv_get_head.rdv);
+      SIMIX_request_answer(req);
+      break;
 
     case REQ_HOST_GET_BY_NAME:
       req->host_get_by_name.result =
@@ -149,7 +243,8 @@ void SIMIX_request_pre(smx_req_t req)
       req->host_execute.result = SIMIX_host_execute(
 	  req->host_execute.name,
 	  req->host_execute.host,
-	  req->host_execute.computation_amount);
+	  req->host_execute.computation_amount,
+	  req->host_execute.priority);
       SIMIX_request_answer(req);
       break;
 
@@ -199,7 +294,8 @@ void SIMIX_request_pre(smx_req_t req)
       break;
 
     case REQ_PROCESS_CREATE:
-      req->process_create.result = SIMIX_process_create(
+      SIMIX_process_create(
+          req->process_create.process,
 	  req->process_create.name,
 	  req->process_create.code,
 	  req->process_create.data,
@@ -211,14 +307,23 @@ void SIMIX_request_pre(smx_req_t req)
       break;
 
     case REQ_PROCESS_KILL:
-      SIMIX_process_kill(req->process_kill.process, req->issuer);
+      SIMIX_process_kill(req->process_kill.process);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_PROCESS_KILLALL:
+      SIMIX_process_killall(req->issuer);
+      SIMIX_request_answer(req);
+      break;
+
+    case REQ_PROCESS_CLEANUP:
+      SIMIX_process_cleanup(req->process_cleanup.process);
       SIMIX_request_answer(req);
       break;
 
     case REQ_PROCESS_CHANGE_HOST:
-      SIMIX_process_change_host(
+      SIMIX_pre_process_change_host(
 	  req->process_change_host.process,
-	  req->process_change_host.source,
 	  req->process_change_host.dest);
       SIMIX_request_answer(req);
       break;
@@ -276,150 +381,6 @@ void SIMIX_request_pre(smx_req_t req)
       SIMIX_pre_process_sleep(req);
       break;
 
-    case REQ_RDV_CREATE:
-      req->rdv_create.result = SIMIX_rdv_create(req->rdv_create.name);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_RDV_DESTROY:
-      SIMIX_rdv_destroy(req->rdv_destroy.rdv);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_RDV_GEY_BY_NAME:
-      req->rdv_get_by_name.result = 
-        SIMIX_rdv_get_by_name(req->rdv_get_by_name.name);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_RDV_COMM_COUNT_BY_HOST:
-      req->rdv_comm_count_by_host.result = SIMIX_rdv_comm_count_by_host(
-	  req->rdv_comm_count_by_host.rdv,
-	  req->rdv_comm_count_by_host.host);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_RDV_GET_HEAD:
-      req->rdv_get_head.result =	SIMIX_rdv_get_head(req->rdv_get_head.rdv);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_ISEND:
-      req->comm_isend.result = SIMIX_comm_isend(
-	  req->issuer,
-	  req->comm_isend.rdv,
-	  req->comm_isend.task_size,
-	  req->comm_isend.rate,
-	  req->comm_isend.src_buff,
-	  req->comm_isend.src_buff_size,
-	  req->comm_isend.match_fun,
-	  req->comm_isend.data);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_IRECV:
-      req->comm_irecv.result = SIMIX_comm_irecv(
-	  req->issuer,
-	  req->comm_irecv.rdv,
-	  req->comm_irecv.dst_buff,
-	  req->comm_irecv.dst_buff_size,
-	  req->comm_irecv.match_fun,
-	  req->comm_irecv.data);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_DESTROY:
-      SIMIX_comm_destroy(req->comm_destroy.comm);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_CANCEL:
-      SIMIX_comm_cancel(req->comm_cancel.comm);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_WAITANY:
-      SIMIX_pre_comm_waitany(req);
-      break;
-
-    case REQ_COMM_WAIT:
-      SIMIX_pre_comm_wait(req);
-      break;
-
-    case REQ_COMM_TEST:
-      SIMIX_pre_comm_test(req);
-      break;
-
-    case REQ_COMM_TESTANY:
-      SIMIX_pre_comm_testany(req);
-      break;
-
-    case REQ_COMM_GET_REMAINS:
-      req->comm_get_remains.result = 
-        SIMIX_comm_get_remains(req->comm_get_remains.comm);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_GET_STATE:
-      req->comm_get_state.result = 
-        SIMIX_comm_get_state(req->comm_get_state.comm);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_GET_SRC_DATA:
-      req->comm_get_src_data.result = SIMIX_comm_get_src_data(req->comm_get_src_data.comm);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_GET_DST_DATA:
-      req->comm_get_dst_data.result = SIMIX_comm_get_dst_data(req->comm_get_dst_data.comm);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_GET_SRC_BUFF:
-      req->comm_get_src_buff.result =
-      	SIMIX_comm_get_src_buff(req->comm_get_src_buff.comm);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_GET_DST_BUFF:
-      req->comm_get_dst_buff.result =
-        SIMIX_comm_get_dst_buff(req->comm_get_dst_buff.comm);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_GET_SRC_BUFF_SIZE:
-      req->comm_get_src_buff_size.result = 
-        SIMIX_comm_get_src_buff_size(req->comm_get_src_buff_size.comm);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_GET_DST_BUFF_SIZE:
-      req->comm_get_dst_buff_size.result =
-      	SIMIX_comm_get_dst_buff_size(req->comm_get_dst_buff_size.comm);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_GET_SRC_PROC:
-      req->comm_get_src_proc.result = 
-        SIMIX_comm_get_src_proc(req->comm_get_src_proc.comm);
-      SIMIX_request_answer(req);
-      break;
-
-    case REQ_COMM_GET_DST_PROC:
-      req->comm_get_dst_proc.result =
-        SIMIX_comm_get_dst_proc(req->comm_get_dst_proc.comm);
-      SIMIX_request_answer(req);
-      break;
-
-#ifdef HAVE_LATENCY_BOUND_TRACKING
-    case REQ_COMM_IS_LATENCY_BOUNDED:
-      req->comm_is_latency_bounded.result =
-	SIMIX_comm_is_latency_bounded(req->comm_is_latency_bounded.comm);
-      SIMIX_request_answer(req);
-      break;
-#endif
-
 #ifdef HAVE_TRACING
     case REQ_SET_CATEGORY:
       SIMIX_set_category(
@@ -516,6 +477,14 @@ void SIMIX_request_pre(smx_req_t req)
         SIMIX_sem_get_capacity(req->sem_get_capacity.sem);
       SIMIX_request_answer(req);
       break;
+
+    case REQ_NO_REQ:
+      THROWF(arg_error,0,"Asked to do the noop syscall on %s@%s",
+          SIMIX_process_get_name(req->issuer),
+          SIMIX_host_get_name(SIMIX_process_get_host(req->issuer))
+          );
+      break;
+
   }
 }