location(loc),
value(value),
reads_from(NULL),
- reads_from_promise(NULL),
last_fence_release(NULL),
node(NULL),
seq_number(ACTION_INITIAL_CLOCK),
- cv(NULL),
- sleep_flag(false)
+ cv(NULL)
{
/* References to NULL atomic variables can end up here */
- ASSERT(loc || type == ATOMIC_FENCE || type == MODEL_FIXUP_RELSEQ);
+ ASSERT(loc || type == ATOMIC_FENCE);
Thread *t = thread ? thread : thread_current();
this->tid = t->get_id();
bool ModelAction::is_thread_join() const
{
- return type == THREAD_JOIN;
-}
-
-bool ModelAction::is_relseq_fixup() const
-{
- return type == MODEL_FIXUP_RELSEQ;
+ return type == THREAD_JOIN || type == PTHREAD_JOIN;
}
bool ModelAction::is_mutex_op() const
Thread * ModelAction::get_thread_operand() const
{
if (type == THREAD_CREATE) {
- /* THREAD_CREATE stores its (Thread *) in a thrd_t::priv */
- thrd_t *thrd = (thrd_t *)get_location();
- return thrd->priv;
- } else if (type == THREAD_JOIN)
+ /* thread_operand is set in execution.cc */
+ return thread_operand;
+ } else if (type == PTHREAD_CREATE) {
+ return thread_operand;
+ } else if (type == THREAD_JOIN) {
/* THREAD_JOIN uses (Thread *) for location */
return (Thread *)get_location();
- else
+ } else if (type == PTHREAD_JOIN) {
+ // return NULL;
+ // thread_operand is stored in execution::pthread_map;
+ return (Thread *)get_location();
+ } else
return NULL;
}
ASSERT(is_read());
if (reads_from)
return reads_from->get_write_value();
- else if (reads_from_promise)
- return reads_from_promise->get_value();
return VALUE_NONE; /* Only for new actions with no reads-from */
}
void ModelAction::set_read_from(const ModelAction *act)
{
ASSERT(act);
+
reads_from = act;
- reads_from_promise = NULL;
- if (act->is_uninitialized())
- model->assert_bug("May read from uninitialized atomic:\n"
+
+ if (act->is_uninitialized()) { // WL
+ uint64_t val = *((uint64_t *) location);
+ ModelAction * act_initialized = (ModelAction *)act;
+ act_initialized->set_value(val);
+ reads_from = (const ModelAction *)act_initialized;
+
+// disabled by WL, because LLVM IR is unable to detect atomic init
+/* model->assert_bug("May read from uninitialized atomic:\n"
" action %d, thread %d, location %p (%s, %s)",
seq_number, id_to_int(tid), location,
get_type_str(), get_mo_str());
-}
-
-/**
- * Set this action's read-from promise
- * @param promise The promise to read from
- */
-void ModelAction::set_read_from_promise(Promise *promise)
-{
- ASSERT(is_read());
- reads_from_promise = promise;
- reads_from = NULL;
+*/
+ }
}
/**
const char * ModelAction::get_type_str() const
{
switch (this->type) {
- case MODEL_FIXUP_RELSEQ: return "relseq fixup";
case THREAD_CREATE: return "thread create";
case THREAD_START: return "thread start";
case THREAD_YIELD: return "thread yield";
case THREAD_JOIN: return "thread join";
case THREAD_FINISH: return "thread finish";
+
+ case PTHREAD_CREATE: return "pthread create";
+ case PTHREAD_JOIN: return "pthread join";
+
case ATOMIC_UNINIT: return "uninitialized";
case ATOMIC_READ: return "atomic read";
case ATOMIC_WRITE: return "atomic write";
{
const char *type_str = get_type_str(), *mo_str = get_mo_str();
- model_print("%-4d %-2d %-13s %7s %14p %-#18" PRIx64,
+ model_print("%-4d %-2d %-14s %7s %14p %-#18" PRIx64,
seq_number, id_to_int(tid), type_str, mo_str, location, get_return_value());
if (is_read()) {
if (reads_from)
model_print(" %-3d", reads_from->get_seq_number());
- else if (reads_from_promise) {
- int idx = reads_from_promise->get_index();
- if (idx >= 0)
- model_print(" P%-2d", idx);
- else
- model_print(" P? ");
- } else
+ else
model_print(" ? ");
}
if (cv) {
if (is_read()) {
if (reads_from)
hash ^= reads_from->get_seq_number();
- else if (reads_from_promise)
- hash ^= reads_from_promise->get_index();
hash ^= get_reads_from_value();
}
return hash;
}
-/**
- * @brief Checks the NodeStack to see if a ModelAction is in our may-read-from set
- * @param write The ModelAction to check for
- * @return True if the ModelAction is found; false otherwise
- */
-bool ModelAction::may_read_from(const ModelAction *write) const
-{
- for (int i = 0; i < node->get_read_from_past_size(); i++)
- if (node->get_read_from_past(i) == write)
- return true;
- return false;
-}
-
-/**
- * @brief Checks the NodeStack to see if a Promise is in our may-read-from set
- * @param promise The Promise to check for
- * @return True if the Promise is found; false otherwise
- */
-bool ModelAction::may_read_from(const Promise *promise) const
-{
- for (int i = 0; i < node->get_read_from_promise_size(); i++)
- if (node->get_read_from_promise(i) == promise)
- return true;
- return false;
-}
-
/**
* Only valid for LOCK, TRY_LOCK, UNLOCK, and WAIT operations.
* @return The mutex operated on by this action, if any; otherwise NULL
*/
-std::mutex * ModelAction::get_mutex() const
+cdsc::mutex * ModelAction::get_mutex() const
{
if (is_trylock() || is_lock() || is_unlock())
- return (std::mutex *)get_location();
+ return (cdsc::mutex *)get_location();
else if (is_wait())
- return (std::mutex *)get_value();
+ return (cdsc::mutex *)get_value();
else
return NULL;
}
projects / c11tester.git / blobdiff