bugfix - add stl-model.h wrappers, to provide more control over STL
authorBrian Norris <banorris@uci.edu>
Thu, 7 Mar 2013 22:56:51 +0000 (14:56 -0800)
committerBrian Norris <banorris@uci.edu>
Thu, 7 Mar 2013 22:58:45 +0000 (14:58 -0800)
We need to provide an operator new/delete for our std::vector and
std::list instantiations. So we extend the base classes and add the
appropriate new/delete methods.

12 files changed:
cyclegraph.cc
cyclegraph.h
datarace.cc
datarace.h
model.cc
model.h
nodestack.h
promise.h
snapshot-interface.cc
stl-model.h [new file with mode: 0644]
threads-model.h
workqueue.h

index e96549f..8d37dea 100644 (file)
@@ -8,7 +8,7 @@
 /** Initializes a CycleGraph object. */
 CycleGraph::CycleGraph() :
        discovered(new HashTable<const CycleNode *, const CycleNode *, uintptr_t, 4, model_malloc, model_calloc, model_free>(16)),
-       queue(new std::vector< const CycleNode *, ModelAlloc<const CycleNode *> >()),
+       queue(new ModelVector<const CycleNode *>()),
        hasCycles(false),
        oldCycles(false)
 {
@@ -554,7 +554,7 @@ unsigned int CycleNode::getNumBackEdges() const
  * @return True if the element was found; false otherwise
  */
 template <typename T>
-static bool vector_remove_node(std::vector<T, SnapshotAlloc<T> >& v, const T n)
+static bool vector_remove_node(SnapVector<T>& v, const T n)
 {
        for (unsigned int i = 0; i < v.size(); i++) {
                if (v[i] == n) {
index 25401d9..9819cf8 100644 (file)
 #include "hashtable.h"
 #include "config.h"
 #include "mymemory.h"
+#include "stl-model.h"
 
 class Promise;
 class CycleNode;
 class ModelAction;
 
-typedef std::vector< const Promise *, ModelAlloc<const Promise *> > promise_list_t;
+typedef ModelVector<const Promise *> promise_list_t;
 
 /** @brief A graph of Model Actions for tracking cycles. */
 class CycleGraph {
@@ -68,7 +69,7 @@ class CycleGraph {
        bool mergeNodes(CycleNode *node1, CycleNode *node2);
 
        HashTable<const CycleNode *, const CycleNode *, uintptr_t, 4, model_malloc, model_calloc, model_free> *discovered;
-       std::vector< const CycleNode *, ModelAlloc<const CycleNode *> > * queue;
+       ModelVector<const CycleNode *> * queue;
 
 
        /** @brief A table for mapping ModelActions to CycleNodes */
@@ -77,7 +78,7 @@ class CycleGraph {
        HashTable<const Promise *, CycleNode *, uintptr_t, 4> promiseToNode;
 
 #if SUPPORT_MOD_ORDER_DUMP
-       std::vector< CycleNode *, SnapshotAlloc<CycleNode *> > nodeList;
+       SnapVector<CycleNode *> nodeList;
 #endif
 
        bool checkReachable(const CycleNode *from, const CycleNode *to) const;
@@ -86,8 +87,8 @@ class CycleGraph {
        bool hasCycles;
        bool oldCycles;
 
-       std::vector< CycleNode *, SnapshotAlloc<CycleNode *> > rollbackvector;
-       std::vector< CycleNode *, SnapshotAlloc<CycleNode *> > rmwrollbackvector;
+       SnapVector<CycleNode *> rollbackvector;
+       SnapVector<CycleNode *> rmwrollbackvector;
 };
 
 /**
@@ -124,10 +125,10 @@ class CycleNode {
        const Promise *promise;
 
        /** @brief The edges leading out from this node */
-       std::vector< CycleNode *, SnapshotAlloc<CycleNode *> > edges;
+       SnapVector<CycleNode *> edges;
 
        /** @brief The edges leading into this node */
-       std::vector< CycleNode *, SnapshotAlloc<CycleNode *> > back_edges;
+       SnapVector<CycleNode *> back_edges;
 
        /** Pointer to a RMW node that reads from this node, or NULL, if none
         * exists */
index 1ec43be..e678498 100644 (file)
@@ -9,7 +9,7 @@
 #include "action.h"
 
 struct ShadowTable *root;
-std::vector<struct DataRace *> unrealizedraces;
+SnapVector<struct DataRace *> unrealizedraces;
 void *memory_base;
 void *memory_top;
 
index d1f91b2..7c24b6d 100644 (file)
@@ -5,8 +5,8 @@
 #ifndef DATARACE_H
 #include "config.h"
 #include <stdint.h>
-#include <vector>
 #include "modeltypes.h"
+#include "stl-model.h"
 
 /* Forward declaration */
 class ClockVector;
@@ -47,7 +47,7 @@ void raceCheckRead(thread_id_t thread, const void *location, ClockVector *currCl
 bool checkDataRaces();
 void assert_race(struct DataRace *race);
 
-extern std::vector<struct DataRace *> unrealizedraces;
+extern SnapVector<struct DataRace *> unrealizedraces;
 
 /** Basic encoding idea:
  *      (void *) Either:
index 0122922..bf60224 100644 (file)
--- a/model.cc
+++ b/model.cc
@@ -61,7 +61,7 @@ struct model_snapshot_members {
        unsigned int next_thread_id;
        modelclock_t used_sequence_numbers;
        ModelAction *next_backtrack;
-       std::vector< bug_message *, SnapshotAlloc<bug_message *> > bugs;
+       SnapVector<bug_message *> bugs;
        struct execution_stats stats;
        bool failed_promise;
        bool too_many_reads;
@@ -85,12 +85,12 @@ ModelChecker::ModelChecker(struct model_params params) :
        obj_map(new HashTable<const void *, action_list_t *, uintptr_t, 4>()),
        lock_waiters_map(new HashTable<const void *, action_list_t *, uintptr_t, 4>()),
        condvar_waiters_map(new HashTable<const void *, action_list_t *, uintptr_t, 4>()),
-       obj_thrd_map(new HashTable<void *, std::vector<action_list_t> *, uintptr_t, 4 >()),
-       promises(new std::vector< Promise *, SnapshotAlloc<Promise *> >()),
-       futurevalues(new std::vector< struct PendingFutureValue, SnapshotAlloc<struct PendingFutureValue> >()),
-       pending_rel_seqs(new std::vector< struct release_seq *, SnapshotAlloc<struct release_seq *> >()),
-       thrd_last_action(new std::vector< ModelAction *, SnapshotAlloc<ModelAction *> >(1)),
-       thrd_last_fence_release(new std::vector< ModelAction *, SnapshotAlloc<ModelAction *> >()),
+       obj_thrd_map(new HashTable<void *, SnapVector<action_list_t> *, uintptr_t, 4 >()),
+       promises(new SnapVector<Promise *>()),
+       futurevalues(new SnapVector<struct PendingFutureValue>()),
+       pending_rel_seqs(new SnapVector<struct release_seq *>()),
+       thrd_last_action(new SnapVector<ModelAction *>(1)),
+       thrd_last_fence_release(new SnapVector<ModelAction *>()),
        node_stack(new NodeStack()),
        priv(new struct model_snapshot_members()),
        mo_graph(new CycleGraph())
@@ -137,11 +137,11 @@ static action_list_t * get_safe_ptr_action(HashTable<const void *, action_list_t
        return tmp;
 }
 
-static std::vector<action_list_t> * get_safe_ptr_vect_action(HashTable<void *, std::vector<action_list_t> *, uintptr_t, 4> * hash, void * ptr)
+static SnapVector<action_list_t> * get_safe_ptr_vect_action(HashTable<void *, SnapVector<action_list_t> *, uintptr_t, 4> * hash, void * ptr)
 {
-       std::vector<action_list_t> *tmp = hash->get(ptr);
+       SnapVector<action_list_t> *tmp = hash->get(ptr);
        if (tmp == NULL) {
-               tmp = new std::vector<action_list_t>();
+               tmp = new SnapVector<action_list_t>();
                hash->put(ptr, tmp);
        }
        return tmp;
@@ -642,8 +642,8 @@ ModelAction * ModelChecker::get_last_fence_conflict(ModelAction *act) const
         *   load-acquire
         * or
         *   load --sb-> fence-acquire */
-       std::vector< ModelAction *, ModelAlloc<ModelAction *> > acquire_fences(get_num_threads(), NULL);
-       std::vector< ModelAction *, ModelAlloc<ModelAction *> > prior_loads(get_num_threads(), NULL);
+       ModelVector<ModelAction *> acquire_fences(get_num_threads(), NULL);
+       ModelVector<ModelAction *> prior_loads(get_num_threads(), NULL);
        bool found_acquire_fences = false;
        for ( ; rit != list->rend(); rit++) {
                ModelAction *prev = *rit;
@@ -1080,7 +1080,7 @@ void ModelChecker::add_future_value(const ModelAction *writer, ModelAction *read
 bool ModelChecker::process_write(ModelAction *curr)
 {
        /* Readers to which we may send our future value */
-       std::vector< ModelAction *, ModelAlloc<ModelAction *> > send_fv;
+       ModelVector<ModelAction *> send_fv;
 
        bool updated_mod_order = w_modification_order(curr, &send_fv);
        int promise_idx = get_promise_to_resolve(curr);
@@ -1704,7 +1704,7 @@ bool ModelChecker::should_read_instead(const ModelAction *curr, const T *rf, con
        if (!mo_graph->checkReachable(rf, other_rf))
                return false;
 
-       std::vector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, curr->get_location());
+       SnapVector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, curr->get_location());
        action_list_t *list = &(*thrd_lists)[id_to_int(curr->get_tid())];
        action_list_t::reverse_iterator rit = list->rbegin();
        ASSERT((*rit) == curr);
@@ -1747,7 +1747,7 @@ bool ModelChecker::check_recency(ModelAction *curr, const T *rf) const
                        curr->get_node()->get_read_from_promise_size() <= 1)
                return true;
 
-       std::vector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, curr->get_location());
+       SnapVector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, curr->get_location());
        int tid = id_to_int(curr->get_tid());
        ASSERT(tid < (int)thrd_lists->size());
        action_list_t *list = &(*thrd_lists)[tid];
@@ -1805,7 +1805,7 @@ bool ModelChecker::check_recency(ModelAction *curr, const T *rf) const
 template <typename rf_type>
 bool ModelChecker::r_modification_order(ModelAction *curr, const rf_type *rf)
 {
-       std::vector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, curr->get_location());
+       SnapVector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, curr->get_location());
        unsigned int i;
        bool added = false;
        ASSERT(curr->is_read());
@@ -1911,9 +1911,9 @@ bool ModelChecker::r_modification_order(ModelAction *curr, const rf_type *rf)
  * value. If NULL, then don't record any future values.
  * @return True if modification order edges were added; false otherwise
  */
-bool ModelChecker::w_modification_order(ModelAction *curr, std::vector< ModelAction *, ModelAlloc<ModelAction *> > *send_fv)
+bool ModelChecker::w_modification_order(ModelAction *curr, ModelVector<ModelAction *> *send_fv)
 {
-       std::vector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, curr->get_location());
+       SnapVector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, curr->get_location());
        unsigned int i;
        bool added = false;
        ASSERT(curr->is_write());
@@ -2057,7 +2057,7 @@ bool ModelChecker::thin_air_constraint_may_allow(const ModelAction *writer, cons
  */
 bool ModelChecker::mo_may_allow(const ModelAction *writer, const ModelAction *reader)
 {
-       std::vector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, reader->get_location());
+       SnapVector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, reader->get_location());
        unsigned int i;
        /* Iterate over all threads */
        for (i = 0; i < thrd_lists->size(); i++) {
@@ -2158,7 +2158,7 @@ bool ModelChecker::release_seq_heads(const ModelAction *rf,
                release_heads->push_back(fence_release);
 
        int tid = id_to_int(rf->get_tid());
-       std::vector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, rf->get_location());
+       SnapVector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, rf->get_location());
        action_list_t *list = &(*thrd_lists)[tid];
        action_list_t::const_reverse_iterator rit;
 
@@ -2301,7 +2301,7 @@ void ModelChecker::get_release_seq_heads(ModelAction *acquire,
 bool ModelChecker::resolve_release_sequences(void *location, work_queue_t *work_queue)
 {
        bool updated = false;
-       std::vector< struct release_seq *, SnapshotAlloc<struct release_seq *> >::iterator it = pending_rel_seqs->begin();
+       SnapVector<struct release_seq *>::iterator it = pending_rel_seqs->begin();
        while (it != pending_rel_seqs->end()) {
                struct release_seq *pending = *it;
                ModelAction *acquire = pending->acquire;
@@ -2382,7 +2382,7 @@ void ModelChecker::add_action_to_lists(ModelAction *act)
        if (uninit)
                action_trace->push_front(uninit);
 
-       std::vector<action_list_t> *vec = get_safe_ptr_vect_action(obj_thrd_map, act->get_location());
+       SnapVector<action_list_t> *vec = get_safe_ptr_vect_action(obj_thrd_map, act->get_location());
        if (tid >= (int)vec->size())
                vec->resize(priv->next_thread_id);
        (*vec)[tid].push_back(act);
@@ -2405,7 +2405,7 @@ void ModelChecker::add_action_to_lists(ModelAction *act)
                void *mutex_loc = (void *) act->get_value();
                get_safe_ptr_action(obj_map, mutex_loc)->push_back(act);
 
-               std::vector<action_list_t> *vec = get_safe_ptr_vect_action(obj_thrd_map, mutex_loc);
+               SnapVector<action_list_t> *vec = get_safe_ptr_vect_action(obj_thrd_map, mutex_loc);
                if (tid >= (int)vec->size())
                        vec->resize(priv->next_thread_id);
                (*vec)[tid].push_back(act);
@@ -2549,7 +2549,7 @@ int ModelChecker::get_promise_to_resolve(const ModelAction *curr) const
  */
 bool ModelChecker::resolve_promise(ModelAction *write, unsigned int promise_idx)
 {
-       std::vector< ModelAction *, ModelAlloc<ModelAction *> > actions_to_check;
+       ModelVector<ModelAction *> actions_to_check;
        Promise *promise = (*promises)[promise_idx];
 
        for (unsigned int i = 0; i < promise->get_num_readers(); i++) {
@@ -2724,7 +2724,7 @@ void ModelChecker::compute_relseq_breakwrites(ModelAction *curr)
  */
 void ModelChecker::build_may_read_from(ModelAction *curr)
 {
-       std::vector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, curr->get_location());
+       SnapVector<action_list_t> *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, curr->get_location());
        unsigned int i;
        ASSERT(curr->is_read());
 
diff --git a/model.h b/model.h
index 96c1ec7..236bbe9 100644 (file)
--- a/model.h
+++ b/model.h
@@ -15,6 +15,7 @@
 #include "workqueue.h"
 #include "config.h"
 #include "modeltypes.h"
+#include "stl-model.h"
 
 /* Forward declaration */
 class Node;
@@ -27,9 +28,9 @@ class ClockVector;
 struct model_snapshot_members;
 
 /** @brief Shorthand for a list of release sequence heads */
-typedef std::vector< const ModelAction *, ModelAlloc<const ModelAction *> > rel_heads_list_t;
+typedef ModelVector<const ModelAction *> rel_heads_list_t;
 
-typedef std::list< ModelAction *, SnapshotAlloc<ModelAction *> > action_list_t;
+typedef SnapList<ModelAction *> action_list_t;
 
 /**
  * Model checker parameter structure. Holds run-time configuration options for
@@ -92,7 +93,7 @@ struct release_seq {
        /** @brief The head of the potential longest release sequence chain */
        const ModelAction *release;
        /** @brief The write(s) that may break the release sequence */
-       std::vector<const ModelAction *> writes;
+       SnapVector<const ModelAction *> writes;
 };
 
 /** @brief The central structure for model-checking */
@@ -204,7 +205,7 @@ private:
        template <typename rf_type>
        bool r_modification_order(ModelAction *curr, const rf_type *rf);
 
-       bool w_modification_order(ModelAction *curr, std::vector< ModelAction *, ModelAlloc<ModelAction *> > *send_fv);
+       bool w_modification_order(ModelAction *curr, ModelVector<ModelAction *> *send_fv);
        void get_release_seq_heads(ModelAction *acquire, ModelAction *read, rel_heads_list_t *release_heads);
        bool release_seq_heads(const ModelAction *rf, rel_heads_list_t *release_heads, struct release_seq *pending) const;
        bool resolve_release_sequences(void *location, work_queue_t *work_queue);
@@ -231,9 +232,9 @@ private:
         * to a trace of all actions performed on the object. */
        HashTable<const void *, action_list_t *, uintptr_t, 4> * const condvar_waiters_map;
 
-       HashTable<void *, std::vector<action_list_t> *, uintptr_t, 4 > * const obj_thrd_map;
-       std::vector< Promise *, SnapshotAlloc<Promise *> > * const promises;
-       std::vector< struct PendingFutureValue, SnapshotAlloc<struct PendingFutureValue> > * const futurevalues;
+       HashTable<void *, SnapVector<action_list_t> *, uintptr_t, 4 > * const obj_thrd_map;
+       SnapVector<Promise *> * const promises;
+       SnapVector<struct PendingFutureValue> * const futurevalues;
 
        /**
         * List of pending release sequences. Release sequences might be
@@ -241,10 +242,10 @@ private:
         * are established. Each entry in the list may only be partially
         * filled, depending on its pending status.
         */
-       std::vector< struct release_seq *, SnapshotAlloc<struct release_seq *> > * const pending_rel_seqs;
+       SnapVector<struct release_seq *> * const pending_rel_seqs;
 
-       std::vector< ModelAction *, SnapshotAlloc<ModelAction *> > * const thrd_last_action;
-       std::vector< ModelAction *, SnapshotAlloc<ModelAction *> > * const thrd_last_fence_release;
+       SnapVector<ModelAction *> * const thrd_last_action;
+       SnapVector<ModelAction *> * const thrd_last_fence_release;
        NodeStack * const node_stack;
 
        /** Private data members that should be snapshotted. They are grouped
index 8ad329e..394552c 100644 (file)
@@ -12,6 +12,7 @@
 #include "mymemory.h"
 #include "schedule.h"
 #include "promise.h"
+#include "stl-model.h"
 
 class ModelAction;
 class Thread;
@@ -133,9 +134,9 @@ private:
 
        Node * const parent;
        const int num_threads;
-       std::vector< bool, ModelAlloc<bool> > explored_children;
-       std::vector< bool, ModelAlloc<bool> > backtrack;
-       std::vector< struct fairness_info, ModelAlloc< struct fairness_info> > fairness;
+       ModelVector<bool> explored_children;
+       ModelVector<bool> backtrack;
+       ModelVector<struct fairness_info> fairness;
        int numBacktracks;
        enabled_type_t *enabled_array;
 
@@ -143,19 +144,19 @@ private:
         * The set of past ModelActions that this the action at this Node may
         * read from. Only meaningful if this Node represents a 'read' action.
         */
-       std::vector< const ModelAction *, ModelAlloc< const ModelAction * > > read_from_past;
+       ModelVector<const ModelAction *> read_from_past;
        unsigned int read_from_past_idx;
 
-       std::vector< const ModelAction *, ModelAlloc<const ModelAction *> > read_from_promises;
+       ModelVector<const ModelAction *> read_from_promises;
        int read_from_promise_idx;
 
-       std::vector< struct future_value, ModelAlloc<struct future_value> > future_values;
+       ModelVector<struct future_value> future_values;
        int future_index;
 
-       std::vector< bool, ModelAlloc<bool> > resolve_promise;
+       ModelVector<bool> resolve_promise;
        int resolve_promise_idx;
 
-       std::vector< const ModelAction *, ModelAlloc<const ModelAction *> > relseq_break_writes;
+       ModelVector<const ModelAction *> relseq_break_writes;
        int relseq_break_index;
 
        int misc_index;
@@ -163,7 +164,7 @@ private:
        int * yield_data;
 };
 
-typedef std::vector< Node *, ModelAlloc< Node * > > node_list_t;
+typedef ModelVector<Node *> node_list_t;
 
 /**
  * @brief A stack of nodes
index 0adc3de..90ec1d2 100644 (file)
--- a/promise.h
+++ b/promise.h
@@ -8,10 +8,10 @@
 #define __PROMISE_H__
 
 #include <inttypes.h>
-#include <vector>
 
 #include "modeltypes.h"
 #include "mymemory.h"
+#include "stl-model.h"
 
 class ModelAction;
 
@@ -52,14 +52,14 @@ class Promise {
  private:
        /** @brief Thread ID(s) for thread(s) that potentially can satisfy this
         *  promise */
-       std::vector< bool, SnapshotAlloc<bool> > available_thread;
+       SnapVector<bool> available_thread;
 
        int num_available_threads;
 
        const future_value fv;
 
        /** @brief The action(s) which read the promised future value */
-       std::vector< ModelAction *, SnapshotAlloc<ModelAction *> > readers;
+       SnapVector<ModelAction *> readers;
 
        const ModelAction *write;
 };
index 57ac52e..bd1de3e 100644 (file)
@@ -2,12 +2,12 @@
 #include <unistd.h>
 #include <cstring>
 #include <inttypes.h>
-#include <vector>
 
 #include "snapshot-interface.h"
 #include "snapshot.h"
 #include "common.h"
 #include "mymemory.h"
+#include "stl-model.h"
 
 /* MYBINARYNAME only works because our pathname usually includes 'model' (e.g.,
  * /.../model-checker/test/userprog.o) */
@@ -29,7 +29,7 @@ class SnapshotStack {
 
        MEMALLOC
  private:
-       std::vector<struct snapshot_entry, ModelAlloc<struct snapshot_entry> > stack;
+       ModelVector<struct snapshot_entry> stack;
 };
 
 static SnapshotStack *snap_stack;
diff --git a/stl-model.h b/stl-model.h
new file mode 100644 (file)
index 0000000..ae6e8b2
--- /dev/null
@@ -0,0 +1,76 @@
+#ifndef __STL_MODEL_H__
+#define __STL_MODEL_H__
+
+#include <vector>
+#include <list>
+#include "mymemory.h"
+
+template<typename _Tp>
+class ModelList : public std::list<_Tp, ModelAlloc<_Tp> >
+{
+ public:
+       typedef std::list< _Tp, ModelAlloc<_Tp> > list;
+
+       ModelList() :
+               list()
+       { }
+
+       ModelList(size_t n, const _Tp& val = _Tp()) :
+               list(n, val)
+       { }
+
+       MEMALLOC
+};
+
+template<typename _Tp>
+class SnapList : public std::list<_Tp, SnapshotAlloc<_Tp> >
+{
+ public:
+       typedef std::list<_Tp, SnapshotAlloc<_Tp> > list;
+
+       SnapList() :
+               list()
+       { }
+
+       SnapList(size_t n, const _Tp& val = _Tp()) :
+               list(n, val)
+       { }
+
+       SNAPSHOTALLOC
+};
+
+template<typename _Tp>
+class ModelVector : public std::vector<_Tp, ModelAlloc<_Tp> >
+{
+ public:
+       typedef std::vector< _Tp, ModelAlloc<_Tp> > vector;
+
+       ModelVector() :
+               vector()
+       { }
+
+       ModelVector(size_t n, const _Tp& val = _Tp()) :
+               vector(n, val)
+       { }
+
+       MEMALLOC
+};
+
+template<typename _Tp>
+class SnapVector : public std::vector<_Tp, SnapshotAlloc<_Tp> >
+{
+ public:
+       typedef std::vector< _Tp, SnapshotAlloc<_Tp> > vector;
+
+       SnapVector() :
+               vector()
+       { }
+
+       SnapVector(size_t n, const _Tp& val = _Tp()) :
+               vector(n, val)
+       { }
+
+       SNAPSHOTALLOC
+};
+
+#endif /* __STL_MODEL_H__ */
index b15c409..e77e80c 100644 (file)
@@ -7,11 +7,11 @@
 
 #include <ucontext.h>
 #include <stdint.h>
-#include <vector>
 
 #include "mymemory.h"
 #include <threads.h>
 #include "modeltypes.h"
+#include "stl-model.h"
 
 struct thread_params {
        thrd_start_t func;
@@ -157,7 +157,7 @@ private:
         * list is used for thread joins, where another Thread waits for this
         * Thread to complete
         */
-       std::vector< ModelAction *, SnapshotAlloc<ModelAction *> > wait_list;
+       SnapVector<ModelAction *> wait_list;
 
        /**
         * The value returned by the last action in this thread
index f08f63c..a25e4fe 100644 (file)
@@ -8,6 +8,7 @@
 
 #include <list>
 #include "mymemory.h"
+#include "stl-model.h"
 
 class ModelAction;
 
@@ -102,6 +103,6 @@ class MOEdgeWorkEntry : public WorkQueueEntry {
 };
 
 /** @brief typedef for the work queue type */
-typedef std::list< WorkQueueEntry, ModelAlloc<WorkQueueEntry> > work_queue_t;
+typedef ModelList<WorkQueueEntry> work_queue_t;
 
 #endif /* __WORKQUEUE_H__ */