From da2b87ad057c4da28fee58c642e00bfc671f4ed6 Mon Sep 17 00:00:00 2001
From: Nemo D'ACREMONT <ndacremont@enseirb-matmeca.fr>
Date: Fri, 18 Apr 2025 19:52:55 +0200
Subject: [PATCH] fix: udpate comments of dac-sum

---
 tst/52-dac-sum.c     |  3 +-
 tst/65-mutex-chall.c | 89 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 90 insertions(+), 2 deletions(-)
 create mode 100644 tst/65-mutex-chall.c

diff --git a/tst/52-dac-sum.c b/tst/52-dac-sum.c
index 55c9e92..7aeaff9 100644
--- a/tst/52-dac-sum.c
+++ b/tst/52-dac-sum.c
@@ -5,7 +5,7 @@
 #include <sys/time.h>
 #include "thread.h"
 
-/* fibonacci.
+/* Somme divide and conquer
  *
  * la durée doit être proportionnel à la valeur du résultat.
  * valgrind doit être content.
@@ -29,7 +29,6 @@ static void* s_dac_sum(void* _value)
   int err;
   void *res = NULL, *res2 = NULL;
   struct dac_in_t* in = (struct dac_in_t*) _value;
-  printf("%p %d %d\n", in->arr, in->st, in->end);
 
   /* on passe un peu la main aux autres pour eviter de faire uniquement la partie gauche de l'arbre */
   thread_yield();
diff --git a/tst/65-mutex-chall.c b/tst/65-mutex-chall.c
new file mode 100644
index 0000000..d478369
--- /dev/null
+++ b/tst/65-mutex-chall.c
@@ -0,0 +1,89 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <sys/time.h>
+#include "thread.h"
+
+/* test pour verifier que prendre un mutex ne casse pas le join.
+ * si ca deadlock, c'est qu'il y a un problème.
+ * la durée du test n'est pas clairement utilisable pour juger de la qualité de l'implementation.
+ *
+ * valgrind doit etre content.
+ * Le programme doit finir.
+ *
+ * support nécessaire:
+ * - thread_create()
+ * - thread_join() dans un mutex
+ * - thread_mutex_init()
+ * - thread_mutex_destroy()
+ * - thread_mutex_lock()
+ * - thread_mutex_unlock()
+ */
+
+int pret = 0;
+thread_mutex_t lock;
+
+static void * thfunc(void *dummy __attribute__((unused)))
+{
+    unsigned i;
+    int err;
+
+    /* on prend le verrou puis on se marque pret */
+    err = thread_mutex_lock(&lock);
+    assert(!err);
+
+    pret = 1;
+    printf("  fils: verrouillé\n");
+    for(i=0; i<5; i++) {
+      printf("  fils: yield() pour verifier que le père n'arrive pas aller plus loin\n");
+      thread_yield();
+    }
+    printf("  fils: va déverrouiller\n");
+    pret = 2;
+    err = thread_mutex_unlock(&lock);
+    assert(!err);
+
+    for(i=0; i<5; i++) {
+      printf("  fils: yield() avant de finir\n");
+      thread_yield();
+    }
+    thread_exit((void*) 0xdeadbeef);
+}
+
+int main(void)
+{
+  thread_t th;
+  int err;
+  void *ret;
+
+  /* on cree le mutex et le thread */
+  if (thread_mutex_init(&lock) != 0) {
+      fprintf(stderr, "thread_mutex_init failed\n");
+      return EXIT_FAILURE;
+  }
+  err = thread_create(&th, thfunc, NULL);
+  assert(!err);
+
+  printf("pere: attend que le fils ait démarré\n");
+  while (pret == 0)
+    thread_yield();
+
+  printf("pere: fils pret, on verrouille\n");
+  err = thread_mutex_lock(&lock);
+  assert(!err);
+  printf("pere: verrouillé, on joine\n");
+  err = thread_join(th, &ret);
+  assert(!err);
+  assert(ret == (void*)0xdeadbeef);
+  assert(pret == 2);
+  printf("pere: join réussi\n");
+
+  err = thread_mutex_unlock(&lock);
+  assert(!err);
+  thread_mutex_destroy(&lock);
+
+  printf("terminé OK\n");
+  return EXIT_SUCCESS;
+}