#include <stdio.h>
#include <algorithm>
-#include <mutex>
#include <new>
#include <stdarg.h>
#include "common.h"
#include "clockvector.h"
#include "cyclegraph.h"
-#include "promise.h"
#include "datarace.h"
#include "threads-model.h"
#include "bugmessage.h"
-#include <pthread.h>
-
#define INITIAL_THREAD_ID 0
/**
scheduler(scheduler),
action_trace(),
thread_map(2), /* We'll always need at least 2 threads */
+ pthread_map(0),
+ pthread_counter(0),
obj_map(),
condvar_waiters_map(),
obj_thrd_map(),
+ mutex_map(),
promises(),
futurevalues(),
pending_rel_seqs(),
*/
bool ModelExecution::process_mutex(ModelAction *curr)
{
- std::mutex *mutex = curr->get_mutex();
- struct std::mutex_state *state = NULL;
+ cdsc::mutex *mutex = curr->get_mutex();
+ struct cdsc::mutex_state *state = NULL;
if (mutex)
state = mutex->get_state();
action_list_t *waiters = get_safe_ptr_action(&condvar_waiters_map, curr->get_location());
int wakeupthread = curr->get_node()->get_misc();
action_list_t::iterator it = waiters->begin();
+
+ // WL
+ if (it == waiters->end())
+ break;
+
advance(it, wakeupthread);
scheduler->wake(get_thread(*it));
waiters->erase(it);
break;
}
case PTHREAD_CREATE: {
- thrd_t *thrd = (thrd_t *)curr->get_location();
+ (*(pthread_t *)curr->get_location()) = pthread_counter++;
+
struct pthread_params *params = (struct pthread_params *)curr->get_value();
- Thread *th = new Thread(get_next_id(), thrd, params->func, params->arg, get_thread(curr));
+ Thread *th = new Thread(get_next_id(), NULL, params->func, params->arg, get_thread(curr));
curr->set_thread_operand(th);
add_thread(th);
th->set_creation(curr);
+
+ if ( pthread_map.size() < pthread_counter )
+ pthread_map.resize( pthread_counter );
+ pthread_map[ pthread_counter-1 ] = th;
+
/* Promises can be satisfied by children */
for (unsigned int i = 0; i < promises.size(); i++) {
Promise *promise = promises[i];
if (promise->thread_is_available(curr->get_tid()))
promise->add_thread(th->get_id());
}
+
break;
}
case THREAD_JOIN: {
*/
bool ModelExecution::check_action_enabled(ModelAction *curr) {
if (curr->is_lock()) {
- std::mutex *lock = curr->get_mutex();
- struct std::mutex_state *state = lock->get_state();
+ cdsc::mutex *lock = curr->get_mutex();
+ struct cdsc::mutex_state *state = lock->get_state();
if (state->locked)
return false;
} else if (curr->is_thread_join()) {
ModelAction * ModelExecution::get_last_unlock(ModelAction *curr) const
{
void *location = curr->get_location();
+
action_list_t *list = obj_map.get(location);
/* Find: max({i in dom(S) | isUnlock(t_i) && samevar(t_i, t)}) */
action_list_t::reverse_iterator rit;
action_list_t::const_iterator it;
model_print("------------------------------------------------------------------------------------\n");
- model_print("# t Action type MO Location Value Rf CV\n");
+ model_print("# t Action type MO Location Value Rf CV\n");
model_print("------------------------------------------------------------------------------------\n");
unsigned int hash = 0;
return get_thread(act->get_tid());
}
+/**
+ * @brief Get a Thread reference by its pthread ID
+ * @param index The pthread's ID
+ * @return A Thread reference
+ */
+Thread * ModelExecution::get_pthread(pthread_t pid) {
+ if (pid < pthread_counter + 1) return pthread_map[pid];
+ else return NULL;
+}
+
/**
* @brief Get a Promise's "promise number"
*