Changes between Version 15 and Version 16 of AS6-TME-B7

Timestamp:

Apr 11, 2022, 9:13:23 PM (2 years ago)

Author:

franck

Comment:

--

AS6-TME-B7

@@ -162 +162 @@
 
 
-== B.1. Mécanisme des barrières
+== B.1.
+
+
+== B.2.
+
+
+== B.3. Mécanisme des barrières
 
 
@@ -275 +281 @@
 }}}
 
+Maintenant, vous n'allez pas avoir à écrire le code des barrières mais voue allez devoir répondre à quelques questions
+{{{#!c
+#define MAGIC_BARRIER   0xDEADBABA
+
+struct thread_barrier_s {
+    int         magic;          ///< magic number to check the validity of the barrier
+    spinlock_t  lock;           ///< protection against parallel modifications
+    size_t      expected;       ///< number of expected threads
+    size_t      waiting;        ///< number of threads waiting
+    list_t      wait;           ///< list element to chain threads that are wainting for the mutex
+};
+
+int thread_barrier_init (thread_barrier_t * barrier, size_t count)
+{
+    thread_barrier_t b = *barrier;                          // get the barrier pointer
+
+    if (count == 0) return EINVAL;                          // count must be > 0
+
+    if (b == NULL) {                                        // if we need a new barrier
+        b = kmalloc (sizeof (struct thread_barrier_s));     // allocates a new barrier
+        if (b == NULL) return ENOMEM;                       // test if there is enough memory
+        b->magic = MAGIC_BARRIER;                           // tell it is a BARRIER
+        b->lock = 0;                                        // free the lock
+        b->expected = count;                                // init the expected threads
+        b->waiting = 0;                                     // init the counter of waiting threads
+        list_init (&b->wait);                               // init the waiting list
+        *barrier = b;                                       // at last, init. the return variable
+        return SUCCESS;                                     // it's fine
+    }
+
+    if (b && (b->magic != MAGIC_BARRIER)) return EINVAL;    // it is not an old barrier
+
+    spin_lock (&b->lock);                                   // get the ownership
+    if (b->waiting != 0) {                                  // if someone is waiting
+        spin_lock (&b->lock);                               // release the ownership
+        return EBUSY;                                       // return an error
+    }
+
+    b->expected = count;                                    // set the number of expected threads
+    spin_lock (&b->lock);                                   // release the ownership
+
+    return SUCCESS;                                         // it's fine
+}
+
+int thread_barrier_wait (thread_barrier_t * barrier)
+{
+    thread_barrier_t b = *barrier;                          // get the barrier pointer
+
+    if (b == NULL) return EINVAL;                           // b is not created
+    if (b && (b->magic != MAGIC_BARRIER)) return EINVAL;    // check that it is barrier (MAGIC)
+
+    spin_lock (&b->lock);                                   // get the ownership
+    b->waiting++;                                           // the current thread is the newcomer
+    if (b->waiting == b->expected) {                        // 
+        list_foreach (&b->wait, waiting_item) {             // 
+            list_unlink (waiting_item);                     // 
+            thread_t t = thread_item (waiting_item);        // get the pointer of a waiting thread
+            thread_notify (t);                              // 
+        }
+        b->waiting = 0;                                     // 
+        spin_unlock (&b->lock);                             // 
+    } else {
+        thread_addlast (&b->wait, ThreadCurrent);           // the current thread in the wait. list
+        spin_unlock (&b->lock);                             // 
+        thread_wait ();                                     // 
+
+    return SUCCESS;                                         // it's fine
+}