From: Brian Norris <banorris@uci.edu>
Date: Wed, 12 Dec 2012 01:44:04 +0000 (-0800)
Subject: nodestack: add 'const'
X-Git-Tag: oopsla2013~438
X-Git-Url: http://plrg.eecs.uci.edu/git/?p=model-checker.git;a=commitdiff_plain;h=2cf946f3bf4f12d2a353fb0c4f4644a6b2f65e56

nodestack: add 'const'
---

diff --git a/nodestack.cc b/nodestack.cc
index 4da3cd6..f0d7924 100644
--- a/nodestack.cc
+++ b/nodestack.cc
@@ -120,7 +120,8 @@ void Node::set_promise(unsigned int i, bool is_rmw) {
  * @param i The promise index.
  * @return true if the promise should be satisfied by the given model action.
  */
-bool Node::get_promise(unsigned int i) {
+bool Node::get_promise(unsigned int i) const
+{
 	return (i < promises.size()) && ((promises[i] & PROMISE_MASK) == PROMISE_FULFILLED);
 }
 
@@ -160,7 +161,8 @@ bool Node::increment_promise() {
  * Returns whether the promise set is empty.
  * @return true if we have explored all promise combinations.
  */
-bool Node::promise_empty() {
+bool Node::promise_empty() const
+{
 	bool fulfilledrmw=false;
 	for (int i = promises.size()-1 ; i>=0; i--) {
 		if (promises[i]==PROMISE_UNFULFILLED)
@@ -178,7 +180,8 @@ void Node::set_misc_max(int i) {
 	misc_max=i;
 }
 
-int Node::get_misc() {
+int Node::get_misc() const
+{
 	return misc_index;
 }
 
@@ -186,7 +189,8 @@ bool Node::increment_misc() {
 	return (misc_index<misc_max)&&((++misc_index)<misc_max);
 }
 
-bool Node::misc_empty() {
+bool Node::misc_empty() const
+{
 	return (misc_index+1)>=misc_max;
 }
 
@@ -233,7 +237,8 @@ bool Node::add_future_value(uint64_t value, modelclock_t expiration) {
  * Checks whether the future_values set for this node is empty.
  * @return true if the future_values set is empty.
  */
-bool Node::future_value_empty() {
+bool Node::future_value_empty() const
+{
 	return ((future_index + 1) >= ((int)future_values.size()));
 }
 
@@ -244,7 +249,7 @@ bool Node::future_value_empty() {
  * @return true if this thread choice has been explored already, false
  * otherwise
  */
-bool Node::has_been_explored(thread_id_t tid)
+bool Node::has_been_explored(thread_id_t tid) const
 {
 	int id = id_to_int(tid);
 	return explored_children[id];
@@ -254,7 +259,7 @@ bool Node::has_been_explored(thread_id_t tid)
  * Checks if the backtracking set is empty.
  * @return true if the backtracking set is empty
  */
-bool Node::backtrack_empty()
+bool Node::backtrack_empty() const
 {
 	return (numBacktracks == 0);
 }
@@ -263,7 +268,8 @@ bool Node::backtrack_empty()
  * Checks whether the readsfrom set for this node is empty.
  * @return true if the readsfrom set is empty.
  */
-bool Node::read_from_empty() {
+bool Node::read_from_empty() const
+{
 	return ((read_from_index+1) >= may_read_from.size());
 }
 
@@ -318,27 +324,28 @@ thread_id_t Node::get_next_backtrack()
 	return int_to_id(i);
 }
 
-bool Node::is_enabled(Thread *t)
+bool Node::is_enabled(Thread *t) const
 {
 	int thread_id=id_to_int(t->get_id());
 	return thread_id < num_threads && (enabled_array[thread_id] != THREAD_DISABLED);
 }
 
-enabled_type_t Node::enabled_status(thread_id_t tid) {
-	int thread_id=id_to_int(tid);
+enabled_type_t Node::enabled_status(thread_id_t tid) const
+{
+	int thread_id = id_to_int(tid);
 	if (thread_id < num_threads)
 		return enabled_array[thread_id];
 	else
 		return THREAD_DISABLED;
 }
 
-bool Node::is_enabled(thread_id_t tid)
+bool Node::is_enabled(thread_id_t tid) const
 {
 	int thread_id=id_to_int(tid);
 	return thread_id < num_threads && (enabled_array[thread_id] != THREAD_DISABLED);
 }
 
-bool Node::has_priority(thread_id_t tid)
+bool Node::has_priority(thread_id_t tid) const
 {
 	return fairness[id_to_int(tid)].priority;
 }
@@ -357,18 +364,21 @@ void Node::add_read_from(const ModelAction *act)
  * where this->action is a 'read'.
  * @return The first element in future_values
  */
-uint64_t Node::get_future_value() {
+uint64_t Node::get_future_value() const
+{
 	ASSERT(future_index >= 0 && future_index<((int)future_values.size()));
 	return future_values[future_index].value;
 }
 
-modelclock_t Node::get_future_value_expiration() {
+modelclock_t Node::get_future_value_expiration() const
+{
 	ASSERT(future_index >= 0 && future_index<((int)future_values.size()));
 	return future_values[future_index].expiration;
 }
 
 
-int Node::get_read_from_size() {
+int Node::get_read_from_size() const
+{
 	return may_read_from.size();
 }
 
@@ -381,7 +391,8 @@ const ModelAction * Node::get_read_from_at(int i) {
  * where this->action is a 'read'.
  * @return The first element in may_read_from
  */
-const ModelAction * Node::get_read_from() {
+const ModelAction * Node::get_read_from() const
+{
 	if (read_from_index < may_read_from.size())
 		return may_read_from[read_from_index];
 	else
@@ -436,7 +447,7 @@ void Node::add_relseq_break(const ModelAction *write)
  * @return A write that may break the release sequence. If NULL, that means
  * the release sequence should not be broken.
  */
-const ModelAction * Node::get_relseq_break()
+const ModelAction * Node::get_relseq_break() const
 {
 	if (relseq_break_index < (int)relseq_break_writes.size())
 		return relseq_break_writes[relseq_break_index];
@@ -464,7 +475,8 @@ bool Node::increment_relseq_break()
  * @return True if all writes that may break the release sequence have been
  * explored
  */
-bool Node::relseq_break_empty() {
+bool Node::relseq_break_empty() const
+{
 	return ((relseq_break_index + 1) >= ((int)relseq_break_writes.size()));
 }
 
@@ -493,7 +505,7 @@ NodeStack::~NodeStack()
 		delete node_list[i];
 }
 
-void NodeStack::print()
+void NodeStack::print() const
 {
 	model_print("............................................\n");
 	model_print("NodeStack printing node_list:\n");
@@ -548,14 +560,14 @@ void NodeStack::pop_restofstack(int numAhead)
 	node_list.resize(it);
 }
 
-Node * NodeStack::get_head()
+Node * NodeStack::get_head() const
 {
 	if (node_list.empty())
 		return NULL;
 	return node_list[iter];
 }
 
-Node * NodeStack::get_next()
+Node * NodeStack::get_next() const
 {
 	if (node_list.empty()) {
 		DEBUG("Empty\n");
diff --git a/nodestack.h b/nodestack.h
index 986b9c9..90d84bd 100644
--- a/nodestack.h
+++ b/nodestack.h
@@ -59,53 +59,53 @@ public:
 	Node(ModelAction *act = NULL, Node *par = NULL, int nthreads = 2, Node *prevfairness = NULL);
 	~Node();
 	/* return true = thread choice has already been explored */
-	bool has_been_explored(thread_id_t tid);
+	bool has_been_explored(thread_id_t tid) const;
 	/* return true = backtrack set is empty */
-	bool backtrack_empty();
+	bool backtrack_empty() const;
 
 	void explore_child(ModelAction *act, enabled_type_t * is_enabled);
 	/* return false = thread was already in backtrack */
 	bool set_backtrack(thread_id_t id);
 	thread_id_t get_next_backtrack();
-	bool is_enabled(Thread *t);
-	bool is_enabled(thread_id_t tid);
-	enabled_type_t enabled_status(thread_id_t tid);
+	bool is_enabled(Thread *t) const;
+	bool is_enabled(thread_id_t tid) const;
+	enabled_type_t enabled_status(thread_id_t tid) const;
 
-	ModelAction * get_action() { return action; }
-	bool has_priority(thread_id_t tid);
-	int get_num_threads() {return num_threads;}
+	ModelAction * get_action() const { return action; }
+	bool has_priority(thread_id_t tid) const;
+	int get_num_threads() const { return num_threads; }
 	/** @return the parent Node to this Node; that is, the action that
 	 * occurred previously in the stack. */
 	Node * get_parent() const { return parent; }
 
 	bool add_future_value(uint64_t value, modelclock_t expiration);
-	uint64_t get_future_value();
-	modelclock_t get_future_value_expiration();
+	uint64_t get_future_value() const;
+	modelclock_t get_future_value_expiration() const;
 	bool increment_future_value();
-	bool future_value_empty();
+	bool future_value_empty() const;
 
 	void add_read_from(const ModelAction *act);
-	const ModelAction * get_read_from();
+	const ModelAction * get_read_from() const;
 	bool increment_read_from();
-	bool read_from_empty();
-	int get_read_from_size();
+	bool read_from_empty() const;
+	int get_read_from_size() const;
 	const ModelAction * get_read_from_at(int i);
 
 	void set_promise(unsigned int i, bool is_rmw);
-	bool get_promise(unsigned int i);
+	bool get_promise(unsigned int i) const;
 	bool increment_promise();
-	bool promise_empty();
+	bool promise_empty() const;
 	enabled_type_t *get_enabled_array() {return enabled_array;}
 
 	void set_misc_max(int i);
-	int get_misc();
+	int get_misc() const;
 	bool increment_misc();
-	bool misc_empty();
+	bool misc_empty() const;
 
 	void add_relseq_break(const ModelAction *write);
-	const ModelAction * get_relseq_break();
+	const ModelAction * get_relseq_break() const;
 	bool increment_relseq_break();
-	bool relseq_break_empty();
+	bool relseq_break_empty() const;
 
 	void print();
 	void print_may_read_from();
@@ -155,13 +155,13 @@ public:
 	NodeStack();
 	~NodeStack();
 	ModelAction * explore_action(ModelAction *act, enabled_type_t * is_enabled);
-	Node * get_head();
-	Node * get_next();
+	Node * get_head() const;
+	Node * get_next() const;
 	void reset_execution();
 	void pop_restofstack(int numAhead);
 	int get_total_nodes() { return total_nodes; }
 
-	void print();
+	void print() const;
 
 	MEMALLOC
 private: