X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/848f95383e4a29010f73eeca63fa26c8118dd72c..6b188a3ca7fe91cf125a08229fb4fe51eee26e6d:/src/simix/smx_smurf.c

diff --git a/src/simix/smx_smurf.c b/src/simix/smx_smurf.c
index 8c4b3705a8..1fb1585b25 100644
--- a/src/simix/smx_smurf.c
+++ b/src/simix/smx_smurf.c
@@ -5,120 +5,197 @@
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_smurf, simix,
                                 "Logging specific to SIMIX (SMURF)");
 
-/* Requests to handle at the end of this round of scheduling user processes */
-static xbt_heap_t req_todo;
-/* to protect the write actions in the heap */
-static xbt_os_mutex_t sync_req_positions;
-
-void SIMIX_request_init(void)
-{
-  req_todo = xbt_heap_new(5,NULL);
-  sync_req_positions = xbt_os_mutex_init();
-}
-
-void SIMIX_request_destroy(void)
+XBT_INLINE smx_req_t SIMIX_req_mine()
 {
-  xbt_heap_free(req_todo);
-  xbt_os_mutex_destroy(sync_req_positions);
-}
-
-/* FIXME: we may want to save the initialization of issuer... */
-XBT_INLINE smx_req_t SIMIX_req_mine() {
   smx_process_t issuer = SIMIX_process_self();
   return &issuer->request;
 }
 
-void SIMIX_request_push()
+/**
+ * \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)
 {
-  smx_process_t issuer = SIMIX_process_self();
-  if (issuer != simix_global->maestro_process){
-    issuer->request.issuer = issuer;
-
-    if (smx_parallel_contexts)
-      xbt_os_mutex_acquire(sync_req_positions);
-    xbt_heap_push(req_todo,&issuer->request,issuer->pid);
-    DEBUG4("Pushed request %s (%d) of %s; now %d requests waiting",
-        SIMIX_request_name(issuer->request.call), issuer->request.call,
-        issuer->name,xbt_heap_size(req_todo));
-    if (smx_parallel_contexts)
-      xbt_os_mutex_release(sync_req_positions);
-
-    DEBUG3("Yield process '%s' on request of type %s (%d)", issuer->name,
-        SIMIX_request_name(issuer->request.call), issuer->request.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(&issuer->request);
+    SIMIX_request_pre(&self->request, 0);
   }
 }
 
-smx_req_t SIMIX_request_pop(void)
-{
-  smx_req_t req = xbt_heap_pop(req_todo);
-  if(req)
-    DEBUG4("Popped request %s (%d) of %s; now %d requests waiting",
-        SIMIX_request_name(req->issuer->request.call),
-        req->issuer->request.call,
-        req->issuer->name,xbt_heap_size(req_todo));
-  return req;
-}
-
 void SIMIX_request_answer(smx_req_t req)
 {
   if (req->issuer != simix_global->maestro_process){
-    DEBUG2("Answer request %s (%d)", SIMIX_request_name(req->call), req->call);
+    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;
+  XBT_DEBUG("Handling request %p: %s", req, SIMIX_request_name(req->call));
 
   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;
+
+    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,
+          NULL, /* no clean function since it's not detached */
+          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.clean_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;
+    }
+
+    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;
 
-    default:    
-      return TRUE;
-  }
-}
+    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;
 
-void SIMIX_request_pre(smx_req_t req)
-{
-  switch (req->call) {
-  case REQ_NO_REQ:
-    THROW2(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;
+    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 =
@@ -169,7 +246,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;
 
@@ -219,7 +297,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,
@@ -231,14 +310,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;
@@ -296,150 +384,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(
@@ -536,6 +480,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;
+
   }
 }