X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/b3d18155a991509df0050df72c7531ffbcae7efc..32f3c7c2fd01a3c0c499b7866bd505617e30a33e:/src/msg/gos.c

diff --git a/src/msg/gos.c b/src/msg/gos.c
index 18094ea14b..cb2890ef83 100644
--- a/src/msg/gos.c
+++ b/src/msg/gos.c
@@ -11,10 +11,14 @@
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(gos, msg,
 				"Logging specific to MSG (gos)");
 
+/** \defgroup msg_gos_functions MSG Operating System Functions
+ *  \brief This section describes the functions that can be used
+ *  by an agent for handling some task.
+ */
+
 /** \ingroup msg_gos_functions
  * \brief This function is now deprecated and useless. Please stop using it.
  */
-
 MSG_error_t MSG_process_start(m_process_t process)
 {
   xbt_assert0(0,"This function is now deprecated and useless. Please stop using it.");
@@ -25,7 +29,7 @@ MSG_error_t MSG_process_start(m_process_t process)
 /** \ingroup msg_gos_functions
  * \brief Listen on a channel and wait for receiving a task.
  *
- * It takes two parameter.
+ * It takes two parameters.
  * \param task a memory location for storing a #m_task_t. It will
    hold a task when this function will return. Thus \a task should not
    be equal to \c NULL and \a *task should be equal to \c NULL. If one of
@@ -38,6 +42,31 @@ MSG_error_t MSG_process_start(m_process_t process)
  */
 MSG_error_t MSG_task_get(m_task_t * task,
 			 m_channel_t channel)
+{
+  return MSG_task_get_with_time_out(task, channel, -1);
+}
+
+/** \ingroup msg_gos_functions
+ * \brief Listen on a channel and wait for receiving a task with a timeout.
+ *
+ * It takes three parameters.
+ * \param task a memory location for storing a #m_task_t. It will
+   hold a task when this function will return. Thus \a task should not
+   be equal to \c NULL and \a *task should be equal to \c NULL. If one of
+   those two condition does not hold, there will be a warning message.
+ * \param channel the channel on which the agent should be
+   listening. This value has to be >=0 and < than the maximal
+   number of channels fixed with MSG_set_channel_number().
+ * \param timeout the maximum time to wait for a task before giving
+    up. In such a case, \a task will not be modified and will still be
+    equal to \c NULL when returning.
+ * \return #MSG_FATAL if \a task is equal to \c NULL, #MSG_WARNING
+   if \a *task is not equal to \c NULL, and #MSG_OK otherwise.
+ */
+
+MSG_error_t MSG_task_get_with_time_out(m_task_t * task,
+				       m_channel_t channel,
+				       double max_duration)
 {
   m_process_t process = MSG_process_self();
   m_task_t t = NULL;
@@ -45,6 +74,7 @@ MSG_error_t MSG_task_get(m_task_t * task,
   simdata_task_t t_simdata = NULL;
   simdata_host_t h_simdata = NULL;
   int warning = 0;
+  int first_time = 1;
   e_surf_action_state_t state = SURF_ACTION_NOT_IN_THE_SYSTEM;
   
   CHECK_HOST();
@@ -57,15 +87,30 @@ MSG_error_t MSG_task_get(m_task_t * task,
   /* Get the task */
   h = MSG_host_self();
   h_simdata = h->simdata;
-  while ((t = xbt_fifo_pop(h_simdata->mbox[channel])) == NULL) {
-    xbt_assert0(!(h_simdata->sleeping[channel]),
-		"A process is already blocked on this channel");
+
+  DEBUG2("Waiting for a task on channel %d (%s)", channel,h->name);
+
+  while ((t = xbt_fifo_shift(h_simdata->mbox[channel])) == NULL) {
+    if(max_duration>0) {
+      if(!first_time) {
+	MSG_RETURN(MSG_OK);
+      }
+    }
+    xbt_assert2(!(h_simdata->sleeping[channel]),
+		"A process (%s(%d)) is already blocked on this channel",
+		h_simdata->sleeping[channel]->name,
+		h_simdata->sleeping[channel]->simdata->PID);
     h_simdata->sleeping[channel] = process; /* I'm waiting. Wake me up when you're ready */
-    MSG_process_suspend(process);
+    if(max_duration>0) {
+      __MSG_process_block(max_duration);
+    } else {
+      __MSG_process_block(-1);
+    }
     if(surf_workstation_resource->extension_public->get_state(h_simdata->host) 
        == SURF_CPU_OFF)
       MSG_RETURN(MSG_HOST_FAILURE);
     h_simdata->sleeping[channel] = NULL;
+    first_time = 0;
     /* OK, we should both be ready now. Are you there ? */
   }
 
@@ -75,21 +120,45 @@ MSG_error_t MSG_task_get(m_task_t * task,
 
   /* Transfer */
   t_simdata->using++;
+
   t_simdata->comm = surf_workstation_resource->extension_public->
     communicate(MSG_process_get_host(t_simdata->sender)->simdata->host,
-		h->simdata->host, t_simdata->message_size);
+		h->simdata->host, t_simdata->message_size,t_simdata->rate);
+  
   surf_workstation_resource->common_public->action_set_data(t_simdata->comm,t);
 
+  if(__MSG_process_isBlocked(t_simdata->sender)) 
+    __MSG_process_unblock(t_simdata->sender);
+
+  PAJE_PROCESS_PUSH_STATE(process,"C");  
+
   do {
     __MSG_task_wait_event(process, t);
     state=surf_workstation_resource->common_public->action_get_state(t_simdata->comm);
   } while (state==SURF_ACTION_RUNNING);
 
-  if(state == SURF_ACTION_DONE) MSG_RETURN(MSG_OK);
-  else if(surf_workstation_resource->extension_public->get_state(h_simdata->host) 
-	  == SURF_CPU_OFF)
+  if(t->simdata->using>1) {
+    xbt_fifo_unshift(msg_global->process_to_run,process);
+    xbt_context_yield();
+  }
+
+  PAJE_PROCESS_POP_STATE(process);
+  PAJE_COMM_STOP(process,t,channel);
+
+  if(state == SURF_ACTION_DONE) {
+    if(surf_workstation_resource->common_public->action_free(t_simdata->comm)) 
+      t_simdata->comm = NULL;
+    MSG_RETURN(MSG_OK);
+  } else if(surf_workstation_resource->extension_public->get_state(h_simdata->host) 
+	  == SURF_CPU_OFF) {
+    if(surf_workstation_resource->common_public->action_free(t_simdata->comm)) 
+      t_simdata->comm = NULL;
     MSG_RETURN(MSG_HOST_FAILURE);
-  else MSG_RETURN(MSG_TRANSFER_FAILURE);
+  } else {
+    if(surf_workstation_resource->common_public->action_free(t_simdata->comm)) 
+      t_simdata->comm = NULL;
+    MSG_RETURN(MSG_TRANSFER_FAILURE);
+  }
 }
 
 /** \ingroup msg_gos_functions
@@ -106,12 +175,96 @@ int MSG_task_Iprobe(m_channel_t channel)
   m_host_t h = NULL;
   simdata_host_t h_simdata = NULL;
 
+  DEBUG2("Probing on channel %d (%s)", channel,h->name);
   CHECK_HOST();
   h = MSG_host_self();
   h_simdata = h->simdata;
   return(xbt_fifo_getFirstItem(h_simdata->mbox[channel])!=NULL);
 }
 
+/** \ingroup msg_gos_functions
+ * \brief Test whether there is a pending communication on a channel, and who sent it.
+ *
+ * It takes one parameter.
+ * \param channel the channel on which the agent should be
+   listening. This value has to be >=0 and < than the maximal
+   number of channels fixed with MSG_set_channel_number().
+ * \return -1 if there is no pending communication and the PID of the process who sent it otherwise
+ */
+int MSG_task_probe_from(m_channel_t channel)
+{
+  m_host_t h = NULL;
+  simdata_host_t h_simdata = NULL;
+  xbt_fifo_item_t item;
+  m_task_t t;
+
+  CHECK_HOST();
+  h = MSG_host_self();
+  h_simdata = h->simdata;
+
+  DEBUG2("Probing on channel %d (%s)", channel,h->name);
+   
+  item = xbt_fifo_getFirstItem(h->simdata->mbox[channel]);
+  if (!item || !(t = xbt_fifo_get_item_content(item)))
+    return -1;
+   
+  return MSG_process_get_PID(t->simdata->sender);
+}
+
+MSG_error_t MSG_channel_select_from(m_channel_t channel, double max_duration,
+				    int *PID)
+{
+  m_host_t h = NULL;
+  simdata_host_t h_simdata = NULL;
+  xbt_fifo_item_t item;
+  m_task_t t;
+  int first_time = 1;
+  m_process_t process = MSG_process_self();
+
+  if(PID) {
+    *PID = -1;
+  }
+
+  if(max_duration==0.0) {
+    return MSG_task_probe_from(channel);
+  } else {
+    CHECK_HOST();
+    h = MSG_host_self();
+    h_simdata = h->simdata;
+    
+    DEBUG2("Probing on channel %d (%s)", channel,h->name);
+    while(!(item = xbt_fifo_getFirstItem(h->simdata->mbox[channel]))) {
+      if(max_duration>0) {
+	if(!first_time) {
+	  MSG_RETURN(MSG_OK);
+	}
+      }
+      xbt_assert2(!(h_simdata->sleeping[channel]),
+		  "A process (%s(%d)) is already blocked on this channel",
+		  h_simdata->sleeping[channel]->name,
+		  h_simdata->sleeping[channel]->simdata->PID);
+      h_simdata->sleeping[channel] = process; /* I'm waiting. Wake me up when you're ready */
+      if(max_duration>0) {
+	__MSG_process_block(max_duration);
+      } else {
+	__MSG_process_block(-1);
+      }
+      if(surf_workstation_resource->extension_public->get_state(h_simdata->host) 
+	 == SURF_CPU_OFF) {
+	MSG_RETURN(MSG_HOST_FAILURE);
+      }
+      h_simdata->sleeping[channel] = NULL;
+      first_time = 0;
+    }
+    if (!item || !(t = xbt_fifo_get_item_content(item))) {
+      MSG_RETURN(MSG_OK);
+    }
+    if(PID) {
+      *PID = MSG_process_get_PID(t->simdata->sender);
+    }
+    MSG_RETURN(MSG_OK);
+  }
+}
 /** \ingroup msg_gos_functions
  * \brief Put a task on a channel of an host and waits for the end of the
  * transmission.
@@ -148,36 +301,73 @@ MSG_error_t MSG_task_put(m_task_t task,
 
   task_simdata = task->simdata;
   task_simdata->sender = process;
-
+  xbt_assert0(task_simdata->using==1,"Gargl!");
+  task_simdata->comm = NULL;
   
   local_host = ((simdata_process_t) process->simdata)->host;
   remote_host = dest;
 
+  DEBUG4("Trying to send a task (%lg Mb) from %s to %s on channel %d", 
+	 task->simdata->message_size,local_host->name, remote_host->name, channel);
+
   xbt_fifo_push(((simdata_host_t) remote_host->simdata)->
 		mbox[channel], task);
+
+  PAJE_COMM_START(process,task,channel);
     
   if(remote_host->simdata->sleeping[channel]) 
-    MSG_process_resume(remote_host->simdata->sleeping[channel]);
-  else {
-    process->simdata->put_host = dest;
-    process->simdata->put_channel = channel;
-    MSG_process_suspend(process);
-    process->simdata->put_host = NULL;
-    process->simdata->put_channel = -1;
-  }
+    __MSG_process_unblock(remote_host->simdata->sleeping[channel]);
 
-  do {
+  process->simdata->put_host = dest;
+  process->simdata->put_channel = channel;
+  while(!(task_simdata->comm)) 
+    __MSG_process_block(-1);
+  surf_workstation_resource->common_public->action_use(task_simdata->comm);
+  process->simdata->put_host = NULL;
+  process->simdata->put_channel = -1;
+
+
+  PAJE_PROCESS_PUSH_STATE(process,"C");  
+
+  state=surf_workstation_resource->common_public->action_get_state(task_simdata->comm);
+  while (state==SURF_ACTION_RUNNING) {
     __MSG_task_wait_event(process, task);
     state=surf_workstation_resource->common_public->action_get_state(task_simdata->comm);
-  } while (state==SURF_ACTION_RUNNING);
+  }
     
   MSG_task_destroy(task);
 
-  if(state == SURF_ACTION_DONE) MSG_RETURN(MSG_OK);
-  else if(surf_workstation_resource->extension_public->get_state(local_host->simdata->host) 
-	  == SURF_CPU_OFF)
+  PAJE_PROCESS_POP_STATE(process);  
+
+  if(state == SURF_ACTION_DONE) {
+    if(surf_workstation_resource->common_public->action_free(task_simdata->comm)) 
+      task_simdata->comm = NULL;
+    MSG_RETURN(MSG_OK);
+  } else if(surf_workstation_resource->extension_public->get_state(local_host->simdata->host) 
+	    == SURF_CPU_OFF) {
+    if(surf_workstation_resource->common_public->action_free(task_simdata->comm)) 
+      task_simdata->comm = NULL;
     MSG_RETURN(MSG_HOST_FAILURE);
-  else MSG_RETURN(MSG_TRANSFER_FAILURE);
+  } else { 
+    if(surf_workstation_resource->common_public->action_free(task_simdata->comm)) 
+      task_simdata->comm = NULL;
+    MSG_RETURN(MSG_TRANSFER_FAILURE);
+  }
+}
+
+/** \ingroup msg_gos_functions
+ * \brief Does exactly the same as MSG_task_put but with a bounded transmition 
+ * rate.
+ *
+ * \sa MSG_task_put
+ */
+MSG_error_t MSG_task_put_bounded(m_task_t task,
+				 m_host_t dest, m_channel_t channel,
+				 double max_rate)
+{
+  task->simdata->rate=max_rate;
+  return(MSG_task_put(task, dest, channel));
+  task->simdata->rate=-1.0;
 }
 
 /** \ingroup msg_gos_functions
@@ -193,9 +383,16 @@ MSG_error_t MSG_task_put(m_task_t task,
 MSG_error_t MSG_task_execute(m_task_t task)
 {
   m_process_t process = MSG_process_self();
+  MSG_error_t res;
+
+  DEBUG1("Computing on %s", process->simdata->host->name);
 
   __MSG_task_execute(process, task);
-  return __MSG_wait_for_computation(process,task);
+
+  PAJE_PROCESS_PUSH_STATE(process,"E");  
+  res = __MSG_wait_for_computation(process,task);
+  PAJE_PROCESS_POP_STATE(process);
+  return res;
 }
 
 void __MSG_task_execute(m_process_t process, m_task_t task)
@@ -225,12 +422,21 @@ MSG_error_t __MSG_wait_for_computation(m_process_t process, m_task_t task)
   simdata->using--;
     
 
-  if(state == SURF_ACTION_DONE) MSG_RETURN(MSG_OK);
-  else if(surf_workstation_resource->extension_public->
-	  get_state(MSG_process_get_host(process)->simdata->host) 
-	  == SURF_CPU_OFF)
+  if(state == SURF_ACTION_DONE) {
+    if(surf_workstation_resource->common_public->action_free(simdata->compute)) 
+      simdata->compute = NULL;
+    MSG_RETURN(MSG_OK);
+  } else if(surf_workstation_resource->extension_public->
+	    get_state(MSG_process_get_host(process)->simdata->host) 
+	    == SURF_CPU_OFF) {
+    if(surf_workstation_resource->common_public->action_free(simdata->compute)) 
+      simdata->compute = NULL;
     MSG_RETURN(MSG_HOST_FAILURE);
-  else MSG_RETURN(MSG_TRANSFER_FAILURE);
+  } else {
+    if(surf_workstation_resource->common_public->action_free(simdata->compute)) 
+      simdata->compute = NULL;
+    MSG_RETURN(MSG_TRANSFER_FAILURE);
+  }
 }
 
 /** \ingroup msg_gos_functions
@@ -240,7 +446,7 @@ MSG_error_t __MSG_wait_for_computation(m_process_t process, m_task_t task)
  *
  * \param nb_sec a number of second
  */
-MSG_error_t MSG_process_sleep(long double nb_sec)
+MSG_error_t MSG_process_sleep(double nb_sec)
 {
   e_surf_action_state_t state = SURF_ACTION_NOT_IN_THE_SYSTEM;
   m_process_t process = MSG_process_self();
@@ -267,16 +473,23 @@ MSG_error_t MSG_process_sleep(long double nb_sec)
   if(state == SURF_ACTION_DONE) {
     if(surf_workstation_resource->extension_public->
        get_state(MSG_process_get_host(process)->simdata->host) 
-       == SURF_CPU_OFF)
+       == SURF_CPU_OFF) {
+      if(surf_workstation_resource->common_public->action_free(simdata->compute)) 
+	simdata->compute = NULL;
       MSG_RETURN(MSG_HOST_FAILURE);
-
-    if(MSG_process_isSuspended(process)) {
-      MSG_process_suspend(MSG_process_self());
+    }
+    if(__MSG_process_isBlocked(process)) {
+      __MSG_process_unblock(MSG_process_self());
     }
     if(surf_workstation_resource->extension_public->
        get_state(MSG_process_get_host(process)->simdata->host) 
-       == SURF_CPU_OFF)
+       == SURF_CPU_OFF) {
+      if(surf_workstation_resource->common_public->action_free(simdata->compute)) 
+	simdata->compute = NULL;
       MSG_RETURN(MSG_HOST_FAILURE);
+    }
+    if(surf_workstation_resource->common_public->action_free(simdata->compute)) 
+      simdata->compute = NULL;
     MSG_task_destroy(dummy);
     MSG_RETURN(MSG_OK);
   } else MSG_RETURN(MSG_HOST_FAILURE);
@@ -286,12 +499,15 @@ MSG_error_t MSG_process_sleep(long double nb_sec)
  * \brief Return the number of MSG tasks currently running on a
  * the host of the current running process.
  */
-int MSG_get_msgload(void) 
+static int MSG_get_msgload(void) 
 {
+  m_process_t process;
+   
   CHECK_HOST();
-  xbt_assert0(0,"Not implemented yet!");
   
-  return 1;
+  xbt_assert0(0, "This function is still to be specified correctly (what do you mean by 'load', exactly?). In the meantime, please don't use it");
+  process = MSG_process_self();
+  return xbt_fifo_size(process->simdata->host->simdata->process_list);
 }
 
 /** \ingroup msg_gos_functions
@@ -303,4 +519,3 @@ MSG_error_t MSG_get_errno(void)
 {
   return PROCESS_GET_ERRNO();
 }
-