unify style for returning pointers

When returning a pointer from a function, always put a space between the type,
the '*', and the function name. E.g.:

  type * func(args);

diff --git a/common.h b/common.h
index f2627200f9851b61409027e70cb904e7876cbb3b..1570a32969a72902cd3ba5569f2413f6b709a062 100644 (file)
--- a/common.h
+++ b/common.h
@@ -13,7 +13,7 @@
 #define DBG()
 #endif
 
 #define DBG()
 #endif
 

-void *myMalloc(size_t size);
+void * myMalloc(size_t size);

 void myFree(void *ptr);
 
 #endif /* __COMMON_H__ */
 void myFree(void *ptr);
 
 #endif /* __COMMON_H__ */

diff --git a/malloc.c b/malloc.c
index 82fdd04c2f6319478547cac7c9a22c0f88dc512d..f20c4e7a46692b9a7d7848431b993979c7033a88 100644 (file)
--- a/malloc.c
+++ b/malloc.c
@@ -22,7 +22,7 @@ static void __my_alloc_init(void)
        }
 }
 
        }
 }
 

-void *myMalloc(size_t size)
+void * myMalloc(size_t size)

 {
        if (real_malloc == NULL)
                __my_alloc_init();
 {
        if (real_malloc == NULL)
                __my_alloc_init();

diff --git a/model.cc b/model.cc
index 914ae3daccefa90aa0c24be3cff1d712c1e5b5a7..f3844f0ad1e1d70d0060934eef73ca7032a048d8 100644 (file)
--- a/model.cc
+++ b/model.cc
@@ -40,7 +40,7 @@ void ModelChecker::add_system_thread(Thread *t)
        this->system_thread = t;
 }
 
        this->system_thread = t;
 }
 

-Thread *ModelChecker::schedule_next_thread()
+Thread * ModelChecker::schedule_next_thread()

 {
        Thread *t;
        if (nextThread == THREAD_ID_T_NONE)
 {
        Thread *t;
        if (nextThread == THREAD_ID_T_NONE)


@@ -96,10 +96,15 @@ thread_id_t ModelChecker::advance_backtracking_state()
 
 bool ModelChecker::next_execution()
 {
 
 bool ModelChecker::next_execution()
 {

-       return false;
+       num_executions++;
+       if ((exploring = model->get_next_backtrack()) == NULL)
+               return false;
+       model->reset_to_initial_state();
+       nextThread = get_next_replay_thread();
+       return true;

 }
 
 }
 

-ModelAction *ModelChecker::get_last_conflict(ModelAction *act)
+ModelAction * ModelChecker::get_last_conflict(ModelAction *act)

 {
        void *loc = act->get_location();
        action_type type = act->get_type();
 {
        void *loc = act->get_location();
        action_type type = act->get_type();

diff --git a/model.h b/model.h
index 44979ab6ed789e229f8be1849da8832f0daed565..7dbd9ab3219130ccfb4a234a870f278072d4240d 100644 (file)
--- a/model.h
+++ b/model.h
@@ -31,9 +31,9 @@ public:
        thread_id_t get_tid() { return tid; }
        action_type get_type() { return type; }
        memory_order get_mo() { return order; }
        thread_id_t get_tid() { return tid; }
        action_type get_type() { return type; }
        memory_order get_mo() { return order; }

-       void *get_location() { return location; }
+       void * get_location() { return location; }

 
 

-       TreeNode *get_node() { return node; }
+       TreeNode * get_node() { return node; }

        void set_node(TreeNode *n) { node = n; }
 private:
        action_type type;
        void set_node(TreeNode *n) { node = n; }
 private:
        action_type type;


@@ -51,10 +51,10 @@ public:
                actionTrace = t;
                iter = actionTrace->begin();
        }
                actionTrace = t;
                iter = actionTrace->begin();
        }

-       ModelAction *get_diverge() { return diverge; }
-       action_list_t *get_trace() { return actionTrace; }
+       ModelAction * get_diverge() { return diverge; }
+       action_list_t * get_trace() { return actionTrace; }

        void advance_state() { iter++; }
        void advance_state() { iter++; }

-       ModelAction *get_state() {
+       ModelAction * get_state() {

                return iter == actionTrace->end() ? NULL : *iter;
        }
 private:
                return iter == actionTrace->end() ? NULL : *iter;
        }
 private:


@@ -76,10 +76,10 @@ public:
        void set_current_action(ModelAction *act) { current_action = act; }
        void check_current_action(void);
        void print_trace(void);
        void set_current_action(ModelAction *act) { current_action = act; }
        void check_current_action(void);
        void print_trace(void);

-       Thread *schedule_next_thread();
+       Thread * schedule_next_thread();

 
        int add_thread(Thread *t);
 
        int add_thread(Thread *t);

-       Thread *get_thread(thread_id_t tid) { return thread_map[tid]; }
+       Thread * get_thread(thread_id_t tid) { return thread_map[tid]; }

 
        void assign_id(Thread *t);
 
 
        void assign_id(Thread *t);
 


@@ -90,7 +90,7 @@ private:
        int used_thread_id;
        int num_executions;
 
        int used_thread_id;
        int num_executions;
 

-       ModelAction *get_last_conflict(ModelAction *act);
+       ModelAction * get_last_conflict(ModelAction *act);

        void set_backtracking(ModelAction *act);
        thread_id_t advance_backtracking_state();
        thread_id_t get_next_replay_thread();
        void set_backtracking(ModelAction *act);
        thread_id_t advance_backtracking_state();
        thread_id_t get_next_replay_thread();

diff --git a/schedule.cc b/schedule.cc
index 0f550c41962a5046c6934fe5380d17e0cda39e36..67b40ec88a809d5c2bff10e07787481a7d934566 100644 (file)
--- a/schedule.cc
+++ b/schedule.cc
@@ -9,7 +9,7 @@ void Scheduler::add_thread(Thread *t)
        readyList.push_back(t);
 }
 
        readyList.push_back(t);
 }
 

-Thread *Scheduler::next_thread(void)
+Thread * Scheduler::next_thread(void)

 {
        Thread *t = model->schedule_next_thread();
 
 {
        Thread *t = model->schedule_next_thread();
 


@@ -29,7 +29,7 @@ Thread *Scheduler::next_thread(void)
        return t;
 }
 
        return t;
 }
 

-Thread *Scheduler::get_current_thread(void)
+Thread * Scheduler::get_current_thread(void)

 {
        return current;
 }
 {
        return current;
 }

diff --git a/threads.cc b/threads.cc
index 830ea1a484159c9df61b641994781d30f97cb989..be384fb2889b1fdc85f16ae89e6274b8de833636 100644 (file)
--- a/threads.cc
+++ b/threads.cc
@@ -10,7 +10,7 @@
 
 #define STACK_SIZE (1024 * 1024)
 
 
 #define STACK_SIZE (1024 * 1024)
 

-static void *stack_allocate(size_t size)
+static void * stack_allocate(size_t size)

 {
        return malloc(size);
 }
 {
        return malloc(size);
 }


@@ -20,7 +20,7 @@ static void stack_free(void *stack)
        free(stack);
 }
 
        free(stack);
 }
 

-Thread *thread_current(void)
+Thread * thread_current(void)

 {
        return model->scheduler->get_current_thread();
 }
 {
        return model->scheduler->get_current_thread();
 }

diff --git a/threads.h b/threads.h
index 9787c3fb9514fdf4eee5c84503f1aedcb0e2ad31..8e0c3b054dfe7c84a92f60f0cc44ee700db00518 100644 (file)
--- a/threads.h
+++ b/threads.h
@@ -37,7 +37,7 @@ private:
        thread_state state;
 };
 
        thread_state state;
 };
 

-Thread *thread_current();
+Thread * thread_current();

 
 static inline thread_id_t thrd_to_id(thrd_t t)
 {
 
 static inline thread_id_t thrd_to_id(thrd_t t)
 {

diff --git a/tree.cc b/tree.cc
index 3a7f5c40e694cd4c8658ff1e122cd6959eaa3f87..16a0b69a96c9248308626698ffbecd7cbf91de87 100644 (file)
--- a/tree.cc
+++ b/tree.cc
@@ -15,7 +15,7 @@ TreeNode::~TreeNode() {
                delete it->second;
 }
 
                delete it->second;
 }
 

-TreeNode *TreeNode::exploreChild(tree_t id)
+TreeNode * TreeNode::exploreChild(tree_t id)

 {
        TreeNode *n;
        std::set<tree_t >::iterator it;
 {
        TreeNode *n;
        std::set<tree_t >::iterator it;


@@ -47,7 +47,7 @@ tree_t TreeNode::getNextBacktrack()
        return *backtrack.begin();
 }
 
        return *backtrack.begin();
 }
 

-TreeNode *TreeNode::getRoot()
+TreeNode * TreeNode::getRoot()

 {
        if (parent)
                return parent->getRoot();
 {
        if (parent)
                return parent->getRoot();

diff --git a/tree.h b/tree.h
index 676cbe4608923b12de245b947c142a64727bf26c..1c9f74cb440f850430b598d92c81b6f245922d33 100644 (file)
--- a/tree.h
+++ b/tree.h
@@ -16,12 +16,12 @@ public:
        TreeNode(TreeNode *par);
        ~TreeNode();
        bool hasBeenExplored(tree_t id) { return children.find(id) != children.end(); }
        TreeNode(TreeNode *par);
        ~TreeNode();
        bool hasBeenExplored(tree_t id) { return children.find(id) != children.end(); }

-       TreeNode *exploreChild(tree_t id);
+       TreeNode * exploreChild(tree_t id);

        tree_t getNextBacktrack();
 
        /* Return 1 if already in backtrack, 0 otherwise */
        int setBacktrack(tree_t id);
        tree_t getNextBacktrack();
 
        /* Return 1 if already in backtrack, 0 otherwise */
        int setBacktrack(tree_t id);

-       TreeNode *getRoot();
+       TreeNode * getRoot();

        static int getTotalNodes() { return TreeNode::totalNodes; }
 private:
        TreeNode *parent;
        static int getTotalNodes() { return TreeNode::totalNodes; }
 private:
        TreeNode *parent;