projects
/
cdsspec-compiler.git
/ commitdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
| commitdiff |
tree
raw
|
patch
|
inline
| side by side (from parent 1:
05f82cd
)
model: fixup style
author
Brian Norris
<banorris@uci.edu>
Thu, 20 Sep 2012 21:29:08 +0000
(14:29 -0700)
committer
Brian Norris
<banorris@uci.edu>
Thu, 20 Sep 2012 23:32:54 +0000
(16:32 -0700)
model.cc
patch
|
blob
|
history
diff --git
a/model.cc
b/model.cc
index 508f3b98284920860c9ce5eb4231b786b070b979..eb646294716a89d7d4d4fd5a0edc0d82e1c6b029 100644
(file)
--- a/
model.cc
+++ b/
model.cc
@@
-254,26
+254,26
@@
void ModelChecker::set_backtracking(ModelAction *act)
int low_tid, high_tid;
if (node->is_enabled(t)) {
int low_tid, high_tid;
if (node->is_enabled(t)) {
- low_tid
=
id_to_int(act->get_tid());
- high_tid
=
low_tid+1;
+ low_tid
=
id_to_int(act->get_tid());
+ high_tid
=
low_tid+1;
} else {
} else {
- low_tid
=
0;
- high_tid
=
get_num_threads();
+ low_tid
=
0;
+ high_tid
=
get_num_threads();
}
}
-
- for(int i
=low_tid;i<high_tid;
i++) {
- thread_id_t tid
=
int_to_id(i);
+
+ for(int i
= low_tid; i < high_tid;
i++) {
+ thread_id_t tid
=
int_to_id(i);
if (!node->is_enabled(tid))
continue;
/* Check if this has been explored already */
if (node->has_been_explored(tid))
continue;
if (!node->is_enabled(tid))
continue;
/* Check if this has been explored already */
if (node->has_been_explored(tid))
continue;
-
+
/* Cache the latest backtracking point */
if (!priv->next_backtrack || *prev > *priv->next_backtrack)
priv->next_backtrack = prev;
/* Cache the latest backtracking point */
if (!priv->next_backtrack || *prev > *priv->next_backtrack)
priv->next_backtrack = prev;
-
+
/* If this is a new backtracking point, mark the tree */
if (!node->set_backtrack(tid))
continue;
/* If this is a new backtracking point, mark the tree */
if (!node->set_backtrack(tid))
continue;
@@
-346,7
+346,7
@@
bool ModelChecker::process_read(ModelAction *curr, bool second_part_of_rmw)
/**
* Processes a lock, trylock, or unlock model action. @param curr is
/**
* Processes a lock, trylock, or unlock model action. @param curr is
- * the read model action to process.
+ * the read model action to process.
*
* The try lock operation checks whether the lock is taken. If not,
* it falls to the normal lock operation case. If so, it returns
*
* The try lock operation checks whether the lock is taken. If not,
* it falls to the normal lock operation case. If so, it returns
@@
-358,13
+358,12
@@
bool ModelChecker::process_read(ModelAction *curr, bool second_part_of_rmw)
* The unlock operation has to re-enable all of the threads that are
* waiting on the lock.
*/
* The unlock operation has to re-enable all of the threads that are
* waiting on the lock.
*/
-
void ModelChecker::process_mutex(ModelAction *curr) {
void ModelChecker::process_mutex(ModelAction *curr) {
- std::mutex *
mutex=(std::mutex *)
curr->get_location();
- struct std::mutex_state *
state=
mutex->get_state();
- switch(curr->get_type()) {
+ std::mutex *
mutex = (std::mutex *)
curr->get_location();
+ struct std::mutex_state *
state =
mutex->get_state();
+ switch
(curr->get_type()) {
case ATOMIC_TRYLOCK: {
case ATOMIC_TRYLOCK: {
- bool success
=
!state->islocked;
+ bool success
=
!state->islocked;
curr->set_try_lock(success);
if (!success) {
get_thread(curr)->set_return_value(0);
curr->set_try_lock(success);
if (!success) {
get_thread(curr)->set_return_value(0);
@@
-374,24
+373,24
@@
void ModelChecker::process_mutex(ModelAction *curr) {
}
//otherwise fall into the lock case
case ATOMIC_LOCK: {
}
//otherwise fall into the lock case
case ATOMIC_LOCK: {
- if (curr->get_cv()->getClock(state->alloc_tid)
<=
state->alloc_clock) {
+ if (curr->get_cv()->getClock(state->alloc_tid)
<=
state->alloc_clock) {
printf("Lock access before initialization\n");
set_assert();
}
printf("Lock access before initialization\n");
set_assert();
}
- state->islocked
=
true;
- ModelAction *unlock
=
get_last_unlock(curr);
+ state->islocked
=
true;
+ ModelAction *unlock
=
get_last_unlock(curr);
//synchronize with the previous unlock statement
//synchronize with the previous unlock statement
- if (
unlock != NULL
)
+ if (
unlock != NULL
)
curr->synchronize_with(unlock);
break;
}
case ATOMIC_UNLOCK: {
//unlock the lock
curr->synchronize_with(unlock);
break;
}
case ATOMIC_UNLOCK: {
//unlock the lock
- state->islocked
=
false;
+ state->islocked
=
false;
//wake up the other threads
//wake up the other threads
- action_list_t *
waiters = lock_waiters_map->get_safe_ptr(curr->get_location());
+ action_list_t *waiters = lock_waiters_map->get_safe_ptr(curr->get_location());
//activate all the waiting threads
//activate all the waiting threads
- for
(action_list_t::iterator rit = waiters->begin(); rit!=
waiters->end(); rit++) {
+ for
(action_list_t::iterator rit = waiters->begin(); rit !=
waiters->end(); rit++) {
scheduler->add_thread(get_thread((*rit)->get_tid()));
}
waiters->clear();
scheduler->add_thread(get_thread((*rit)->get_tid()));
}
waiters->clear();
@@
-402,7
+401,6
@@
void ModelChecker::process_mutex(ModelAction *curr) {
}
}
}
}
-
/**
* Process a write ModelAction
* @param curr The ModelAction to process
/**
* Process a write ModelAction
* @param curr The ModelAction to process
@@
-414,7
+412,7
@@
bool ModelChecker::process_write(ModelAction *curr)
bool updated_promises = resolve_promises(curr);
if (promises->size() == 0) {
bool updated_promises = resolve_promises(curr);
if (promises->size() == 0) {
- for (unsigned int i = 0; i
<
futurevalues->size(); i++) {
+ for (unsigned int i = 0; i
<
futurevalues->size(); i++) {
struct PendingFutureValue pfv = (*futurevalues)[i];
if (pfv.act->get_node()->add_future_value(pfv.value, pfv.expiration) &&
(!priv->next_backtrack || *pfv.act > *priv->next_backtrack))
struct PendingFutureValue pfv = (*futurevalues)[i];
if (pfv.act->get_node()->add_future_value(pfv.value, pfv.expiration) &&
(!priv->next_backtrack || *pfv.act > *priv->next_backtrack))
@@
-456,7
+454,7
@@
ModelAction * ModelChecker::initialize_curr_action(ModelAction *curr)
if (curr->is_rmwr())
newcurr->copy_typeandorder(curr);
if (curr->is_rmwr())
newcurr->copy_typeandorder(curr);
- ASSERT(curr->get_location()
==
newcurr->get_location());
+ ASSERT(curr->get_location()
==
newcurr->get_location());
newcurr->copy_from_new(curr);
/* Discard duplicate ModelAction; use action from NodeStack */
newcurr->copy_from_new(curr);
/* Discard duplicate ModelAction; use action from NodeStack */
@@
-488,7
+486,7
@@
ModelAction * ModelChecker::initialize_curr_action(ModelAction *curr)
bool ModelChecker::check_action_enabled(ModelAction *curr) {
if (curr->is_lock()) {
bool ModelChecker::check_action_enabled(ModelAction *curr) {
if (curr->is_lock()) {
- std::mutex * lock
=(std::mutex *)
curr->get_location();
+ std::mutex * lock
= (std::mutex *)
curr->get_location();
struct std::mutex_state * state = lock->get_state();
if (state->islocked) {
//Stick the action in the appropriate waiting queue
struct std::mutex_state * state = lock->get_state();
if (state->islocked) {
//Stick the action in the appropriate waiting queue
@@
-591,7
+589,7
@@
Thread * ModelChecker::check_current_action(ModelAction *curr)
if (act->is_write() && process_write(act))
updated = true;
if (act->is_write() && process_write(act))
updated = true;
- if (act->is_mutex_op())
+ if (act->is_mutex_op())
process_mutex(act);
if (updated)
process_mutex(act);
if (updated)
@@
-812,7
+810,7
@@
void ModelChecker::check_recency(ModelAction *curr) {
/**
* Updates the mo_graph with the constraints imposed from the current
/**
* Updates the mo_graph with the constraints imposed from the current
- * read.
+ * read.
*
* Basic idea is the following: Go through each other thread and find
* the lastest action that happened before our read. Two cases:
*
* Basic idea is the following: Go through each other thread and find
* the lastest action that happened before our read. Two cases:
@@
-871,7
+869,7
@@
bool ModelChecker::r_modification_order(ModelAction *curr, const ModelAction *rf
* promises. The basic problem is that actions that occur after the
* read curr could not property add items to the modification order
* for our read.
* promises. The basic problem is that actions that occur after the
* read curr could not property add items to the modification order
* for our read.
- *
+ *
* So for each thread, we find the earliest item that happens after
* the read curr. This is the item we have to fix up with additional
* constraints. If that action is write, we add a MO edge between
* So for each thread, we find the earliest item that happens after
* the read curr. This is the item we have to fix up with additional
* constraints. If that action is write, we add a MO edge between
@@
-1007,7
+1005,7
@@
bool ModelChecker::w_modification_order(ModelAction *curr)
*/
if (thin_air_constraint_may_allow(curr, act)) {
if (isfeasible() ||
*/
if (thin_air_constraint_may_allow(curr, act)) {
if (isfeasible() ||
- (curr->is_rmw() && act->is_rmw() && curr->get_reads_from()
==
act->get_reads_from() && isfeasibleotherthanRMW())) {
+ (curr->is_rmw() && act->is_rmw() && curr->get_reads_from()
==
act->get_reads_from() && isfeasibleotherthanRMW())) {
struct PendingFutureValue pfv = {curr->get_value(),curr->get_seq_number()+params.maxfuturedelay,act};
futurevalues->push_back(pfv);
}
struct PendingFutureValue pfv = {curr->get_value(),curr->get_seq_number()+params.maxfuturedelay,act};
futurevalues->push_back(pfv);
}
@@
-1031,7
+1029,7
@@
bool ModelChecker::thin_air_constraint_may_allow(const ModelAction * writer, con
return true;
for (const ModelAction *search = writer->get_reads_from(); search != NULL; search = search->get_reads_from()) {
return true;
for (const ModelAction *search = writer->get_reads_from(); search != NULL; search = search->get_reads_from()) {
- if (search
==
reader)
+ if (search
==
reader)
return false;
if (search->get_tid() == reader->get_tid() &&
search->happens_before(reader))
return false;
if (search->get_tid() == reader->get_tid() &&
search->happens_before(reader))
@@
-1459,7
+1457,7
@@
void ModelChecker::build_reads_from_past(ModelAction *curr)
continue;
/* Don't consider more than one seq_cst write if we are a seq_cst read. */
continue;
/* Don't consider more than one seq_cst write if we are a seq_cst read. */
- if (!curr->is_seqcst()
|| (!act->is_seqcst() && (last_seq_cst==NULL||
!act->happens_before(last_seq_cst))) || act == last_seq_cst) {
+ if (!curr->is_seqcst()
|| (!act->is_seqcst() && (last_seq_cst == NULL ||
!act->happens_before(last_seq_cst))) || act == last_seq_cst) {
DEBUG("Adding action to may_read_from:\n");
if (DBG_ENABLED()) {
act->print();
DEBUG("Adding action to may_read_from:\n");
if (DBG_ENABLED()) {
act->print();