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

diff --git a/src/simix/smx_smurf.c b/src/simix/smx_smurf.c
index bed8cd05b1..0f34218233 100644
--- a/src/simix/smx_smurf.c
+++ b/src/simix/smx_smurf.c
@@ -5,99 +5,219 @@
 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;
+/* 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)
 {
-  sync_req_vector = xbt_os_mutex_init();
-  req_vector = xbt_dynar_new(sizeof(void *), NULL);
+  req_todo = xbt_heap_new(5,NULL);
+  sync_req_positions = xbt_os_mutex_init();
 }
 
 void SIMIX_request_destroy(void)
 {
-  xbt_os_mutex_destroy(sync_req_vector);
-  xbt_dynar_free(&req_vector);
+  xbt_heap_free(req_todo);
+  xbt_os_mutex_destroy(sync_req_positions);
 }
 
-void SIMIX_request_push(smx_req_t req)
+/* 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()
 {
-  req->issuer = SIMIX_process_self();
-  if (req->issuer != simix_global->maestro_process){
-    xbt_os_mutex_acquire(sync_req_vector);
-    xbt_dynar_set_as(req_vector, req->issuer->pid, smx_req_t, req);
-    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);
+  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();
   } else {
-    SIMIX_request_pre(req);
+    SIMIX_request_pre(&issuer->request, 0);
   }
 }
 
 smx_req_t SIMIX_request_pop(void)
 {
-  smx_req_t request = NULL;
-  xbt_os_mutex_acquire(sync_req_vector);
-  while (xbt_dynar_length(req_vector)){
-    request = xbt_dynar_pop_as(req_vector, smx_req_t);
-    if (request)
-      break;
-  }
-  xbt_os_mutex_release(sync_req_vector);
-  return request;
+  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){
-    req->issuer->request = NULL;    
-    xbt_swag_insert(req->issuer, simix_global->process_to_run);
+    DEBUG2("Answer request %s (%d)", SIMIX_request_name(req->call), req->call);
+    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)
+void SIMIX_request_pre(smx_req_t req, int value)
 {
-  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;
-}
+  switch (req->call) {
 
-int SIMIX_request_is_enabled(smx_req_t req)
-{
-  unsigned int index = 0;
-  smx_action_t act;
+    case REQ_COMM_TEST:
+      SIMIX_pre_comm_test(req);
+      break;
 
-  switch (req->call) {
+    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, 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_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;
 
-void SIMIX_request_pre(smx_req_t req)
-{
-  switch (req->call) {
+    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_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
+
+    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 =
@@ -193,15 +313,6 @@ void SIMIX_request_pre(smx_req_t req)
       SIMIX_request_answer(req);
       break;
 
-#ifdef HAVE_TRACING
-    case REQ_HOST_EXECUTION_SET_CATEGORY:
-      SIMIX_host_execution_set_category(
-          req->host_execution_set_category.execution,
-          req->host_execution_set_category.category);
-      SIMIX_request_answer(req);
-      break;
-#endif
-
     case REQ_HOST_EXECUTION_WAIT:
       SIMIX_pre_host_execution_wait(req);
       break;
@@ -284,134 +395,11 @@ 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.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);
-      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_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_DATA:
-      req->comm_get_data.result = SIMIX_comm_get_data(req->comm_get_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);
+#ifdef HAVE_TRACING
+    case REQ_SET_CATEGORY:
+      SIMIX_set_category(
+          req->set_category.action,
+          req->set_category.category);
       SIMIX_request_answer(req);
       break;
 #endif
@@ -503,6 +491,13 @@ 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:
+      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;
   }
 }