From: weiyu <weiyuluo1232@gmail.com>
Date: Fri, 4 Sep 2020 20:35:39 +0000 (-0700)
Subject: small changes
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=251ac4b4bf3a9f2d3cfacc1e6618200ca1c431ac;p=c11tester.git
small changes
---
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<ModelAction *> *
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;
+ }
}
/**