#include <algorithm>
#include <new>
#include <stdarg.h>
+#include <errno.h>
#include "model.h"
#include "execution.h"
#include "fuzzer.h"
#include "newfuzzer.h"
-#define INITIAL_THREAD_ID 0
-
#ifdef COLLECT_STAT
static unsigned int atomic_load_count = 0;
static unsigned int atomic_store_count = 0;
/** @brief Destructor */
ModelExecution::~ModelExecution()
{
- for (unsigned int i = 0;i < get_num_threads();i++)
+ for (unsigned int i = INITIAL_THREAD_ID;i < get_num_threads();i++)
delete get_thread(int_to_id(i));
delete mo_graph;
* @param thread The thread that we might wake up
* @return True, if we should wake up the sleeping thread; false otherwise
*/
-bool ModelExecution::should_wake_up(const Thread *thread) const
+bool ModelExecution::should_wake_up(const ModelAction * asleep) const
{
- const ModelAction *asleep = thread->get_pending();
-
/* The sleep is literally sleeping */
switch (asleep->get_type()) {
case THREAD_SLEEP:
void ModelExecution::wake_up_sleeping_actions()
{
- for (unsigned int i = 0;i < get_num_threads();i++) {
+ for (unsigned int i = MAIN_THREAD_ID;i < get_num_threads();i++) {
thread_id_t tid = int_to_id(i);
if (scheduler->is_sleep_set(tid)) {
Thread *thr = get_thread(tid);
- if (should_wake_up(thr)) {
+ ModelAction * pending = thr->get_pending();
+ if (should_wake_up(pending)) {
/* Remove this thread from sleep set */
scheduler->remove_sleep(thr);
- ModelAction * pending = thr->get_pending();
+
if (pending->is_sleep()) {
thr->set_wakeup_state(true);
} else if (pending->is_wait()) {
thr->set_wakeup_state(true);
+ /* Remove this thread from list of waiters */
simple_action_list_t *waiters = get_safe_ptr_action(&condvar_waiters_map, pending->get_location());
for (sllnode<ModelAction *> * rit = waiters->begin();rit != NULL;rit=rit->getNext()) {
if (rit->getVal()->get_tid() == tid) {
break;
}
}
+
+ /* Set ETIMEDOUT error */
+ if (pending->is_timedwait())
+ thr->set_return_value(ETIMEDOUT);
}
}
}
bool ModelExecution::is_deadlocked() const
{
bool blocking_threads = false;
- for (unsigned int i = 0;i < get_num_threads();i++) {
+ for (unsigned int i = MAIN_THREAD_ID;i < get_num_threads();i++) {
thread_id_t tid = int_to_id(i);
if (is_enabled(tid))
return false;
*/
bool ModelExecution::is_complete_execution() const
{
- for (unsigned int i = 0;i < get_num_threads();i++)
+ for (unsigned int i = MAIN_THREAD_ID;i < get_num_threads();i++)
if (is_enabled(int_to_id(i)))
return false;
return true;
case ATOMIC_WAIT: {
Thread *curr_thrd = get_thread(curr);
/* wake up the other threads */
- for (unsigned int i = 0;i < get_num_threads();i++) {
+ for (unsigned int i = MAIN_THREAD_ID;i < get_num_threads();i++) {
Thread *t = get_thread(int_to_id(i));
if (t->waiting_on() == curr_thrd && t->get_pending()->is_lock())
scheduler->wake(t);
waiters->push_back(curr);
curr_thrd->set_pending(curr); // Forbid this thread to stash a new action
- if (fuzzer->waitShouldFail(curr))
- scheduler->add_sleep(curr_thrd); // Place this thread into THREAD_SLEEP_SET
+ if (fuzzer->waitShouldFail(curr)) // If wait should fail spuriously,
+ scheduler->add_sleep(curr_thrd); // place this thread into THREAD_SLEEP_SET
else
scheduler->sleep(curr_thrd);
break;
}
- case ATOMIC_TIMEDWAIT:
- case ATOMIC_UNLOCK: {
- //TODO: FIX WAIT SITUATION...WAITS CAN SPURIOUSLY
- //FAIL...TIMED WAITS SHOULD PROBABLY JUST BE THE SAME
- //AS NORMAL WAITS...THINK ABOUT PROBABILITIES
- //THOUGH....AS IN TIMED WAIT MUST FAIL TO GUARANTEE
- //PROGRESS...NORMAL WAIT MAY FAIL...SO NEED NORMAL
- //WAIT TO WORK CORRECTLY IN THE CASE IT SPURIOUSLY
- //FAILS AND IN THE CASE IT DOESN'T... TIMED WAITS
- //MUST EVENMTUALLY RELEASE...
+ case ATOMIC_TIMEDWAIT: {
+ Thread *curr_thrd = get_thread(curr);
+ if (!fuzzer->randomizeWaitTime(curr)) {
+ curr_thrd->set_return_value(ETIMEDOUT);
+ return false;
+ }
+ /* wake up the other threads */
+ for (unsigned int i = MAIN_THREAD_ID;i < get_num_threads();i++) {
+ Thread *t = get_thread(int_to_id(i));
+ if (t->waiting_on() == curr_thrd && t->get_pending()->is_lock())
+ scheduler->wake(t);
+ }
+
+ /* unlock the lock - after checking who was waiting on it */
+ state->locked = NULL;
+
+ /* disable this thread */
+ simple_action_list_t * waiters = get_safe_ptr_action(&condvar_waiters_map, curr->get_location());
+ waiters->push_back(curr);
+ curr_thrd->set_pending(curr); // Forbid this thread to stash a new action
+ scheduler->add_sleep(curr_thrd);
+ break;
+ }
+ case ATOMIC_UNLOCK: {
// 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++) {
+ for (unsigned int i = MAIN_THREAD_ID;i < get_num_threads();i++) {
Thread *t = get_thread(int_to_id(i));
if (t->waiting_on() == curr_thrd && t->get_pending()->is_lock())
scheduler->wake(t);
}
/* Wake up any joining threads */
- for (unsigned int i = 0;i < get_num_threads();i++) {
+ for (unsigned int i = MAIN_THREAD_ID;i < get_num_threads();i++) {
Thread *waiting = get_thread(int_to_id(i));
if (waiting->waiting_on() == th &&
waiting->get_pending()->is_thread_join())