Initial Pintos

1 files changed, 64 insertions, 0 deletions

diff --git a/src/tests/threads/mlfqs-block.c b/src/tests/threads/mlfqs-block.c
new file mode 100644
index 0000000..6d4992d
--- /dev/null
+++ b/src/tests/threads/mlfqs-block.c
@@ -0,0 +1,64 @@
+/* Checks that recent_cpu and priorities are updated for blocked
+   threads.
+
+   The main thread sleeps for 25 seconds, spins for 5 seconds,
+   then releases a lock.  The "block" thread spins for 20 seconds
+   then attempts to acquire the lock, which will block for 10
+   seconds (until the main thread releases it).  If recent_cpu
+   decays properly while the "block" thread sleeps, then the
+   block thread should be immediately scheduled when the main
+   thread releases the lock. */
+
+#include <stdio.h>
+#include "tests/threads/tests.h"
+#include "threads/init.h"
+#include "threads/malloc.h"
+#include "threads/synch.h"
+#include "threads/thread.h"
+#include "devices/timer.h"
+
+static void block_thread (void *lock_);
+
+void
+test_mlfqs_block (void) 
+{
+  int64_t start_time;
+  struct lock lock;
+  
+  ASSERT (thread_mlfqs);
+
+  msg ("Main thread acquiring lock.");
+  lock_init (&lock);
+  lock_acquire (&lock);
+  
+  msg ("Main thread creating block thread, sleeping 25 seconds...");
+  thread_create ("block", PRI_DEFAULT, block_thread, &lock);
+  timer_sleep (25 * TIMER_FREQ);
+
+  msg ("Main thread spinning for 5 seconds...");
+  start_time = timer_ticks ();
+  while (timer_elapsed (start_time) < 5 * TIMER_FREQ)
+    continue;
+
+  msg ("Main thread releasing lock.");
+  lock_release (&lock);
+
+  msg ("Block thread should have already acquired lock.");
+}
+
+static void
+block_thread (void *lock_) 
+{
+  struct lock *lock = lock_;
+  int64_t start_time;
+
+  msg ("Block thread spinning for 20 seconds...");
+  start_time = timer_ticks ();
+  while (timer_elapsed (start_time) < 20 * TIMER_FREQ)
+    continue;
+
+  msg ("Block thread acquiring lock...");
+  lock_acquire (lock);
+
+  msg ("...got it.");
+}