Changes between Version 12 and Version 13 of AS6-TME-B7

Timestamp:

Apr 11, 2022, 8:50:43 PM (2 years ago)

Author:

franck

Comment:

--

AS6-TME-B7

@@ -165 +165 @@
 
 
-En cours, nous avons vu le mécanisme de base, le spinlock (ou busylock) réalisant une prise de verrou par attente active et le mutex ayant aussi comme finalité de prendre un verrou, mais cette fois sans attente active, en organisant une liste d'attente des threads. Notez que nous avons présenté les spinlocks pour le noyau et les mutex pour l'utilisateur, mais il est parfaitement possible d'avoir des spinlocks en mode utilisateur (LL et SC ne sont pas des instructions privilégiées) et mutex en mode noyau.
-
-Il existe d'autres mécanismes de synchronisation, par exemple, les sémaphores, les variables de conditions, les read-write lock, ou les barrières de synchronisation. Nous allons, ici nous intéresser aux barrières.
-
-Une barrière de synchronisation est utilisée pour synchroniser les étapes de calculs réalisés par plusieurs threads. Supposons que l'on souhaite exécuter deux threads en parallèle et que l'on veuille attendre que les deux aient terminé leur travail avant de recommencer un travail. Il faut que les deux threads se donnent rendez-vous à la fin de leur calcul.
+En cours, nous avons vu le mécanisme de base, le spinlock (ou busylock) réalisant une prise de verrou par attente active. Nous avons aussi vu le mutex ayant aussi comme finalité de prendre un verrou, mais cette fois sans attente active, en organisant une liste d'attente des threads. Notez que nous avons présenté les spinlocks pour le noyau et les mutex pour l'utilisateur, mais il est parfaitement possible d'avoir des spinlocks en mode utilisateur (LL et SC n'étant pas des instructions privilégiées) et des mutex en mode noyau.
+
+Il existe plein d'autres mécanismes de synchronisation, par exemple, les sémaphores, les variables de conditions, les read-write lock, ou les barrières de synchronisation. Nous allons, ici nous intéresser aux barrières.
+
+Les barrières de synchronisation sont utilisées pour synchroniser les étapes de calculs réalisés par plusieurs threads. Supposons que l'on souhaite exécuter deux threads en parallèle et que l'on veuille attendre que les deux aient terminé leur travail avant de recommencer un travail. Il faut que les deux threads se donnent rendez-vous à la fin de leur calcul.
+
+L'API des barrières est composée de trois functions (prototypes définis dans `ulib/thread.h` pour les appels systèmes coté utilisateur et dans `kernel/ksynchro.h` pour les prototypes de fonctions implémentées) c'est évidemment les mêmes prototypes (si vous ne comprenez pas pourquoi, demandez le moi).
+
+{{{#!c
+//--------------------------------------------------------------------------------------------------
+// Barrier API 
+//--------------------------------------------------------------------------------------------------
+
+/**
+ * \brief   hidden barrier type, the user do not what is in the barrier structure
+ */
+typedef struct thread_barrier_s * thread_barrier_t;
+
+/**
+ * \brief   creates or initialize a barrier depending the value of barrier parameter
+ * \param   barrier a pointer referencing the barrier, there are two cases
+ *                  1) if *barrier == NULL then allocate a new barrier, then initialize count
+ *                  2) if *barrier != NULL it the barrier already exists, just initialize count 
+ * \param   count   number of expected threads for this barrier
+ * \return  SUCCESS if it all goes fine or
+ *          EINVAL  The value specified by count is equal to zero.
+ *          ENOMEM  Insufficient memory exists to initialize the barrier
+ *          EBUSY   The implementation has detected an attempt to reinitialize a barrier 
+ *                  while it is in use (for example, while being used in a  thread_barrier_wait()  
+ *                  call) by  another thread.
+ */
+extern int thread_barrier_init (thread_barrier_t * barrier, size_t count);
+
+/**
+ * \brief   wait to the referenced barrier, it is a blocking operation for all thread but the last
+ *          the last arrived thread doesn't wait and notifies the other threads which becomes READY 
+ * \param   barrier a pointer referencing a barrier 
+ * \return  SUCCESS or FEALURE
+ */
+extern int thread_barrier_wait (thread_barrier_t * barrier);
+
+/**
+ * \brief   destroy the referenced barrier
+ *          If a thread is waiting at the barrier, then the destruction is not done, it is an error
+ * \param   barrier a pointer referencing a barrier 
+ * \return  SUCCESS if it all goes fine or
+ *          EINVAL  wrong argument
+ *          EBUSY   The implementation has detected an attempt to destroy a barrier 
+ *                  while it is in use (for example, while being used in a  thread_barrier_wait()  
+ *                  call) by  another thread.
+ */
+extern int thread_barrier_destroy (thread_barrier_t * barrier);
+
+}}}
 
 {{{#!c