From fab8621e4bf6acafc04dbaf786e2de6263d892f6 Mon Sep 17 00:00:00 2001 From: Brian Norris Date: Fri, 7 Dec 2012 18:40:59 -0800 Subject: [PATCH] spacing --- action.cc | 16 +++++------ action.h | 4 +-- model.cc | 82 +++++++++++++++++++++++++++++-------------------------- model.h | 12 ++++---- 4 files changed, 59 insertions(+), 55 deletions(-) diff --git a/action.cc b/action.cc index a313b70..e88fcee 100644 --- a/action.cc +++ b/action.cc @@ -264,7 +264,7 @@ void ModelAction::process_rmw(ModelAction * act) { */ bool ModelAction::could_synchronize_with(const ModelAction *act) const { - //Same thread can't be reordered + // Same thread can't be reordered if (same_thread(act)) return false; @@ -283,15 +283,15 @@ bool ModelAction::could_synchronize_with(const ModelAction *act) const (act->could_be_write() || act->is_fence())) return true; - //lock just released...we can grab lock + // lock just released...we can grab lock if ((is_lock() ||is_trylock()) && (act->is_unlock()||act->is_wait())) return true; - //lock just acquired...we can fail to grab lock + // lock just acquired...we can fail to grab lock if (is_trylock() && act->is_success_lock()) return true; - //other thread stalling on lock...we can release lock + // other thread stalling on lock...we can release lock if (is_unlock() && (act->is_trylock()||act->is_lock())) return true; @@ -310,19 +310,19 @@ bool ModelAction::could_synchronize_with(const ModelAction *act) const bool ModelAction::is_conflicting_lock(const ModelAction *act) const { - //Must be different threads to reorder + // Must be different threads to reorder if (same_thread(act)) return false; - //Try to reorder a lock past a successful lock + // Try to reorder a lock past a successful lock if (act->is_success_lock()) return true; - //Try to push a successful trylock past an unlock + // Try to push a successful trylock past an unlock if (act->is_unlock() && is_trylock() && value == VALUE_TRYSUCCESS) return true; - //Try to push a successful trylock past a wait + // Try to push a successful trylock past a wait if (act->is_wait() && is_trylock() && value == VALUE_TRYSUCCESS) return true; diff --git a/action.h b/action.h index a246123..5ec1098 100644 --- a/action.h +++ b/action.h @@ -24,12 +24,10 @@ using std::memory_order_acq_rel; using std::memory_order_seq_cst; /** Note that this value can be legitimately used by a program, and - hence by iteself does not indicate no value. */ - + * hence by iteself does not indicate no value. */ #define VALUE_NONE 0xdeadbeef /** A special value to represent a successful trylock */ - #define VALUE_TRYSUCCESS 1 /** A special value to represent a failed trylock */ diff --git a/model.cc b/model.cc index c38c79c..e4b6431 100644 --- a/model.cc +++ b/model.cc @@ -129,19 +129,21 @@ ModelChecker::~ModelChecker() delete priv; } -static action_list_t * get_safe_ptr_action(HashTable * hash, void * ptr) { - action_list_t * tmp=hash->get(ptr); - if (tmp==NULL) { - tmp=new action_list_t(); +static action_list_t * get_safe_ptr_action(HashTable * hash, void * ptr) +{ + action_list_t *tmp = hash->get(ptr); + if (tmp == NULL) { + tmp = new action_list_t(); hash->put(ptr, tmp); } return tmp; } -static std::vector * get_safe_ptr_vect_action(HashTable *, uintptr_t, 4> * hash, void * ptr) { - std::vector * tmp=hash->get(ptr); - if (tmp==NULL) { - tmp=new std::vector(); +static std::vector * get_safe_ptr_vect_action(HashTable *, uintptr_t, 4> * hash, void * ptr) +{ + std::vector *tmp = hash->get(ptr); + if (tmp == NULL) { + tmp = new std::vector(); hash->put(ptr, tmp); } return tmp; @@ -208,7 +210,7 @@ Thread * ModelChecker::get_next_thread(ModelAction *curr) { thread_id_t tid; - if (curr!=NULL) { + if (curr != NULL) { /* Do not split atomic actions. */ if (curr->is_rmwr()) return thread_current(); @@ -283,10 +285,11 @@ Thread * ModelChecker::get_next_thread(ModelAction *curr) * the corresponding thread object's pending action. */ -void ModelChecker::execute_sleep_set() { - for(unsigned int i=0;iis_sleep_set(thr) && thr->get_pending() == NULL) { thr->set_state(THREAD_RUNNING); scheduler->next_thread(thr); @@ -602,11 +605,11 @@ ModelAction * ModelChecker::get_last_conflict(ModelAction *act) void ModelChecker::set_backtracking(ModelAction *act) { Thread *t = get_thread(act); - ModelAction * prev = get_last_conflict(act); + ModelAction *prev = get_last_conflict(act); if (prev == NULL) return; - Node * node = prev->get_node()->get_parent(); + Node *node = prev->get_node()->get_parent(); int low_tid, high_tid; if (node->is_enabled(t)) { @@ -1136,8 +1139,8 @@ bool ModelChecker::read_from(ModelAction *act, const ModelAction *rf) */ bool ModelChecker::check_action_enabled(ModelAction *curr) { if (curr->is_lock()) { - std::mutex * lock = (std::mutex *)curr->get_location(); - struct std::mutex_state * state = lock->get_state(); + 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 get_safe_ptr_action(lock_waiters_map, curr->get_location())->push_back(curr); @@ -1271,7 +1274,8 @@ Thread * ModelChecker::check_current_action(ModelAction *curr) return get_next_thread(curr); } -void ModelChecker::check_curr_backtracking(ModelAction * curr) { +void ModelChecker::check_curr_backtracking(ModelAction *curr) +{ Node *currnode = curr->get_node(); Node *parnode = currnode->get_parent(); @@ -1383,9 +1387,9 @@ ModelAction * ModelChecker::process_rmw(ModelAction *act) { * * If so, we decide that the execution is no longer feasible. */ -void ModelChecker::check_recency(ModelAction *curr, const ModelAction *rf) { +void ModelChecker::check_recency(ModelAction *curr, const ModelAction *rf) +{ if (params.maxreads != 0) { - if (curr->get_node()->get_read_from_size() <= 1) return; //Must make sure that execution is currently feasible... We could @@ -1411,7 +1415,7 @@ void ModelChecker::check_recency(ModelAction *curr, const ModelAction *rf) { //See if we have enough reads from the same value int count = 0; for (; count < params.maxreads; rit++,count++) { - if (rit==list->rend()) + if (rit == list->rend()) return; ModelAction *act = *rit; if (!act->is_read()) @@ -1422,12 +1426,12 @@ void ModelChecker::check_recency(ModelAction *curr, const ModelAction *rf) { if (act->get_node()->get_read_from_size() <= 1) return; } - for (int i = 0; iget_node()->get_read_from_size(); i++) { - //Get write - const ModelAction * write = curr->get_node()->get_read_from_at(i); + for (int i = 0; i < curr->get_node()->get_read_from_size(); i++) { + /* Get write */ + const ModelAction *write = curr->get_node()->get_read_from_at(i); - //Need a different write - if (write==rf) + /* Need a different write */ + if (write == rf) continue; /* Test to see whether this is a feasible write to read from*/ @@ -1444,7 +1448,7 @@ void ModelChecker::check_recency(ModelAction *curr, const ModelAction *rf) { //new we need to see if this write works for everyone for (int loop = count; loop>0; loop--,rit++) { - ModelAction *act=*rit; + ModelAction *act = *rit; bool foundvalue = false; for (int j = 0; jget_node()->get_read_from_size(); j++) { if (act->get_node()->get_read_from_at(j)==write) { @@ -1762,7 +1766,8 @@ bool ModelChecker::w_modification_order(ModelAction *curr) /** Arbitrary reads from the future are not allowed. Section 29.3 * part 9 places some constraints. This method checks one result of constraint * constraint. Others require compiler support. */ -bool ModelChecker::thin_air_constraint_may_allow(const ModelAction * writer, const ModelAction *reader) { +bool ModelChecker::thin_air_constraint_may_allow(const ModelAction *writer, const ModelAction *reader) +{ if (!writer->is_rmw()) return true; @@ -2377,14 +2382,14 @@ void ModelChecker::check_promises_thread_disabled() { * cannot perform a future write that will resolve the promise due to * modificatin order constraints. * - * @parem tid The thread that either read from the model action + * @param tid The thread that either read from the model action * write, or actually did the model action write. * - * @parem write The ModelAction representing the relevant write. + * @param write The ModelAction representing the relevant write. */ - -void ModelChecker::mo_check_promises(thread_id_t tid, const ModelAction *write) { - void * location = write->get_location(); +void ModelChecker::mo_check_promises(thread_id_t tid, const ModelAction *write) +{ + void *location = write->get_location(); for (unsigned int i = 0; i < promises->size(); i++) { Promise *promise = (*promises)[i]; const ModelAction *act = promise->get_action(); @@ -2509,20 +2514,21 @@ void ModelChecker::build_reads_from_past(ModelAction *curr) } } -bool ModelChecker::sleep_can_read_from(ModelAction * curr, const ModelAction *write) { +bool ModelChecker::sleep_can_read_from(ModelAction *curr, const ModelAction *write) +{ while (true) { /* UNINIT actions don't have a Node, and they never sleep */ if (write->is_uninitialized()) return true; - Node *prevnode=write->get_node()->get_parent(); + Node *prevnode = write->get_node()->get_parent(); - bool thread_sleep=prevnode->enabled_status(curr->get_tid())==THREAD_SLEEP_SET; - if (write->is_release()&&thread_sleep) + bool thread_sleep = prevnode->enabled_status(curr->get_tid()) == THREAD_SLEEP_SET; + if (write->is_release() && thread_sleep) return true; if (!write->is_rmw()) { return false; } - if (write->get_reads_from()==NULL) + if (write->get_reads_from() == NULL) return true; write=write->get_reads_from(); } diff --git a/model.h b/model.h index af6802a..4f13987 100644 --- a/model.h +++ b/model.h @@ -121,7 +121,7 @@ public: ModelAction * get_parent_action(thread_id_t tid) const; void check_promises_thread_disabled(); void mo_check_promises(thread_id_t tid, const ModelAction *write); - void check_promises(thread_id_t tid, ClockVector *old_cv, ClockVector * merge_cv); + void check_promises(thread_id_t tid, ClockVector *old_cv, ClockVector *merge_cv); bool isfeasibleprefix() const; bool assert_bug(const char *msg); @@ -135,15 +135,15 @@ private: /** The scheduler to use: tracks the running/ready Threads */ Scheduler *scheduler; - bool sleep_can_read_from(ModelAction * curr, const ModelAction *write); - bool thin_air_constraint_may_allow(const ModelAction * writer, const ModelAction *reader); - bool mo_may_allow(const ModelAction * writer, const ModelAction *reader); + bool sleep_can_read_from(ModelAction *curr, const ModelAction *write); + bool thin_air_constraint_may_allow(const ModelAction *writer, const ModelAction *reader); + bool mo_may_allow(const ModelAction *writer, const ModelAction *reader); bool has_asserted() const; void set_assert(); void set_bad_synchronization(); bool promises_expired() const; void execute_sleep_set(); - void wake_up_sleeping_actions(ModelAction * curr); + void wake_up_sleeping_actions(ModelAction *curr); modelclock_t get_next_seq_num(); bool next_execution(); @@ -171,7 +171,7 @@ private: void compute_promises(ModelAction *curr); void compute_relseq_breakwrites(ModelAction *curr); - void check_curr_backtracking(ModelAction * curr); + void check_curr_backtracking(ModelAction *curr); void add_action_to_lists(ModelAction *act); ModelAction * get_last_action(thread_id_t tid) const; ModelAction * get_last_fence_release(thread_id_t tid) const; -- 2.34.1