X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=model.cc;h=856a33d2cdfa13d2db741797d4fc0f1681a9fd04;hb=09c3eb5539455e82dcb357fbce82bf5974c3a37c;hp=f5dd7cbda419209acf023c27d340218d146ebcff;hpb=18c6031154215ab85ad74fe70deb50ac8e3cbdf6;p=model-checker.git

diff --git a/model.cc b/model.cc
index f5dd7cb..856a33d 100644
--- a/model.cc
+++ b/model.cc
@@ -39,7 +39,6 @@ struct bug_message {
  */
 struct model_snapshot_members {
 	model_snapshot_members() :
-		current_action(NULL),
 		/* First thread created will have id INITIAL_THREAD_ID */
 		next_thread_id(INITIAL_THREAD_ID),
 		used_sequence_numbers(0),
@@ -59,7 +58,6 @@ struct model_snapshot_members {
 		bugs.clear();
 	}
 
-	ModelAction *current_action;
 	unsigned int next_thread_id;
 	modelclock_t used_sequence_numbers;
 	ModelAction *next_backtrack;
@@ -161,6 +159,14 @@ void ModelChecker::reset_to_initial_state()
 	/* Print all model-checker output before rollback */
 	fflush(model_out);
 
+	/**
+	 * FIXME: if we utilize partial rollback, we will need to free only
+	 * those pending actions which were NOT pending before the rollback
+	 * point
+	 */
+	for (unsigned int i = 0; i < get_num_threads(); i++)
+		delete get_thread(int_to_id(i))->get_pending();
+
 	snapshot_backtrack_before(0);
 }
 
@@ -218,7 +224,7 @@ Thread * ModelChecker::get_next_thread(ModelAction *curr)
 	if (curr != NULL) {
 		/* Do not split atomic actions. */
 		if (curr->is_rmwr())
-			return thread_current();
+			return get_thread(curr);
 		else if (curr->get_type() == THREAD_CREATE)
 			return curr->get_thread_operand();
 	}
@@ -295,11 +301,8 @@ void ModelChecker::execute_sleep_set()
 	for (unsigned int i = 0; i < get_num_threads(); i++) {
 		thread_id_t tid = int_to_id(i);
 		Thread *thr = get_thread(tid);
-		if (scheduler->is_sleep_set(thr) && thr->get_pending() == NULL) {
-			scheduler->next_thread(thr);
-			Thread::swap(&system_context, thr);
-			priv->current_action->set_sleep_flag();
-			thr->set_pending(priv->current_action);
+		if (scheduler->is_sleep_set(thr) && thr->get_pending()) {
+			thr->get_pending()->set_sleep_flag();
 		}
 	}
 }
@@ -324,11 +327,22 @@ void ModelChecker::set_bad_synchronization()
 	priv->bad_synchronization = true;
 }
 
+/**
+ * Check whether the current trace has triggered an assertion which should halt
+ * its execution.
+ *
+ * @return True, if the execution should be aborted; false otherwise
+ */
 bool ModelChecker::has_asserted() const
 {
 	return priv->asserted;
 }
 
+/**
+ * Trigger a trace assertion which should cause this execution to be halted.
+ * This can be due to a detected bug or due to an infeasibility that should
+ * halt ASAP.
+ */
 void ModelChecker::set_assert()
 {
 	priv->asserted = true;
@@ -1215,16 +1229,6 @@ bool ModelChecker::check_action_enabled(ModelAction *curr) {
 	return true;
 }
 
-/**
- * Stores the ModelAction for the current thread action.  Call this
- * immediately before switching from user- to system-context to pass
- * data between them.
- * @param act The ModelAction created by the user-thread action
- */
-void ModelChecker::set_current_action(ModelAction *act) {
-	priv->current_action = act;
-}
-
 /**
  * This is the heart of the model checker routine. It performs model-checking
  * actions corresponding to a given "current action." Among other processes, it
@@ -2678,7 +2682,8 @@ uint64_t ModelChecker::switch_to_master(ModelAction *act)
 {
 	DBG();
 	Thread *old = thread_current();
-	set_current_action(act);
+	ASSERT(!old->get_pending());
+	old->set_pending(act);
 	if (Thread::swap(old, &system_context) < 0) {
 		perror("swap threads");
 		exit(EXIT_FAILURE);
@@ -2694,9 +2699,6 @@ uint64_t ModelChecker::switch_to_master(ModelAction *act)
  */
 Thread * ModelChecker::take_step(ModelAction *curr)
 {
-	if (has_asserted())
-		return NULL;
-
 	Thread *curr_thrd = get_thread(curr);
 	ASSERT(curr_thrd->get_state() == THREAD_READY);
 
@@ -2738,7 +2740,7 @@ Thread * ModelChecker::take_step(ModelAction *curr)
 		ModelAction *fixup = new ModelAction(MODEL_FIXUP_RELSEQ,
 				std::memory_order_seq_cst, NULL, VALUE_NONE,
 				model_thread);
-		set_current_action(fixup);
+		model_thread->set_pending(fixup);
 		return model_thread;
 	}
 
@@ -2746,13 +2748,6 @@ Thread * ModelChecker::take_step(ModelAction *curr)
 	if (!next_thrd)
 		return NULL;
 
-	if (next_thrd->get_pending() != NULL) {
-		/* restart a pending action */
-		set_current_action(next_thrd->get_pending());
-		next_thrd->set_pending(NULL);
-		return next_thrd;
-	}
-
 	return next_thrd;
 }
 
@@ -2771,9 +2766,30 @@ void ModelChecker::run()
 		add_thread(t);
 
 		do {
-			scheduler->next_thread(t);
-			Thread::swap(&system_context, t);
-			t = take_step(priv->current_action);
+			/*
+			 * Stash next pending action(s) for thread(s). There
+			 * should only need to stash one thread's action--the
+			 * thread which just took a step--plus the first step
+			 * for any newly-created thread
+			 */
+			for (unsigned int i = 0; i < get_num_threads(); i++) {
+				thread_id_t tid = int_to_id(i);
+				Thread *thr = get_thread(tid);
+				if (!thr->is_model_thread() && !thr->is_complete() && !thr->get_pending()) {
+					scheduler->next_thread(thr);
+					Thread::swap(&system_context, thr);
+				}
+			}
+
+			/* Catch assertions from prior take_step or from
+			 * between-ModelAction bugs (e.g., data races) */
+			if (has_asserted())
+				break;
+
+			/* Consume the next action for a Thread */
+			ModelAction *curr = t->get_pending();
+			t->set_pending(NULL);
+			t = take_step(curr);
 		} while (t && !t->is_model_thread());
 		/** @TODO Re-write release sequence fixups here */
 	} while (next_execution());