1212#include < deque>
1313#include < boost/container/vector.hpp>
1414#include < boost/container/deque.hpp>
15+ #include " new_deque.hpp"
1516#include < boost/container/devector.hpp>
1617#include < boost/container/small_vector.hpp>
1718#include < boost/container/stable_vector.hpp>
@@ -93,8 +94,9 @@ struct capacity_wrapper<C, false>
9394 { }
9495};
9596
96- const std::size_t RangeSize = 5 ;
97+ const std::size_t RangeSize = 8 ;
9798
99+ template <class IntType >
98100struct insert_end_range
99101{
100102 inline std::size_t capacity_multiplier () const
@@ -105,39 +107,42 @@ struct insert_end_range
105107 { c.insert (c.end (), &a[0 ], &a[0 ]+RangeSize); }
106108
107109 const char *name () const
108- { return " insert_end_range"
110+ { return " insert_end_range(8) "
109111
110- MyInt a[RangeSize];
112+ IntType a[RangeSize];
111113};
112114
115+ template <class IntType >
113116struct insert_end_repeated
114117{
115118 inline std::size_t capacity_multiplier () const
116119 { return RangeSize; }
117120
118121 template <class C >
119122 inline void operator ()(C &c, int i)
120- { c.insert (c.end (), RangeSize, MyInt (i)); }
123+ { c.insert (c.end (), RangeSize, IntType (i)); }
121124
122125 inline const char *name () const
123- { return " insert_end_repeated"
126+ { return " insert_end_repeated(8) "
124127
125- MyInt a[RangeSize];
128+ IntType a[RangeSize];
126129};
127130
131+ template <class IntType >
128132struct push_back
129133{
130134 inline std::size_t capacity_multiplier () const
131135 { return 1 ; }
132136
133137 template <class C >
134138 inline void operator ()(C &c, int i)
135- { c.push_back (MyInt (i)); }
139+ { c.push_back (IntType (i)); }
136140
137141 inline const char *name () const
138142 { return " push_back"
139143};
140144
145+ template <class IntType >
141146struct emplace_back
142147{
143148 inline std::size_t capacity_multiplier () const
@@ -151,19 +156,21 @@ struct emplace_back
151156 { return " emplace_back"
152157};
153158
159+ template <class IntType >
154160struct insert_near_end_repeated
155161{
156162 inline std::size_t capacity_multiplier () const
157163 { return RangeSize; }
158164
159165 template <class C >
160166 inline void operator ()(C &c, int i)
161- { c.insert (c.size () >= 2 *RangeSize ? c.end ()-2 *RangeSize : c.begin (), RangeSize, MyInt (i)); }
167+ { c.insert (c.size () >= 2 *RangeSize ? c.end ()-2 *RangeSize : c.begin (), RangeSize, IntType (i)); }
162168
163169 inline const char *name () const
164- { return " insert_near_end_repeated"
170+ { return " insert_near_end_repeated(8) "
165171};
166172
173+ template <class IntType >
167174struct insert_near_end_range
168175{
169176 inline std::size_t capacity_multiplier () const
@@ -176,11 +183,12 @@ struct insert_near_end_range
176183 }
177184
178185 inline const char *name () const
179- { return " insert_near_end_range"
186+ { return " insert_near_end_range(8) "
180187
181- MyInt a[RangeSize];
188+ IntType a[RangeSize];
182189};
183190
191+ template <class IntType >
184192struct insert_near_end
185193{
186194 inline std::size_t capacity_multiplier () const
@@ -192,13 +200,14 @@ struct insert_near_end
192200 typedef typename C::iterator it_t ;
193201 it_t it (c.end ());
194202 it -= static_cast <typename C::difference_type>(c.size () >= 2 )*2 ;
195- c.insert (it, MyInt (i));
203+ c.insert (it, IntType (i));
196204 }
197205
198206 inline const char *name () const
199207 { return " insert_near_end"
200208};
201209
210+ template <class IntType >
202211struct emplace_near_end
203212{
204213 inline std::size_t capacity_multiplier () const
@@ -272,16 +281,16 @@ void vector_test_template(std::size_t num_iterations, std::size_t num_elements,
272281
273282 nanosecond_type nseconds = timer.elapsed ().wall ;
274283
275- std::cout << cont_name << " ->" op. name () << " ns: "
284+ std::cout << cont_name << " ->" " ns: "
276285 << std::setw (8 )
277286 << float (nseconds)/float ((num_iterations-1 )*num_elements)
278287 << ' \t '
279288 << " Capacity: "
280289 << std::endl;
281290}
282291
283- template <class Operation >
284- void test_vectors ()
292+ template <class IntType , class Operation >
293+ void test_vectors_impl ()
285294{
286295 // #define SINGLE_TEST
287296 #define SIMPLE_IT
@@ -293,7 +302,11 @@ void test_vectors()
293302 #endif
294303 std::size_t numele [] = { 100000 };
295304 #elif defined SIMPLE_IT
305+ #ifdef NDEBUG
306+ std::size_t numit [] = { 50 };
307+ #else
296308 std::size_t numit [] = { 10 };
309+ #endif
297310 std::size_t numele [] = { 100000 };
298311 #else
299312 #ifdef NDEBUG
@@ -304,42 +317,69 @@ void test_vectors()
304317 unsigned int numele [] = { 10000 , 1000 , 100 , 10 };
305318 #endif
306319
307- // #define PRERESERVE_ONLY
308- #ifdef PRERESERVE_ONLY
320+
321+ #define RESERVE_ONLY 0
322+ #define NORESERVE_ONLY 1
323+
324+ // #define RESERVE_STRATEGY NORESERVE_ONLY
325+ #define RESERVE_STRATEGY RESERVE_ONLY
326+
327+ #ifndef RESERVE_STRATEGY
328+ #define P_INIT 0
329+ #define P_END 2
330+ #elif RESERVE_STRATEGY == PRERESERVE_ONLY
309331 #define P_INIT 1
310- #else
332+ #define P_END 2
333+ #elif RESERVE_STRATEGY == NORESERVE_ONLY
311334 #define P_INIT 0
312- #endif
335+ #define P_END 1
336+ #endif
313337
314- for (unsigned p = P_INIT; p != 2 ; ++p) {
315- std::cout << Operation ().name () << " , prereserve: " " 1" " 0" " \n "
316- const bool bp =p != 0 ;
317- for (unsigned int i = 0 ; i < sizeof (numele)/sizeof (numele[0 ]); ++i){
318- vector_test_template< std::vector<MyInt, std::allocator<MyInt> >, Operation >(numit[i], numele[i], " std::vector "
319- vector_test_template< bc::vector<MyInt, std::allocator<MyInt> >, Operation >(numit[i], numele[i] , " vector "
320- vector_test_template< bc::small_vector<MyInt, 0 , std::allocator<MyInt> >, Operation >(numit[i], numele[i], " small_vector "
321- vector_test_template< bc::devector<MyInt, std::allocator<MyInt> >, Operation >(numit[i], numele[i], " devector "
322- // vector_test_template< std::deque<MyInt, std::allocator<MyInt> >, Operation >(numit[i], numele[i], "std::deque ", bp);
323- vector_test_template< bc::deque<MyInt, std::allocator<MyInt> >, Operation >(numit[i], numele[i], " deque "
338+ for (unsigned p = P_INIT; p != P_END; ++p) {
339+ std::cout << " ---------------------------------\n "
340+ std::cout << " IntType:" typeid (IntType).name () << " op:" Operation ().name () << " , prereserve: " " 1" " 0" " \n "
341+ std::cout << " ---------------------------------\n "
342+ const bool bp = p != 0 ;
343+ const std::size_t it_count = sizeof (numele)/sizeof (numele[0 ]);
344+ for (unsigned int i = 0 ; i < it_count; ++i){
345+ std::cout << " \n " " ---- numit[i]: " " numele[i] : " " ---- \n "
346+ vector_test_template< std::vector<IntType, std::allocator<IntType> >, Operation >(numit[i], numele[i], " std::vector "
347+ vector_test_template< bc::vector<IntType, std::allocator<IntType> >, Operation >(numit[i], numele[i] , " vector "
348+ vector_test_template< bc::small_vector<IntType, 0 , std::allocator<IntType> >, Operation >(numit[i], numele[i], " small_vector "
349+ vector_test_template< bc::devector<IntType, std::allocator<IntType> >, Operation >(numit[i], numele[i], " devector "
350+ vector_test_template< std::deque<IntType, std::allocator<IntType> >, Operation >(numit[i], numele[i], " std::deque "
351+ vector_test_template< bc::deque<IntType, std::allocator<IntType> >, Operation >(numit[i], numele[i], " deque "
352+ vector_test_template< bc::new_deque<IntType, std::allocator<IntType> >, Operation >(numit[i], numele[i], " new_deque "
324353 }
325354 std::cout << " ---------------------------------\n ---------------------------------\n "
326355 }
327356}
328357
329- int main ()
358+ template <class IntType >
359+ void test_vectors ()
330360{
331361 // end
332- test_vectors<push_back>();
333- test_vectors<insert_end_range>();
334- test_vectors<insert_end_repeated>();
362+ test_vectors_impl<IntType, push_back<IntType> >();
363+ #if BOOST_CXX_VERSION >= 201103L
364+ test_vectors_impl<IntType, emplace_back<IntType> >();
365+ #endif
366+
367+ test_vectors_impl<IntType, insert_end_range<IntType> >();
368+ test_vectors_impl<IntType, insert_end_repeated<IntType> >();
369+
335370 // near end
336- test_vectors<insert_near_end>();
337- test_vectors<insert_near_end_range>();
338- test_vectors<insert_near_end_repeated>();
371+ test_vectors_impl<IntType, insert_near_end<IntType> >();
339372 #if BOOST_CXX_VERSION >= 201103L
340- test_vectors<emplace_back>();
341- test_vectors<emplace_near_end>();
373+ test_vectors_impl<IntType, emplace_near_end<IntType> >();
342374 #endif
375+ test_vectors_impl<IntType, insert_near_end_range<IntType> >();
376+ test_vectors_impl<IntType, insert_near_end_repeated<IntType> >();
377+ }
378+
379+ int main ()
380+ {
381+ // test_vectors<MyInt>();
382+ test_vectors<int >();
343383
344384 return 0 ;
345385}
0 commit comments