From 251ac4b4bf3a9f2d3cfacc1e6618200ca1c431ac Mon Sep 17 00:00:00 2001 From: weiyu Date: Fri, 4 Sep 2020 13:35:39 -0700 Subject: [PATCH] small changes --- cyclegraph.cc | 3 +-- datarace.cc | 2 +- execution.cc | 44 ++++++++++++++++++++------------------------ model.cc | 7 ++----- model.h | 1 - threads.cc | 16 +++++++++------- 6 files changed, 33 insertions(+), 40 deletions(-) diff --git a/cyclegraph.cc b/cyclegraph.cc index 6c7e945e..1d9533f4 100644 --- a/cyclegraph.cc +++ b/cyclegraph.cc @@ -70,8 +70,7 @@ void CycleGraph::addNodeEdge(CycleNode *fromnode, CycleNode *tonode, bool forcee * If the fromnode has a rmwnode, we should * follow its RMW chain to add an edge at the end. */ - while (fromnode->getRMW()) { - CycleNode *nextnode = fromnode->getRMW(); + while (CycleNode * nextnode = fromnode->getRMW()) { if (nextnode == tonode) break; fromnode = nextnode; diff --git a/datarace.cc b/datarace.cc index 06de5375..9c403668 100644 --- a/datarace.cc +++ b/datarace.cc @@ -55,7 +55,7 @@ void * table_calloc(size_t size) /** This function looks up the entry in the shadow table corresponding to a * given address.*/ -static uint64_t * lookupAddressEntry(const void *address) +static inline uint64_t * lookupAddressEntry(const void *address) { struct ShadowTable *currtable = root; #if BIT48 diff --git a/execution.cc b/execution.cc index dcaada34..8f459d17 100644 --- a/execution.cc +++ b/execution.cc @@ -250,21 +250,7 @@ void ModelExecution::restore_last_seq_num() bool ModelExecution::should_wake_up(const ModelAction *curr, const Thread *thread) const { const ModelAction *asleep = thread->get_pending(); - /* Don't allow partial RMW to wake anyone up */ - if (curr->is_rmwr()) - return false; - /* Synchronizing actions may have been backtracked */ - if (asleep->could_synchronize_with(curr)) - return true; - /* All acquire/release fences and fence-acquire/store-release */ - if (asleep->is_fence() && asleep->is_acquire() && curr->is_release()) - return true; - /* Fence-release + store can awake load-acquire on the same location */ - if (asleep->is_read() && asleep->is_acquire() && curr->same_var(asleep) && curr->is_write()) { - ModelAction *fence_release = get_last_fence_release(curr->get_tid()); - if (fence_release && *(get_last_action(thread->get_id())) < *fence_release) - return true; - } + /* The sleep is literally sleeping */ if (asleep->is_sleep()) { if (fuzzer->shouldWake(asleep)) @@ -278,8 +264,8 @@ void ModelExecution::wake_up_sleeping_actions(ModelAction *curr) { 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(tid)) { + Thread *thr = get_thread(tid); if (should_wake_up(curr, thr)) { /* Remove this thread from sleep set */ scheduler->remove_sleep(thr); @@ -420,10 +406,10 @@ bool ModelExecution::process_read(ModelAction *curr, SnapVector * mo_graph->addEdge((*priorset)[i], rf); } read_from(curr, rf); - get_thread(curr)->set_return_value(curr->get_return_value()); + get_thread(curr)->set_return_value(rf->get_write_value()); delete priorset; //Update acquire fence clock vector - ClockVector * hbcv = get_hb_from_write(curr->get_reads_from()); + ClockVector * hbcv = get_hb_from_write(rf); if (hbcv != NULL) get_thread(curr)->get_acq_fence_cv()->merge(hbcv); return canprune && (curr->get_type() == ATOMIC_READ); @@ -487,10 +473,10 @@ bool ModelExecution::process_mutex(ModelAction *curr) case ATOMIC_WAIT: { //TODO: DOESN'T REALLY IMPLEMENT SPURIOUS WAKEUPS CORRECTLY if (fuzzer->shouldWait(curr)) { + Thread *curr_thrd = get_thread(curr); /* wake up the other threads */ for (unsigned int i = 0;i < get_num_threads();i++) { Thread *t = get_thread(int_to_id(i)); - Thread *curr_thrd = get_thread(curr); if (t->waiting_on() == curr_thrd && t->get_pending()->is_lock()) scheduler->wake(t); } @@ -509,7 +495,7 @@ bool ModelExecution::process_mutex(ModelAction *curr) } waiters->push_back(curr); - scheduler->sleep(get_thread(curr)); + scheduler->sleep(curr_thrd); } break; @@ -527,9 +513,9 @@ bool ModelExecution::process_mutex(ModelAction *curr) // TODO: lock count for recursive mutexes /* wake up the other threads */ + Thread *curr_thrd = get_thread(curr); for (unsigned int i = 0;i < get_num_threads();i++) { Thread *t = get_thread(int_to_id(i)); - Thread *curr_thrd = get_thread(curr); if (t->waiting_on() == curr_thrd && t->get_pending()->is_lock()) scheduler->wake(t); } @@ -770,7 +756,8 @@ bool ModelExecution::synchronize(const ModelAction *first, ModelAction *second) * @return a bool that indicates whether the action is enabled. */ bool ModelExecution::check_action_enabled(ModelAction *curr) { - if (curr->is_lock()) { + switch (curr->get_type()) { + case ATOMIC_LOCK: { cdsc::mutex *lock = curr->get_mutex(); struct cdsc::mutex_state *state = lock->get_state(); if (state->locked) { @@ -782,14 +769,23 @@ bool ModelExecution::check_action_enabled(ModelAction *curr) { return false; } - } else if (curr->is_thread_join()) { + break; + } + case THREAD_JOIN: + case PTHREAD_JOIN: { Thread *blocking = curr->get_thread_operand(); if (!blocking->is_complete()) { return false; } - } else if (curr->is_sleep()) { + break; + } + case THREAD_SLEEP: { if (!fuzzer->shouldSleep(curr)) return false; + break; + } + default: + return true; } return true; diff --git a/model.cc b/model.cc index 4cf5cc57..8f974762 100644 --- a/model.cc +++ b/model.cc @@ -342,7 +342,6 @@ void ModelChecker::startRunExecution(Thread *old) { execution->collectActions(); } - thread_chosen = false; curr_thread_num = 1; Thread *thr = getNextThread(old); if (thr != nullptr) { @@ -386,20 +385,18 @@ Thread* ModelChecker::getNextThread(Thread *old) } /* Allow pending relaxed/release stores or thread actions to perform first */ - else if (!thread_chosen) { + else if (!chosen_thread) { if (act->is_write()) { std::memory_order order = act->get_mo(); if (order == std::memory_order_relaxed || \ order == std::memory_order_release) { chosen_thread = thr; - thread_chosen = true; } } else if (act->get_type() == THREAD_CREATE || \ act->get_type() == PTHREAD_CREATE || \ act->get_type() == THREAD_START || \ act->get_type() == THREAD_FINISH) { chosen_thread = thr; - thread_chosen = true; } } } @@ -487,7 +484,7 @@ bool ModelChecker::handleChosenThread(Thread *old) if (!chosen_thread) { chosen_thread = get_next_thread(); } - if (!chosen_thread || chosen_thread->is_model_thread()) { + if (!chosen_thread) { finishRunExecution(old); return false; } diff --git a/model.h b/model.h index 03dafd11..fd65c050 100644 --- a/model.h +++ b/model.h @@ -73,7 +73,6 @@ private: unsigned int curr_thread_num; Thread * chosen_thread; - bool thread_chosen; bool break_execution; void startRunExecution(Thread *old); diff --git a/threads.cc b/threads.cc index f83433bc..e22ffa32 100644 --- a/threads.cc +++ b/threads.cc @@ -508,13 +508,15 @@ Thread * Thread::waiting_on() const if (!pending) return NULL; - if (pending->get_type() == THREAD_JOIN) - return pending->get_thread_operand(); - else if (pending->get_type() == PTHREAD_JOIN) - return pending->get_thread_operand(); - else if (pending->is_lock()) - return (Thread *)pending->get_mutex()->get_state()->locked; - return NULL; + switch (pending->get_type()) { + case THREAD_JOIN: + case PTHREAD_JOIN: + return pending->get_thread_operand(); + case ATOMIC_LOCK: + return (Thread *)pending->get_mutex()->get_state()->locked; + default: + return NULL; + } } /** -- 2.34.1