X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/5834b3e37665fac531ccb6118397895604d5d569..c665004452a6a694cea474e402376893b774eca1:/src/simix/smx_synchro.c

diff --git a/src/simix/smx_synchro.c b/src/simix/smx_synchro.c
index 730e2cd520..5c95b5da26 100644
--- a/src/simix/smx_synchro.c
+++ b/src/simix/smx_synchro.c
@@ -11,7 +11,7 @@
 
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_synchro, simix,
-				"Logging specific to SIMIX (synchronization)");
+                                "Logging specific to SIMIX (synchronization)");
 
 
 /****************************** Synchronization *******************************/
@@ -26,12 +26,12 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_synchro, simix,
  */
 smx_mutex_t SIMIX_mutex_init()
 {
-	smx_mutex_t m = xbt_new0(s_smx_mutex_t,1);
-	s_smx_process_t p; /* useful to initialize sleeping swag */
-	/* structures initialization */
-	m->using = 0;
-	m->sleeping = xbt_swag_new(xbt_swag_offset(p, synchro_hookup));
-	return m;
+  smx_mutex_t m = xbt_new0(s_smx_mutex_t, 1);
+  s_smx_process_t p;            /* useful to initialize sleeping swag */
+  /* structures initialization */
+  m->refcount = 0;
+  m->sleeping = xbt_swag_new(xbt_swag_offset(p, synchro_hookup));
+  return m;
 }
 
 /**
@@ -42,30 +42,29 @@ smx_mutex_t SIMIX_mutex_init()
  */
 void SIMIX_mutex_lock(smx_mutex_t mutex)
 {
-	smx_process_t self = SIMIX_process_self();
-	xbt_assert0((mutex != NULL), "Invalid parameters");
-	
-
-	if (mutex->using) {
-		/* somebody using the mutex, block */
-		xbt_swag_insert(self, mutex->sleeping);
-		self->simdata->mutex = mutex;
-		/* wait for some process make the unlock and wake up me from mutex->sleeping */
-		xbt_context_yield();
-		self->simdata->mutex = NULL;
-
-		/* verify if the process was suspended */
-		while (self->simdata->suspended) {
-			xbt_context_yield();
-		}
-
-		mutex->using = 1;
-	}
-	else {
-		/* mutex free */
-		mutex->using = 1;
-	}
-	return;
+  smx_process_t self = SIMIX_process_self();
+  xbt_assert0((mutex != NULL), "Invalid parameters");
+
+
+  if (mutex->refcount) {
+    /* somebody using the mutex, block */
+    xbt_swag_insert(self, mutex->sleeping);
+    self->mutex = mutex;
+    /* wait for some process make the unlock and wake up me from mutex->sleeping */
+    SIMIX_process_yield();
+    self->mutex = NULL;
+
+    /* verify if the process was suspended */
+    while (self->suspended) {
+      SIMIX_process_yield();
+    }
+
+    mutex->refcount = 1;
+  } else {
+    /* mutex free */
+    mutex->refcount = 1;
+  }
+  return;
 }
 
 /**
@@ -77,14 +76,14 @@ void SIMIX_mutex_lock(smx_mutex_t mutex)
  */
 int SIMIX_mutex_trylock(smx_mutex_t mutex)
 {
-	xbt_assert0((mutex != NULL), "Invalid parameters");
-	
-	if (mutex->using) 
-		return 0;
-	else {
-		mutex->using = 1;
-		return 1;
-	}
+  xbt_assert0((mutex != NULL), "Invalid parameters");
+
+  if (mutex->refcount)
+    return 0;
+  else {
+    mutex->refcount = 1;
+    return 1;
+  }
 }
 
 /**
@@ -95,20 +94,19 @@ int SIMIX_mutex_trylock(smx_mutex_t mutex)
  */
 void SIMIX_mutex_unlock(smx_mutex_t mutex)
 {
-	smx_process_t p;	/*process to wake up */
-
-	xbt_assert0((mutex != NULL), "Invalid parameters");
-
-	if (xbt_swag_size(mutex->sleeping) > 0) {
-		p = xbt_swag_extract(mutex->sleeping);
-		mutex->using = 0;
-		xbt_swag_insert(p, simix_global->process_to_run);
-	}
-	else {
-		/* nobody to wake up */
-		mutex->using = 0;
-	}
-	return;
+  smx_process_t p;              /*process to wake up */
+
+  xbt_assert0((mutex != NULL), "Invalid parameters");
+
+  if (xbt_swag_size(mutex->sleeping) > 0) {
+    p = xbt_swag_extract(mutex->sleeping);
+    mutex->refcount = 0;
+    xbt_swag_insert(p, simix_global->process_to_run);
+  } else {
+    /* nobody to wake up */
+    mutex->refcount = 0;
+  }
+  return;
 }
 
 /**
@@ -119,13 +117,13 @@ void SIMIX_mutex_unlock(smx_mutex_t mutex)
  */
 void SIMIX_mutex_destroy(smx_mutex_t mutex)
 {
-	if ( mutex == NULL )
-		return ;
-	else {
-		xbt_swag_free(mutex->sleeping);
-		xbt_free(mutex);
-		return ;
-	}
+  if (mutex == NULL)
+    return;
+  else {
+    xbt_swag_free(mutex->sleeping);
+    xbt_free(mutex);
+    return;
+  }
 }
 
 /******************************** Conditional *********************************/
@@ -133,37 +131,40 @@ void SIMIX_mutex_destroy(smx_mutex_t mutex)
 /**
  * \brief Initialize a condition.
  *
- * Allocs and creates the data for the condition. It have to be called before the utilisation of the condition.
+ * Allocates and creates the data for the condition.
+ * It have to be called before the use of the condition.
  * \return A condition
  */
 smx_cond_t SIMIX_cond_init()
 {
-	smx_cond_t cond = xbt_new0(s_smx_cond_t,1);
-	s_smx_process_t p;
-	
-	cond->sleeping = xbt_swag_new(xbt_swag_offset(p,synchro_hookup));
-	cond->actions = xbt_fifo_new();
-	cond->mutex = NULL;
-	return cond;
+  smx_cond_t cond = xbt_new0(s_smx_cond_t, 1);
+  s_smx_process_t p;
+
+  cond->sleeping = xbt_swag_new(xbt_swag_offset(p, synchro_hookup));
+  cond->actions = xbt_fifo_new();
+  cond->mutex = NULL;
+  return cond;
 }
 
 /**
  * \brief Signalizes a condition.
  *
- * Signalizes a condition and wakes up a sleping process. If there are no process sleeping, no action is done.
+ * Signalizes a condition and wakes up a sleeping process. If there are no process sleeping, no action is done.
  * \param cond A condition
  */
 void SIMIX_cond_signal(smx_cond_t cond)
 {
-	xbt_assert0((cond != NULL), "Invalid parameters");
-	smx_process_t proc = NULL;
+  smx_process_t proc = NULL;
+  DEBUG1("Signal condition %p", cond);
+  xbt_assert0((cond != NULL), "Invalid parameters");
+
 
-	if (xbt_swag_size(cond->sleeping) >= 1) {
-		proc = xbt_swag_extract(cond->sleeping);
-		xbt_swag_insert(proc, simix_global->process_to_run);
-	}
+  if (xbt_swag_size(cond->sleeping) >= 1) {
+    proc = xbt_swag_extract(cond->sleeping);
+    xbt_swag_insert(proc, simix_global->process_to_run);
+  }
 
-	return;
+  return;
 }
 
 /**
@@ -173,54 +174,56 @@ void SIMIX_cond_signal(smx_cond_t cond)
  * \param cond A condition
  * \param mutex A mutex
  */
-void SIMIX_cond_wait(smx_cond_t cond,smx_mutex_t mutex)
+void SIMIX_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
 {
-	smx_action_t act_sleep;
-	xbt_assert0((mutex != NULL), "Invalid parameters");
-	
-	cond->mutex = mutex;
-
-	SIMIX_mutex_unlock(mutex);
-	/* create an action null only if there are no actions already on the condition, usefull if the host crashs */
-	if (xbt_fifo_size(cond->actions) ==0 ) {
-		act_sleep = SIMIX_action_sleep(SIMIX_host_self(), -1);
-		SIMIX_register_action_to_condition(act_sleep,cond);
-		SIMIX_register_condition_to_action(act_sleep,cond);
-		__SIMIX_cond_wait(cond);
-		xbt_fifo_pop(act_sleep->cond_list);
-		SIMIX_action_destroy(act_sleep);
-	}
-	else {
-		__SIMIX_cond_wait(cond);
-	}
-	/* get the mutex again */
-	SIMIX_mutex_lock(cond->mutex);
-
-	return;
+  smx_action_t act_sleep;
+
+  DEBUG1("Wait condition %p", cond);
+
+  /* If there is a mutex unlock it */
+  if(mutex != NULL){
+    cond->mutex = mutex;
+    SIMIX_mutex_unlock(mutex);
+  }
+  
+  /* Always create an action null in case there is a host failure */
+  act_sleep = SIMIX_action_sleep(SIMIX_host_self(), -1);
+  SIMIX_action_set_name(act_sleep,bprintf("Wait condition %p", cond));
+  SIMIX_process_self()->waiting_action = act_sleep;
+  SIMIX_register_action_to_condition(act_sleep, cond);
+  __SIMIX_cond_wait(cond);
+  SIMIX_process_self()->waiting_action = NULL;
+  SIMIX_unregister_action_to_condition(act_sleep, cond);
+  SIMIX_action_destroy(act_sleep);
+
+  /* get the mutex again if necessary */
+  if(mutex != NULL)
+    SIMIX_mutex_lock(cond->mutex);
+
+  return;
 }
 
 xbt_fifo_t SIMIX_cond_get_actions(smx_cond_t cond)
 {
-	xbt_assert0((cond != NULL), "Invalid parameters");
-	return cond->actions;
+  xbt_assert0((cond != NULL), "Invalid parameters");
+  return cond->actions;
 }
 
 void __SIMIX_cond_wait(smx_cond_t cond)
 {
-	smx_process_t self = SIMIX_process_self();
-	xbt_assert0((cond != NULL), "Invalid parameters");
-	
-	/* process status */	
-
-	self->simdata->cond = cond;
-	xbt_swag_insert(self, cond->sleeping);
-	xbt_context_yield();
-	self->simdata->cond = NULL;
-	while (self->simdata->suspended) {
-		xbt_context_yield();
-	}
-	return;
-
+  smx_process_t self = SIMIX_process_self();
+  xbt_assert0((cond != NULL), "Invalid parameters");
+
+  /* process status */
+
+  self->cond = cond;
+  xbt_swag_insert(self, cond->sleeping);
+  SIMIX_process_yield();
+  self->cond = NULL;
+  while (self->suspended) {
+    SIMIX_process_yield();
+  }
+  return;
 }
 
 /**
@@ -231,36 +234,40 @@ void __SIMIX_cond_wait(smx_cond_t cond)
  * \param mutex A mutex
  * \param max_duration Timeout time
  */
-void SIMIX_cond_wait_timeout(smx_cond_t cond,smx_mutex_t mutex, double max_duration)
+void SIMIX_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex,
+                             double max_duration)
 {
-	xbt_assert0((mutex != NULL), "Invalid parameters");
-	smx_action_t act_sleep;
-
-	cond->mutex = mutex;
-
-	SIMIX_mutex_unlock(mutex);
-	if (max_duration >=0) {
-		act_sleep = SIMIX_action_sleep(SIMIX_host_self(), max_duration);
-		SIMIX_register_action_to_condition(act_sleep,cond);
-		SIMIX_register_condition_to_action(act_sleep,cond);
-		__SIMIX_cond_wait(cond);
-		xbt_fifo_remove(act_sleep->cond_list,cond);
-		if ( SIMIX_action_get_state(act_sleep) == SURF_ACTION_DONE) {
-			SIMIX_action_destroy(act_sleep);
-			THROW0(timeout_error,0,"Condition timeout"); 
-		}
-		else {
-			SIMIX_action_destroy(act_sleep);
-		}
-
-	}
-	else
-		__SIMIX_cond_wait(cond);
-
-	/* get the mutex again */
-	SIMIX_mutex_lock(cond->mutex);
-
-	return;
+  smx_action_t act_sleep;
+
+  DEBUG1("Timed wait condition %p", cond);
+
+  /* If there is a mutex unlock it */
+  if(mutex != NULL){
+    cond->mutex = mutex;
+    SIMIX_mutex_unlock(mutex);
+  }
+
+  if (max_duration >= 0) {
+    act_sleep = SIMIX_action_sleep(SIMIX_host_self(), max_duration);
+    SIMIX_action_set_name(act_sleep,bprintf("Timed wait condition %p (max_duration:%f)", cond,max_duration));
+    SIMIX_register_action_to_condition(act_sleep, cond);
+    SIMIX_process_self()->waiting_action = act_sleep;
+    __SIMIX_cond_wait(cond);
+    SIMIX_process_self()->waiting_action = NULL;
+    SIMIX_unregister_action_to_condition(act_sleep, cond);
+    if (SIMIX_action_get_state(act_sleep) == SURF_ACTION_DONE) {
+      SIMIX_action_destroy(act_sleep);
+      THROW1(timeout_error, 0, "Condition timeout after %f",max_duration);
+    } else {
+      SIMIX_action_destroy(act_sleep);
+    }
+
+  } else
+    SIMIX_cond_wait(cond,NULL);
+
+  /* get the mutex again if necessary */
+  if(mutex != NULL)
+    SIMIX_mutex_lock(cond->mutex);
 }
 
 /**
@@ -271,16 +278,16 @@ void SIMIX_cond_wait_timeout(smx_cond_t cond,smx_mutex_t mutex, double max_durat
  */
 void SIMIX_cond_broadcast(smx_cond_t cond)
 {
-	xbt_assert0((cond != NULL), "Invalid parameters");
-	smx_process_t proc = NULL;
-	smx_process_t proc_next = NULL;
+  smx_process_t proc = NULL;
+  smx_process_t proc_next = NULL;
 
-	xbt_swag_foreach_safe(proc,proc_next,cond->sleeping) {
-		xbt_swag_remove(proc,cond->sleeping);
-		xbt_swag_insert(proc, simix_global->process_to_run);
-	}
+  xbt_assert0((cond != NULL), "Invalid parameters");
 
-	return;
+  DEBUG1("Broadcast condition %p", cond);
+  xbt_swag_foreach_safe(proc, proc_next, cond->sleeping) {
+    xbt_swag_remove(proc, cond->sleeping);
+    xbt_swag_insert(proc, simix_global->process_to_run);
+  }
 }
 
 /**
@@ -291,29 +298,198 @@ void SIMIX_cond_broadcast(smx_cond_t cond)
  */
 void SIMIX_cond_destroy(smx_cond_t cond)
 {
-	if ( cond == NULL )
-		return ;
-	else {
-		xbt_assert0( xbt_swag_size(cond->sleeping) == 0 , "Cannot destroy conditional");
-		xbt_swag_free(cond->sleeping);
-		xbt_fifo_free(cond->actions);
-		xbt_free(cond);
-		return;
-	}
+  DEBUG1("Destroy condition %p", cond);
+  if (cond == NULL)
+    return;
+  else {
+    xbt_fifo_item_t item = NULL;
+    smx_action_t action = NULL;
+
+    xbt_assert0(xbt_swag_size(cond->sleeping) == 0,
+                "Cannot destroy conditional since someone is still using it");
+    xbt_swag_free(cond->sleeping);
+
+    DEBUG1("%d actions registered", xbt_fifo_size(cond->actions));
+    __SIMIX_cond_display_actions(cond);
+    xbt_fifo_foreach(cond->actions, item, action, smx_action_t) {
+      SIMIX_unregister_action_to_condition(action, cond);
+    }
+    __SIMIX_cond_display_actions(cond);
+
+    xbt_fifo_free(cond->actions);
+    xbt_free(cond);
+    return;
+  }
 }
 
-/**
- * 	\brief Set a condition to an action
- *
- * 	Creates the "link" between an action and a condition. You have to call this function when you create an action and want to wait its ending. 
- *	\param action SIMIX action
- *	\param cond SIMIX cond
- */
-void SIMIX_register_condition_to_action(smx_action_t action, smx_cond_t cond)
+void SIMIX_cond_display_info(smx_cond_t cond)
 {
-	xbt_assert0( (action != NULL) && (cond != NULL), "Invalid parameters");
+  if (cond == NULL)
+    return;
+  else {
+    smx_process_t process = NULL;
+
+    INFO0("Blocked process on this condition:");
+    xbt_swag_foreach(process, cond->sleeping) {
+      INFO2("\t %s running on host %s", process->name,
+            process->smx_host->name);
+    }
+  }
+}
+
+/* ************************** Semaphores ************************************** */
+#define SMX_SEM_NOLIMIT 99999
+/** @brief Initialize a semaphore */
+smx_sem_t SIMIX_sem_init(int capacity) {
+  smx_sem_t sem = xbt_new0(s_smx_sem_t, 1);
+  s_smx_process_t p;
+
+  sem->sleeping = xbt_swag_new(xbt_swag_offset(p, synchro_hookup));
+  sem->actions = xbt_fifo_new();
+  sem->capacity = capacity;
+  return sem;
+}
+/** @brief Destroys a semaphore */
+void SIMIX_sem_destroy(smx_sem_t sem) {
+  DEBUG1("Destroy semaphore %p", sem);
+  if (sem == NULL)
+    return;
+
+  xbt_fifo_item_t item = NULL;
+  smx_action_t action = NULL;
+
+  xbt_assert0(xbt_swag_size(sem->sleeping) == 0,
+      "Cannot destroy semaphore since someone is still using it");
+  xbt_swag_free(sem->sleeping);
+
+  DEBUG1("%d actions registered", xbt_fifo_size(sem->actions));
+  xbt_fifo_foreach(sem->actions, item, action, smx_action_t) {
+    SIMIX_unregister_action_to_semaphore(action, sem);
+  }
+
+  xbt_fifo_free(sem->actions);
+  xbt_free(sem);
+}
+
+/** @brief release the semaphore
+ *
+ * The first locked process on this semaphore is unlocked.
+ * If no one was blocked, the semaphore capacity is increased by 1.
+ * */
+void SIMIX_sem_release(smx_sem_t sem) {
+  if (xbt_swag_size(sem->sleeping) >= 1) {
+    smx_process_t proc = xbt_swag_extract(sem->sleeping);
+    xbt_swag_insert(proc, simix_global->process_to_run);
+  } else if (sem->capacity != SMX_SEM_NOLIMIT) {
+    sem->capacity++;
+  }
+}
+/** @brief make sure the semaphore will never be blocking again
+ *
+ * This function is not really in the semaphore spirit. It makes
+ * sure that the semaphore will never be blocking anymore.
+ *
+ * Releasing and acquiring the semaphore after calling this
+ * function is a noop. Such "broken" semaphores are useful to
+ * implement something between condition variables (with broadcast)
+ * and semaphore (with memory). It's like a semaphore signaled for ever.
+ *
+ * There is no way to reset the semaphore to a more regular state afterward.
+ * */
+void SIMIX_sem_release_forever(smx_sem_t sem) {
+  smx_process_t proc = NULL;
+  smx_process_t proc_next = NULL;
+
+  DEBUG1("Broadcast semaphore %p", sem);
+  xbt_swag_foreach_safe(proc, proc_next, sem->sleeping) {
+    xbt_swag_remove(proc, sem->sleeping);
+    xbt_swag_insert(proc, simix_global->process_to_run);
+  }
+}
+
+static inline void SIMIX_sem_block_onto(smx_sem_t sem) {
+  smx_process_t self = SIMIX_process_self();
 
-	xbt_fifo_push(action->cond_list,cond);
+  /* process status */
+  self->sem = sem;
+  xbt_swag_insert(self, sem->sleeping);
+  SIMIX_process_yield();
+  self->sem = NULL;
+  while (self->suspended)
+    SIMIX_process_yield();
 }
 
+/** @brief Returns true if acquiring this semaphore would block */
+int SIMIX_sem_would_block(smx_sem_t sem) {
+  return (sem->capacity>0);
+}
 
+/**
+ * \brief Waits on a semaphore
+ *
+ * If the capacity>0, decrease the capacity.
+ *
+ * If capacity==0, locks the current process
+ * until someone call SIMIX_sem_release() on this semaphore
+ */
+void SIMIX_sem_acquire(smx_sem_t sem) {
+  smx_action_t act_sleep;
+
+  DEBUG1("Wait semaphore %p", sem);
+
+  if (sem->capacity == SMX_SEM_NOLIMIT)
+    return; /* don't even decrease it if wide open */
+
+  /* If capacity sufficient, decrease it */
+  if (sem->capacity>0) {
+    sem->capacity--;
+    return;
+  }
+
+  /* Always create an action null in case there is a host failure */
+  act_sleep = SIMIX_action_sleep(SIMIX_host_self(), -1);
+  SIMIX_action_set_name(act_sleep,bprintf("Locked in semaphore %p", sem));
+  SIMIX_process_self()->waiting_action = act_sleep;
+  SIMIX_register_action_to_semaphore(act_sleep, sem);
+  SIMIX_sem_block_onto(sem);
+  SIMIX_process_self()->waiting_action = NULL;
+  SIMIX_unregister_action_to_semaphore(act_sleep, sem);
+  SIMIX_action_destroy(act_sleep);
+}
+/**
+ * \brief Tries to acquire a semaphore before a timeout
+ *
+ * Same behavior of #SIMIX_sem_acquire, but waits a maximum time and throws an timeout_error if it happens.
+ */
+void SIMIX_sem_acquire_timeout(smx_sem_t sem, double max_duration) {
+  smx_action_t act_sleep;
+
+  DEBUG2("Timed wait semaphore %p (timeout:%f)", sem,max_duration);
+
+  if (sem->capacity == SMX_SEM_NOLIMIT)
+    return; /* don't even decrease it if wide open */
+
+  /* If capacity sufficient, decrease it */
+  if (sem->capacity>0) {
+    sem->capacity--;
+    return;
+  }
+
+  if (max_duration >= 0) {
+    act_sleep = SIMIX_action_sleep(SIMIX_host_self(), max_duration);
+    SIMIX_action_set_name(act_sleep,bprintf("Timed wait semaphore %p (max_duration:%f)", sem,max_duration));
+    SIMIX_register_action_to_semaphore(act_sleep, sem);
+    SIMIX_process_self()->waiting_action = act_sleep;
+    SIMIX_sem_block_onto(sem);
+    SIMIX_process_self()->waiting_action = NULL;
+    SIMIX_unregister_action_to_semaphore(act_sleep, sem);
+    if (SIMIX_action_get_state(act_sleep) == SURF_ACTION_DONE) {
+      SIMIX_action_destroy(act_sleep);
+      THROW1(timeout_error, 0, "Semaphore acquire timeouted after %f",max_duration);
+    } else {
+      SIMIX_action_destroy(act_sleep);
+    }
+
+  } else
+    SIMIX_sem_acquire(sem);
+}