X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=action.h;h=f792de215994097605ec084b83c9d671f60f6ceb;hp=fead25e649a3dfcb575e9d5aae353b4363e92d8c;hb=527eb9241e1b39b6ad4125a71b951d445d4e251e;hpb=a7df00de36ef87549b654cfbc5c6b098cbba7a5b diff --git a/action.h b/action.h index fead25e6..f792de21 100644 --- a/action.h +++ b/action.h @@ -11,14 +11,11 @@ #include "mymemory.h" #include "memoryorder.h" #include "modeltypes.h" -#include "pthread.h" - -/* Forward declarations */ -class ClockVector; -class Thread; +#include "mypthread.h" +#include "classlist.h" namespace cdsc { - class mutex; +class mutex; } using std::memory_order; @@ -37,6 +34,7 @@ using std::memory_order_seq_cst; * iteself does not indicate no value. */ #define VALUE_NONE 0xdeadbeef +#define WRITE_REFERENCED ((void *)0x1) /** * @brief The "location" at which a fence occurs @@ -50,70 +48,81 @@ using std::memory_order_seq_cst; /** @brief Represents an action type, identifying one of several types of * ModelAction */ typedef enum action_type { - THREAD_CREATE, /**< A thread creation action */ - THREAD_START, /**< First action in each thread */ - THREAD_YIELD, /**< A thread yield action */ - THREAD_JOIN, /**< A thread join action */ - THREAD_FINISH, /**< A thread completion action */ - PTHREAD_CREATE, /**< A pthread creation action */ - PTHREAD_JOIN, /**< A pthread join action */ - - ATOMIC_UNINIT, /**< Represents an uninitialized atomic */ - ATOMIC_READ, /**< An atomic read action */ - ATOMIC_WRITE, /**< An atomic write action */ - ATOMIC_RMWR, /**< The read part of an atomic RMW action */ - ATOMIC_RMW, /**< The write part of an atomic RMW action */ - ATOMIC_RMWC, /**< Convert an atomic RMW action into a READ */ - ATOMIC_INIT, /**< Initialization of an atomic object (e.g., - * atomic_init()) */ - ATOMIC_FENCE, /**< A fence action */ - ATOMIC_LOCK, /**< A lock action */ - ATOMIC_TRYLOCK, /**< A trylock action */ - ATOMIC_UNLOCK, /**< An unlock action */ - ATOMIC_NOTIFY_ONE, /**< A notify_one action */ - ATOMIC_NOTIFY_ALL, /**< A notify all action */ - ATOMIC_WAIT, /**< A wait action */ - ATOMIC_ANNOTATION, /**< An annotation action to pass information - to a trace analysis */ - NOOP + THREAD_CREATE, // < A thread creation action + THREAD_START, // < First action in each thread + THREAD_YIELD, // < A thread yield action + THREAD_JOIN, // < A thread join action + THREAD_FINISH, // < A thread completion action + THREADONLY_FINISH, // < A thread completion action + THREAD_SLEEP, // < A sleep operation + + PTHREAD_CREATE, // < A pthread creation action + PTHREAD_JOIN, // < A pthread join action + + NONATOMIC_WRITE, // < Represents a non-atomic store + ATOMIC_INIT, // < Initialization of an atomic object (e.g., atomic_init()) + ATOMIC_WRITE, // < An atomic write action + ATOMIC_RMW, // < The write part of an atomic RMW action + ATOMIC_READ, // < An atomic read action + ATOMIC_RMWR, // < The read part of an atomic RMW action + ATOMIC_RMWRCAS, // < The read part of an atomic RMW action + ATOMIC_RMWC, // < Convert an atomic RMW action into a READ + + ATOMIC_FENCE, // < A fence action + ATOMIC_LOCK, // < A lock action + ATOMIC_TRYLOCK, // < A trylock action + ATOMIC_UNLOCK, // < An unlock action + + ATOMIC_NOTIFY_ONE, // < A notify_one action + ATOMIC_NOTIFY_ALL, // < A notify all action + ATOMIC_WAIT, // < A wait action + ATOMIC_TIMEDWAIT, // < A timed wait action + ATOMIC_ANNOTATION, // < An annotation action to pass information to a trace analysis + READY_FREE, // < Write is ready to be freed + ATOMIC_NOP // < Placeholder } action_type_t; -/* Forward declaration */ -class Node; -class ClockVector; /** * @brief Represents a single atomic action * * A ModelAction is always allocated as non-snapshotting, because it is used in - * multiple executions during backtracking. Except for fake uninitialized - * (ATOMIC_UNINIT) ModelActions, each action is assigned a unique sequence + * multiple executions during backtracking. Except for non-atomic write + * ModelActions, each action is assigned a unique sequence * number. */ class ModelAction { public: ModelAction(action_type_t type, memory_order order, void *loc, uint64_t value = VALUE_NONE, Thread *thread = NULL); + ModelAction(action_type_t type, memory_order order, void *loc, uint64_t value, int size); + ModelAction(action_type_t type, const char * position, memory_order order, void *loc, uint64_t value, int size); + ModelAction(action_type_t type, memory_order order, uint64_t value, uint64_t time); + ModelAction(action_type_t type, const char * position, memory_order order, void *loc, uint64_t value = VALUE_NONE, Thread *thread = NULL); ~ModelAction(); void print() const; thread_id_t get_tid() const { return tid; } action_type get_type() const { return type; } + void set_type(action_type _type) { type = _type; } + action_type get_original_type() const { return original_type; } + void set_original_type(action_type _type) { original_type = _type; } + void set_free() { type = READY_FREE; } memory_order get_mo() const { return order; } memory_order get_original_mo() const { return original_order; } void set_mo(memory_order order) { this->order = order; } void * get_location() const { return location; } + const char * get_position() const { return position; } modelclock_t get_seq_number() const { return seq_number; } uint64_t get_value() const { return value; } uint64_t get_reads_from_value() const; uint64_t get_write_value() const; uint64_t get_return_value() const; - const ModelAction * get_reads_from() const { return reads_from; } + ModelAction * get_reads_from() const { return reads_from; } + uint64_t get_time() const {return time;} cdsc::mutex * get_mutex() const; + bool get_swap_flag() const { return swap_flag; } - Node * get_node() const; - void set_node(Node *n) { node = n; } - - void set_read_from(const ModelAction *act); + void set_read_from(ModelAction *act); /** Store the most recent fence-release from the same thread * @param fence The fence-release that occured prior to this */ @@ -123,25 +132,29 @@ public: void copy_from_new(ModelAction *newaction); void set_seq_number(modelclock_t num); + void reset_seq_number(); void set_try_lock(bool obtainedlock); bool is_thread_start() const; bool is_thread_join() const; bool is_mutex_op() const; bool is_lock() const; + bool is_sleep() const; bool is_trylock() const; bool is_unlock() const; bool is_wait() const; + bool is_create() const; bool is_notify() const; bool is_notify_one() const; bool is_success_lock() const; bool is_failed_trylock() const; bool is_atomic_var() const; - bool is_uninitialized() const; bool is_read() const; bool is_write() const; + bool is_free() const; bool is_yield() const; bool could_be_write() const; bool is_rmwr() const; + bool is_rmwrcas() const; bool is_rmwc() const; bool is_rmw() const; bool is_fence() const; @@ -155,11 +168,12 @@ public: bool same_thread(const ModelAction *act) const; bool is_conflicting_lock(const ModelAction *act) const; bool could_synchronize_with(const ModelAction *act) const; - + int getSize() const; Thread * get_thread_operand() const; - void create_cv(const ModelAction *parent = NULL); ClockVector * get_cv() const { return cv; } + ClockVector * get_rfcv() const { return rf_cv; } + void set_rfcv(ClockVector * rfcv) { rf_cv = rfcv; } bool synchronize_with(const ModelAction *act); bool has_synchronized_with(const ModelAction *act) const; @@ -174,75 +188,97 @@ public: void process_rmw(ModelAction * act); void copy_typeandorder(ModelAction * act); - unsigned int hash() const; - bool equals(const ModelAction *x) const { return this == x; } - - MEMALLOC - void set_value(uint64_t val) { value = val; } + void use_original_type(); + /* to accomodate pthread create and join */ Thread * thread_operand; - void set_thread_operand(Thread *th) { thread_operand = th; } + void set_thread_operand(Thread *th) { thread_operand = th; } + void setTraceRef(sllnode *ref) { trace_ref = ref; } + void setThrdMapRef(sllnode *ref) { thrdmap_ref = ref; } + void setActionRef(sllnode *ref) { action_ref = ref; } + sllnode * getTraceRef() { return trace_ref; } + sllnode * getThrdMapRef() { return thrdmap_ref; } + sllnode * getActionRef() { return action_ref; } + + void incr_func_ref_count() { func_ref_count++; } + void decr_func_ref_count() { if (func_ref_count > 0) func_ref_count--; } + uint32_t get_func_ref_count() { return func_ref_count; } + + SNAPSHOTALLOC private: - const char * get_type_str() const; const char * get_mo_str() const; - /** @brief Type of action (read, write, RMW, fence, thread create, etc.) */ - action_type type; - - /** @brief The memory order for this operation. */ - memory_order order; - - /** @brief The original memory order parameter for this operation. */ - memory_order original_order; - /** @brief A pointer to the memory location for this action. */ void *location; - /** @brief The thread id that performed this action. */ - thread_id_t tid; + /** @brief A pointer to the source line for this atomic action. */ + const char * position; - /** @brief The value written (for write or RMW; undefined for read) */ - uint64_t value; - - /** - * @brief The store that this action reads from - * - * Only valid for reads - */ - const ModelAction *reads_from; + union { + /** + * @brief The store that this action reads from + * + * Only valid for reads + */ + ModelAction *reads_from; + int size; + uint64_t time; //used for sleep + }; /** @brief The last fence release from the same thread */ const ModelAction *last_fence_release; /** - * @brief A back reference to a Node in NodeStack + * @brief The clock vector for this operation * - * Only set if this ModelAction is saved on the NodeStack. (A - * ModelAction can be thrown away before it ever enters the NodeStack.) + * Technically, this is only needed for potentially synchronizing + * (e.g., non-relaxed) operations, but it is very handy to have these + * vectors for all operations. */ - Node *node; + ClockVector *cv; + ClockVector *rf_cv; + sllnode * trace_ref; + sllnode * thrdmap_ref; + sllnode * action_ref; + + /** @brief Number of read actions that are reading from this store */ + uint32_t func_ref_count; + + /** @brief The value written (for write or RMW; undefined for read) */ + uint64_t value; + + /** @brief Type of action (read, write, RMW, fence, thread create, etc.) */ + action_type type; + + /** @brief The original type of action (read, write, RMW) before it was + * set as READY_FREE or weaken from a RMW to a write */ + action_type original_type; + + /** @brief Indicate whether the action type and the original action type + * has been swapped. */ + bool swap_flag; + + /** @brief The memory order for this operation. */ + memory_order order; + + /** @brief The original memory order parameter for this operation. */ + memory_order original_order; + + /** @brief The thread id that performed this action. */ + thread_id_t tid; /** * @brief The sequence number of this action * - * Except for ATOMIC_UNINIT actions, this number should be unique and + * Except for non atomic write actions, this number should be unique and * should represent the action's position in the execution order. */ modelclock_t seq_number; - - /** - * @brief The clock vector for this operation - * - * Technically, this is only needed for potentially synchronizing - * (e.g., non-relaxed) operations, but it is very handy to have these - * vectors for all operations. - */ - ClockVector *cv; }; -#endif /* __ACTION_H__ */ +#endif /* __ACTION_H__ */