X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=schedule.cc;h=444e1a82982535339f241d5eb203fddf1d00a15a;hb=9d9c0f4e9909c2f58889e198a065479003f7bced;hp=88200a81cc650617044b4b0449477fbed1afb4e9;hpb=f4d77c40b4029cdc18f4aaa5a4e01dfbcfca5f7b;p=model-checker.git

diff --git a/schedule.cc b/schedule.cc
index 88200a8..444e1a8 100644
--- a/schedule.cc
+++ b/schedule.cc
@@ -1,33 +1,109 @@
 #include <string.h>
 #include <stdlib.h>
 
-#include "threads.h"
+#include "threads-model.h"
 #include "schedule.h"
 #include "common.h"
 #include "model.h"
+#include "nodestack.h"
 
 /** Constructor */
 Scheduler::Scheduler() :
-	is_enabled(NULL),
+	enabled(NULL),
 	enabled_len(0),
 	curr_thread_index(0),
 	current(NULL)
 {
 }
 
-void Scheduler::set_enabled(Thread *t, bool enabled_status) {
-	int threadid=id_to_int(t->get_id());
-	if (threadid>=enabled_len) {
-		bool *new_enabled = (bool *)snapshot_malloc(sizeof(bool) * (threadid + 1));
-		memset(&new_enabled[enabled_len], 0, (threadid+1-enabled_len)*sizeof(bool));
-		if (is_enabled != NULL) {
-			memcpy(new_enabled, is_enabled, enabled_len*sizeof(bool));
-			snapshot_free(is_enabled);
+void Scheduler::set_enabled(Thread *t, enabled_type_t enabled_status) {
+	int threadid = id_to_int(t->get_id());
+	if (threadid >= enabled_len) {
+		enabled_type_t *new_enabled = (enabled_type_t *)snapshot_malloc(sizeof(enabled_type_t) * (threadid + 1));
+		memset(&new_enabled[enabled_len], 0, (threadid + 1 - enabled_len) * sizeof(enabled_type_t));
+		if (enabled != NULL) {
+			memcpy(new_enabled, enabled, enabled_len * sizeof(enabled_type_t));
+			snapshot_free(enabled);
 		}
-		is_enabled=new_enabled;
-		enabled_len=threadid+1;
+		enabled = new_enabled;
+		enabled_len = threadid + 1;
 	}
-	is_enabled[threadid]=enabled_status;
+	enabled[threadid] = enabled_status;
+	if (enabled_status == THREAD_DISABLED)
+		model->check_promises_thread_disabled();
+}
+
+/**
+ * @brief Check if a Thread is currently enabled
+ *
+ * Check if a Thread is currently enabled. "Enabled" includes both
+ * THREAD_ENABLED and THREAD_SLEEP_SET.
+ * @param t The Thread to check
+ * @return True if the Thread is currently enabled
+ */
+bool Scheduler::is_enabled(const Thread *t) const
+{
+	return is_enabled(t->get_id());
+}
+
+/**
+ * @brief Check if a Thread is currently enabled
+ *
+ * Check if a Thread is currently enabled. "Enabled" includes both
+ * THREAD_ENABLED and THREAD_SLEEP_SET.
+ * @param tid The ID of the Thread to check
+ * @return True if the Thread is currently enabled
+ */
+bool Scheduler::is_enabled(thread_id_t tid) const
+{
+	int i = id_to_int(tid);
+	return (i >= enabled_len) ? false : (enabled[i] != THREAD_DISABLED);
+}
+
+/**
+ * @brief Check if a Thread is currently in the sleep set
+ * @param t The Thread to check
+ * @return True if the Thread is currently enabled
+ */
+bool Scheduler::is_sleep_set(const Thread *t) const
+{
+	return get_enabled(t) == THREAD_SLEEP_SET;
+}
+
+enabled_type_t Scheduler::get_enabled(const Thread *t) const
+{
+	int id = id_to_int(t->get_id());
+	ASSERT(id < enabled_len);
+	return enabled[id];
+}
+
+void Scheduler::update_sleep_set(Node *n) {
+	enabled_type_t *enabled_array = n->get_enabled_array();
+	for (int i = 0; i < enabled_len; i++) {
+		if (enabled_array[i] == THREAD_SLEEP_SET) {
+			enabled[i] = THREAD_SLEEP_SET;
+		}
+	}
+}
+
+/**
+ * Add a Thread to the sleep set.
+ * @param t The Thread to add
+ */
+void Scheduler::add_sleep(Thread *t)
+{
+	DEBUG("thread %d\n", id_to_int(t->get_id()));
+	set_enabled(t, THREAD_SLEEP_SET);
+}
+
+/**
+ * Remove a Thread from the sleep set.
+ * @param t The Thread to remove
+ */
+void Scheduler::remove_sleep(Thread *t)
+{
+	DEBUG("thread %d\n", id_to_int(t->get_id()));
+	set_enabled(t, THREAD_ENABLED);
 }
 
 /**
@@ -37,7 +113,8 @@ void Scheduler::set_enabled(Thread *t, bool enabled_status) {
 void Scheduler::add_thread(Thread *t)
 {
 	DEBUG("thread %d\n", id_to_int(t->get_id()));
-	set_enabled(t, true);
+	ASSERT(!t->is_model_thread());
+	set_enabled(t, THREAD_ENABLED);
 }
 
 /**
@@ -48,7 +125,7 @@ void Scheduler::remove_thread(Thread *t)
 {
 	if (current == t)
 		current = NULL;
-	set_enabled(t, false);
+	set_enabled(t, THREAD_DISABLED);
 }
 
 /**
@@ -58,7 +135,7 @@ void Scheduler::remove_thread(Thread *t)
  */
 void Scheduler::sleep(Thread *t)
 {
-	set_enabled(t, false);
+	set_enabled(t, THREAD_DISABLED);
 	t->set_state(THREAD_BLOCKED);
 }
 
@@ -68,7 +145,8 @@ void Scheduler::sleep(Thread *t)
  */
 void Scheduler::wake(Thread *t)
 {
-	set_enabled(t, true);
+	ASSERT(!t->is_model_thread());
+	set_enabled(t, THREAD_ENABLED);
 	t->set_state(THREAD_READY);
 }
 
@@ -82,12 +160,27 @@ void Scheduler::wake(Thread *t)
  */
 Thread * Scheduler::next_thread(Thread *t)
 {
-	if ( t == NULL ) {
+	if (t == NULL) {
 		int old_curr_thread = curr_thread_index;
-		while(true) {
-			curr_thread_index = (curr_thread_index+1) % enabled_len;
-			if (is_enabled[curr_thread_index]) {
-				t = model->get_thread(int_to_id(curr_thread_index));
+		bool have_enabled_thread_with_priority = false;
+		Node *n = model->get_curr_node();
+
+		for (int i = 0; i < enabled_len; i++) {
+			thread_id_t tid = int_to_id(i);
+			if (n->has_priority(tid)) {
+				DEBUG("Node (tid %d) has priority\n", i);
+				//Have a thread with priority
+				if (enabled[i] != THREAD_DISABLED)
+					have_enabled_thread_with_priority = true;
+			}
+		}
+
+		while (true) {
+			curr_thread_index = (curr_thread_index + 1) % enabled_len;
+			thread_id_t curr_tid = int_to_id(curr_thread_index);
+			if (enabled[curr_thread_index] == THREAD_ENABLED &&
+					(!have_enabled_thread_with_priority || n->has_priority(curr_tid))) {
+				t = model->get_thread(curr_tid);
 				break;
 			}
 			if (curr_thread_index == old_curr_thread) {
@@ -95,6 +188,9 @@ Thread * Scheduler::next_thread(Thread *t)
 				return NULL;
 			}
 		}
+	} else if (t->is_model_thread()) {
+		/* model-checker threads never run */
+		t = NULL;
 	} else {
 		curr_thread_index = id_to_int(t->get_id());
 	}
@@ -109,6 +205,7 @@ Thread * Scheduler::next_thread(Thread *t)
  */
 Thread * Scheduler::get_current_thread() const
 {
+	ASSERT(!current || !current->is_model_thread());
 	return current;
 }