From d8c843f16a852bc5191b113eb5bb90b63a82f356 Mon Sep 17 00:00:00 2001
From: EDiasAlberto <proxamon1@gmail.com>
Date: Wed, 23 Oct 2024 19:37:27 +0100
Subject: [PATCH] add mlfqs condition checking in synchronisation primitives

---
 src/threads/synch.c  | 101 ++++++++++++++++++++++++-------------------
 src/threads/thread.c |   6 +++
 2 files changed, 62 insertions(+), 45 deletions(-)

diff --git a/src/threads/synch.c b/src/threads/synch.c
index 05b7d93..0ceb746 100644
--- a/src/threads/synch.c
+++ b/src/threads/synch.c
@@ -251,19 +251,27 @@ lock_acquire (struct lock *lock)
   ASSERT (!lock_held_by_current_thread (lock));
 
   struct thread *t = thread_current ();
-  enum intr_level old_level = intr_disable ();
 
-  if (lock->holder != NULL)
-    {
-      t->waiting_lock = lock;
-      donate_priority (lock->holder);
-    }
+  if(!thread_mlfqs)
+  {
+
+      enum intr_level old_level = intr_disable ();
+
+      if (lock->holder != NULL)
+      {
+        t->waiting_lock = lock;
+        donate_priority (lock->holder);
+      }
+
+      intr_set_level (old_level);
+  }
+
 
-  intr_set_level (old_level);
 
   sema_down (&lock->semaphore);
   lock->holder = thread_current ();
-  t->waiting_lock = NULL;
+  if (!thread_mlfqs)
+    t->waiting_lock = NULL;
 }
 
 /* Tries to acquires LOCK and returns true if successful or false
@@ -297,50 +305,53 @@ lock_release (struct lock *lock)
   ASSERT (lock != NULL);
   ASSERT (lock_held_by_current_thread (lock));
 
-  struct thread *current_thread = thread_current ();
-  struct thread *max_donor = NULL;
+  if (!thread_mlfqs)
+  {
+    struct thread *current_thread = thread_current ();
+    struct thread *max_donor = NULL;
 
-  struct list orphan_list;
-  list_init (&orphan_list);
+    struct list orphan_list;
+    list_init (&orphan_list);
 
-  enum intr_level old_level = intr_disable ();
-  /* Loop through current thread's donors, removing the ones waiting for the
-     lock being released and keeping track of them (within orphan_list).
-     Also identifies the highest priority donor thread among them. */
-  struct list_elem *tail = list_tail (&current_thread->donors_list);
-  struct list_elem *e = list_begin (&current_thread->donors_list);
-  while (e != tail)
-    {
-      struct thread *donor = list_entry (e, struct thread, donor_elem);
-      struct list_elem *next = list_next (e);
+    enum intr_level old_level = intr_disable ();
+    /* Loop through current thread's donors, removing the ones waiting for the
+       lock being released and keeping track of them (within orphan_list).
+       Also identifies the highest priority donor thread among them. */
+    struct list_elem *tail = list_tail (&current_thread->donors_list);
+    struct list_elem *e = list_begin (&current_thread->donors_list);
+    while (e != tail)
+      {
+        struct thread *donor = list_entry (e, struct thread, donor_elem);
+        struct list_elem *next = list_next (e);
 
-      /* Excludes donors that aren't waiting for the lock being released,
-         and tracks the rest. */
-      if (donor->waiting_lock == lock)
-        {
-          list_remove (e);
-          list_push_back (&orphan_list, e);
+        /* Excludes donors that aren't waiting for the lock being released,
+           and tracks the rest. */
+        if (donor->waiting_lock == lock)
+          {
+            list_remove (e);
+            list_push_back (&orphan_list, e);
 
-          /* Identify highest priority donor. */
-          if (max_donor == NULL || donor->priority > max_donor->priority)
-            max_donor = donor;
-        }
+            /* Identify highest priority donor. */
+            if (max_donor == NULL || donor->priority > max_donor->priority)
+              max_donor = donor;
+          }
 
-      e = next;
-    }
+        e = next;
+      }
 
-  /* If there exists a maximum donor thread waiting for this lock to be
-     released, transfer the remaining orphaned donors to its donor list. */
-  if (max_donor != NULL)
-    {
-      while (!list_empty (&orphan_list))
-        list_push_back (&max_donor->donors_list, list_pop_front (&orphan_list));
-    }
+    /* If there exists a maximum donor thread waiting for this lock to be
+       released, transfer the remaining orphaned donors to its donor list. */
+    if (max_donor != NULL)
+      {
+        while (!list_empty (&orphan_list))
+          list_push_back (&max_donor->donors_list, list_pop_front (&orphan_list));
+      }
 
-  intr_set_level (old_level);
-  /* Removal of donors to this thread may change its effective priority,
-     so recalculate. */
-  thread_recalculate_priority ();
+    intr_set_level (old_level);
+    /* Removal of donors to this thread may change its effective priority,
+       so recalculate. */
+    thread_recalculate_priority ();
+  }
 
   lock->holder = NULL;
   sema_up (&lock->semaphore);
diff --git a/src/threads/thread.c b/src/threads/thread.c
index c64bc87..1a7ab68 100644
--- a/src/threads/thread.c
+++ b/src/threads/thread.c
@@ -473,6 +473,12 @@ void
 thread_recalculate_priority (void)
 {
   struct thread *t = thread_current ();
+
+  if (thread_mlfqs)
+  {
+    t->priority = calculate_bsd_priority (t->recent_cpu, t->nice);
+    return;
+  }
   
   enum intr_level old_level = intr_disable ();
   t->priority = t->base_priority;