- Boost - lists.preview.boost.org

[reference_wrapper] add operator()(Args...) to reference_wrapper
by Philipp Moeller 10 May '12

10 May '12

Given that Boost now has perfect forwarding emulation through Boost.Move and a better result_of, would it be possible to enable reference_wrapper to forward the function call operator? The current behavior is somewhat surprising and makes a few of the most promising applications of reference_wrapper (reference wrap polymorphic boost::function objects) impossible with code that is no prepared to work with reference_wrapper. It would also be more consistent with reference_wrapper of the stdlib. I can file a corresponding bug report and add a patch, if there is interest. Cheers, Philipp Moeller

2 5

[multi_array] Updated patches
by Bill Buklis 10 May '12

10 May '12

For the multi_array library, there is an updated version of the library in the trunk plus a few tickets that have proposed patches. These are updates for some fairly important issues. I'd absolutely love it if these patches could be incorporated into the next boost release, whenever that may be. I realize that the official maintainer, Garcia, is understandably very busy, so could one of the powers that be please review these patches for correctness and update the official libraries as needed? Here are the tickets that already have proposed fixes: ticket:4874 <https://svn.boost.org/trac/boost/ticket/4874> - multi_array compile errors using Visual C++ 2010 in debug mode ticket:6554 <https://svn.boost.org/trac/boost/ticket/6554> - Compiler error dereferencing multi_array value via an iterator ticket:6811 <https://svn.boost.org/trac/boost/ticket/6811> - Default argument of type multi_array fails under MSVC 2010 SP1 Thanks, -- Bill

1 0

[preprocessor] include speed question
by lcaminiti 10 May '12

10 May '12

Hello all, I have a general question about what's the best way to include files that results in faster compilation time. In my example, I have *a lot* of files that use different parts of Boost.Preprocessor. Each header includes the specific Boost.Preprocessor headers that it needs. As a results the same Boost.Preprocessor header and #included many times (50+?) even if the including has no effect after the first inclusion. Furthermore, at the end essentially all Boost.Preprocessor header get included. This way is more module in that each single file includes all the headers that it needs. But, does that slow down compilation? Would it be faster to just #include <boost/preprocessor.hpp> just once into a front-end header that then includes all my single header files? (Maybe with modern compilers and file-systems this makes no difference?) Thanks a lot. --Lorenzo -- View this message in context: http://boost.2283326.n4.nabble.com/boost-preprocessor-include-speed-questio… Sent from the Boost - Dev mailing list archive at Nabble.com.

3 2

Scoped enum emulation
by Anthony Williams 10 May '12

10 May '12

Hi, On trunk there are currently two scoped enum emulation headers. One is the one that Beman wrote, in boost/detail/scoped_enum_emulation.hpp and the other is the one that Vicente has developed for the new version of Boost.Thread, in boost/thread/detail/scoped_enum.hpp It seems to me that it is a shame to have two implementations of the same thing in boost. Since Vicente's version provides additional facilities, I would therefore like to merge Vicente's code into the boost/detail header. We could retain the simple macros from Beman's header as wrappers for the more complex macros that Vicente has written. What do you think? Anthony -- Author of C++ Concurrency in Action http://www.stdthread.co.uk/book/ just::thread C++11 thread library http://www.stdthread.co.uk Just Software Solutions Ltd http://www.justsoftwaresolutions.co.uk 15 Carrallack Mews, St Just, Cornwall, TR19 7UL, UK. Company No. 5478976

3 2

[mpl] cross product and gcc specific compiler error
by Josh Quigley 10 May '12

10 May '12

Hi, A question from the grossly uninformed: I grabbed an mpl cross product implementation (product_view) of this mailing list. It works fine in MSVC but fails in gcc: typedef boost::mpl::vector<float, double, long double> DecimalTypes; typedef boost::mpl::vector<int, unsigned int, long, unsigned long, long long, unsigned long long> IntegralTypes; typedef product_view<boost::mpl::vector<DecimalTypes, IntegralTypes> > EachDecimalWithEachIntegralT; BOOST_AUTO_TEST_CASE_TEMPLATE(MyTest, DecimalIntegralT, EachDecimalWithEachIntegralT) { { typename DecimalIntegralT::item1 r(1234567); // Fails on gcc: no type named ‘item0’ in ‘struct boost::mpl::v_item<long long unsigned int, boost::mpl::v_item<ext::decimal::decimal128, boost::mpl::vector0<mpl_::na>, 0>, 0> typename DecimalIntegralT::item0 d(r); BOOST_CHECK_EQUAL(static_cast<long long>(d), r); } } A complete listing is below. The thing that has me really stumped is the type exsits in MSVC, so I'm at a bit of loss of how to proceed debugging. // // LISTING // #include <boost/mpl/vector.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/at.hpp> #include <boost/mpl/copy.hpp> #include <boost/mpl/transform.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/function.hpp> #include <boost/mpl/vector.hpp> #include <boost/mpl/list.hpp> #include <boost/mpl/joint_view.hpp> #include <boost/test/unit_test.hpp> namespace detail { using boost::mpl::at_c; using boost::mpl::at; using boost::mpl::vector3; using boost::mpl::true_; using boost::mpl::false_; using boost::mpl::if_; using boost::mpl::next; using boost::mpl::bool_; using boost::mpl::front_inserter; using boost::mpl::clear; using boost::mpl::forward_iterator_tag; using boost::mpl::reverse_copy; using boost::mpl::transform1; using boost::mpl::deref; using boost::mpl::_1; using boost::mpl::_2; using boost::mpl::int_; using boost::mpl::fold; using boost::mpl::or_; using boost::mpl::nested_begin_end_tag; template<typename S, typename O> struct state_with_overflow { typedef S state; typedef O overflow; }; template<typename I3S> struct i3s_increment_inserter { template<typename I3, typename O> struct i3_ { typedef I3 i3; typedef O overflow; }; template<typename I3> struct incr_ { typedef typename next< typename at_c< I3, 1 >::type >::type next_; typedef bool_< boost::is_same< next_, typename at_c<I3,2>::type >::value > overflow_; typedef i3_< vector3< typename at_c<I3,0>::type, typename if_< overflow_, typename at_c<I3,0>::type, next_ >::type, typename at_c<I3,2>::type >, overflow_ > type; }; typedef front_inserter< typename clear<I3S>::type > base_; typedef state_with_overflow< typename base_::state, true_ > state; struct operation { template<typename S, typename I3> struct apply { typedef typename if_< typename S::overflow, typename incr_<I3>::type, i3_<I3,false_> >::type next_; typedef state_with_overflow< typename base_::operation::template apply< typename S::state, typename next_::i3 >::type, typename next_::overflow > type; }; }; }; template< typename SWO > struct product_iterator { private: typedef typename SWO::state I3S; public: typedef forward_iterator_tag category; typedef typename transform1< I3S, deref< at< _1, int_<1> > > >::type type; typedef product_iterator< typename reverse_copy< I3S, i3s_increment_inserter<I3S> >::type > next; }; template<typename S> struct product_view { private: typedef typename transform1< S, vector3< boost::mpl::begin<_1>, boost::mpl::begin<_1>, boost::mpl::end<_1> > >::type begin_impl; typedef typename fold< S, false_, or_< _1, boost::is_same< boost::mpl::begin<_2>, boost::mpl::end<_2> > // empty<_2> refuses to compile on MSVC 7.1 > >::type empty_result; public: typedef nested_begin_end_tag tag; typedef product_iterator< state_with_overflow< begin_impl, empty_result > > begin; typedef product_iterator< state_with_overflow< begin_impl, true_ > > end; }; } using detail::product_view; // typedef boost::mpl::vector<decimal32, decimal64, decimal128> DecimalTypes; // Original typedef boost::mpl::vector<float, double, long double> DecimalTypes; // for demonstration typedef boost::mpl::vector<int, unsigned int, long, unsigned long, long long, unsigned long long> IntegralTypes; typedef product_view<boost::mpl::vector<DecimalTypes, IntegralTypes> > EachDecimalWithEachIntegralT; BOOST_AUTO_TEST_CASE_TEMPLATE(MyTest, DecimalIntegralT, EachDecimalWithEachIntegralT) { { typename DecimalIntegralT::item1 r(1234567); // Fails on gcc: no type named ‘item0’ in ‘struct boost::mpl::v_item<long long unsigned int, boost::mpl::v_item<ext::decimal::decimal128, boost::mpl::vector0<mpl_::na>, 0>, 0> typename DecimalIntegralT::item0 d(r); BOOST_CHECK_EQUAL(static_cast<long long>(d), r); } }

1 0

[coroutine]
by Christopher Kormanyos 10 May '12

10 May '12

Hello, I am checking out the fascinating work with Boost.Coroutine. Excellent! This is definitely paving the way for C++ threads. I have been looking for this kind of thing for quite some time now. I am mostly interested in adaptability, as I386 and the lot are mostly done. It's always the same game with the cooperative context switching. Time-after-time, you identify the clobbered registers after a cooperative yield, save them in a context structure and restore them after the yield. Then you deal with the stacks. OK, fine. But how can you approach the dream of generic context switching? So you know, here I am. I would want Boost.Context for numerous GCC targets: Atmel AVR, Renesas V850, Renesas RL78, Cortex-M3/4. And the list goes on, as I use numerous embedded processors. The compiler's calling convention is poorly documented at best. And various compiler vendors may or may not coordinate the calling convention among each other. Can the documentation of Boost.Coroutine aid in adaptation in any way? Or is this simply beyond the present scope of the proposed Boost.Coroutine? * Is there any documentation regarding the context switch? * Are you specifically targeting preemptive yields? * If so, is the compiler's calling convention taken into account? * Can the remarkable Boost.Coroutine be adapted to other CPUs? * How? * Is Coroutine meant to be compatible with std::this_thread::yield(), etc? * Can the user select the stack sizes? * How? Thank you. And keep up the great work! Best regards, Chris.

3 6

[coroutine] request for review manager
by Oliver Kowalke 10 May '12

10 May '12

Hi, I want to ask who wants to be the review manager for boost.coroutine? The documentation is updated and available at: http://ok73.ok.funpic.de/boost/libs/coroutine/doc/html/index.html best regards, Oliver

2 4

[serialization] portable_binary_archive using shared lib
by Renato Tegon Forti 09 May '12

09 May '12

Hi, I want use portable_binary_archive, but using shared link on Windows! Have any way? Thanks

1 0

[exception] patches for a few testing-related issues
by David Deakins 09 May '12

09 May '12

Hi Emil, I have opened two Trac tickets (6877 and 6878) related to what I believe is a bug in exception_ptr_test.cpp and also for a minor change to the testing jamfile that will allow some of the thread-dependent tests to run on platforms that do not have automatic thread-specific-storage cleanup implemented (WinCE falls in this category). Are you ok with me applying these patches? Thanks, -Dave

2 1

enable_if question
by John Maddock 08 May '12

08 May '12

Folks I'm having some difficulties understanding the subtleties of enable_if, consider: using namespace boost; template <unsigned B> struct dummy {}; template <unsigned B, class Integer> typename boost::enable_if<mpl::and_<is_signed<Integer>, mpl::bool_<(sizeof(Integer) <= sizeof(long))> > >::type bar(dummy<B>&, const Integer&) { } template <unsigned B, class Integer> typename boost::enable_if<mpl::and_<is_unsigned<Integer>, mpl::bool_<(sizeof(Integer) <= sizeof(long))> > >::type bar(dummy<B>&, const Integer&) { } Then calling: dummy<2> d; bar(d, 2); Leads to an ambiguity between the two overloads (both gcc and VC++10), how can that be? However, changing the condition to: template <unsigned B, class Integer> typename boost::enable_if<mpl::and_<is_signed<Integer>, mpl::bool_<(B || !B) && (sizeof(Integer) <= sizeof(long))> > >::type bar(dummy<B>&, const Integer&) { } template <unsigned B, class Integer> typename boost::enable_if<mpl::and_<is_unsigned<Integer>, mpl::bool_<(B || !B) && (sizeof(Integer) <= sizeof(long))> > >::type bar(dummy<B>&, const Integer&) { } "fixes" things. But this fix isn't always possible. Thoughts? Thanks, John.

2 2

[preprocessor] Chaos: Auto macros incorrectly deduces the recursion state
by paul Fultz 08 May '12

08 May '12

Hello, I am not sure if this is the most appropriate place to post this, but I do know the author frequents this mailing list often. Well, when I run this code: #define FIXED(s, n, text) text #define TTP(s, n, id) \ template< \ CHAOS_PP_AUTO_ENUM( \ CHAOS_PP_INC(n), FIXED, class \ ) \ > class id ## n \ /**/ CHAOS_PP_AUTO_ENUM(3, TTP, T) // template<class> class T0, // template<class, class> class T1, // template<class, class, class> class T2 It expands to: template< CHAOS_IP_AUTO_ENUM_1( 1, FIXED, class ) > class T0 , template< CHAOS_IP_AUTO_ENUM_1( 2, FIXED, class ) > class T1 , template< CHAOS_IP_AUTO_ENUM_1( 3, FIXED, class ) > class T2 Showing CHAOS_IP_AUTO_ENUM_1 is incorrect, and its why it won't expand since its trying to be expanded recursively. It should be CHAOS_IP_AUTO_ENUM_2 instead. I'm not sure why it incorrectly deduces the recursion state. TTP is not a deferred expression. Any ideas? Thanks, Paul Fultz II

2 1

Aspen Meadows Resort suite available for up to 4 nights for C++Now Conference
by Pdruck 08 May '12

08 May '12

Hi. I reserved a suite at Aspen Meadows Resort for 4 nights, for the C++Now conference; Sunday night, May 13 – Wed night, May 16, leaving Thurs. May 17. But due to last minute pressing events in the office, I have to cancel my registration. Propose to switch my reservation to whomever might be attending. Win-win. I don’t lose a heft cancellation fee. You get a beautiful suite (having been there previously) and conveniently located to the conference at Physics Center. Regards. Phil

1 0

Iterator Range and operator==
by Olaf van der Spek 08 May '12

08 May '12

Hi, What do you expect this code to do? Is b true or false? And why? Is this expected behaviour? #include <boost/range/iterator_range.hpp> #include <string> int main() { std::string s = "Olaf"; boost::iterator_range<std::string::iterator> r(s); bool a = r == s; bool b = r == "Olaf"; assert(a); assert(b); return 0; } -- Olaf

9 17

[bind] variant arg list template functions could have a forward declaration as doc & coding suggeustion
by Huang Huan 08 May '12

08 May '12

Hi all, Before I do some change, no suggestion when I coding with Boost.Bind. This is a big disadvantage for learning & using. Variant arg list template functions as follow are there in so many boost code file. // template<class F, class A1, ... class An> // X foo(F f, A1 a1, ... An an); template<class F> X foo(F f) { ... } template<class F, class A1> X foo(F f, A1 a1) { ... } template<class F, class A1, class A2> X foo(F f, A1 a1, A2 a1) { ... } ... Some code like the comment, the forward declaration could be good doc & coding suggestion, such as following: template<class F /*, class A1, ... class An */> X foo(F f /*, A1 a1, ... An an */); OR template<class F, class A1, class A2 /*, ... */> X foo(F f, A1 a1, A2 a2, ... ); OR template<class F /*... */> // may no cxx11 X foo(F f , ... ); This may like BOOST_CONTAINERS_PERFECT_FORWARDING Becase of the template grammar, this forward declaration has no implementation. The code is ONLY for coding suggestion & doc. As an example [boost][bind] When I write the code boost::bind( _ ) I want the suggestions as follow ______________________________________________ | [1 of 3] _bi::bind_t<_bi::unspecified, F, L> bind(F f, ...) | |_____________________________________________| A more difficulty is boost bind has a BOOST_BIND for redefine the name. my patch as follow: =================================================================== --- bind.hpp (revision 77278) +++ bind.hpp (working copy) @@ -1289,6 +1289,17 @@ #ifndef BOOST_BIND #define BOOST_BIND bind + +template<class R, class F, class L> + _bi::bind_t<R, F, L> + bind(F f, ...); +template<class R, class F, class L> + _bi::bind_t<R, F, L> + bind(boost::type<R>, F f, ...); +template<class F, class L> + _bi::bind_t<_bi::unspecified, F, L> + bind(F f, ...); + #endif // generic function objects

1 0

Boost Threads - x86 Platforms / 64 bits compilation in Managed/Unmanaged Code / Visual Studio 2010 / Windows SDK 7.1 /clr
by Guillaume Rembert 07 May '12

07 May '12

As I had lots of issues to include boost thread libraries in a windows 64 bits code generated under Visual Studio 2010, here are the different steps to follow in order to get it compiling and executing quickly (mix of lots of the different specific posts). I could not find an easy, up to date procedure for this. This has been tested with Boost 1_49_0 release, Visual Studio 2010, Windows SDK 7.1 and Microsoft .NET 4. - Download 64 bits libraries, as binaries: http://boost.teeks99.com/ + unzip in a dedicated folder (for the example C:\boost\lib64) - Download boost headers and source code: http://sourceforge.net/projects/boost/files/boost/1.49.0/ + unzip in a dedicate folder (for the example C:\boost) - Set the project not to use precompiled headers + compilation with /clr to mix managed and unmanaged code - Add the headers path to the project additional include directories (in the example C:\boost) - Add the compiled libraries path to the linker additional library directories (in the example C:\boost\lib64) - Add to your project the following lines (force dynamic linking): #define BOOST_ALL_DYN_LINK #define BOOST_THREAD_USE_DLL #define BOOST_LIB_DIAGNOSTIC #include <boost/thread.hpp> --> Just compile and execute, it should not give any problems. The first line (#define BOOST_ALL_DYN_LINK) solves the following error I had: An unhandled exception of type 'System.TypeInitializationException' occurred in Unknown Module. Additional information: The type initializer for '<Module>' threw an exception.

2 1

[generic] status?
by lcaminiti 06 May '12

06 May '12

Hello all, What's the status of Matt Calabrese's Boost.Generic library? I was looking at the similarities between Boost.Generic and Boost.Contract syntax, and I think the following syntax can be implemented to define concepts, concepts_maps, axioms, etc CONTRACT_CONCEPT( concept (Iterator) ( typename X ) extends( Semiregular<X> ) ( typename(MoveConstructible) reference, as typename X::reference , typename(MoveConstructible) postinc_result , requires HasDereference<postinc_result> , (reference) operator(*)(deref) ( X& ) , (reference) operator(*)(deref) ( X&& ) , (X&) operator(++)(preinc) ( X& ) , (postinc_result) operator(++)(postinc) ( X&, int ) ) ) More examples here (auto concepts, concept maps, axioms, etc): http://contractpp.svn.sourceforge.net/viewvc/contractpp/trunk/doc/html/cont… If there was real interest using this syntax to define concepts, either the syntax could replace the on of Boost.Generic or Boost.Contract could provide the syntax and then use Boost.Generic behind the scene to actually define the concepts (same as Boost.Contract now does for Boost.Parameter). What do you think? Thanks. --Lorenzo -- View this message in context: http://boost.2283326.n4.nabble.com/boost-generic-status-tp4611363.html Sent from the Boost - Dev mailing list archive at Nabble.com.

2 2

[concept] typenames vs. typedefs
by lcaminiti 06 May '12

06 May '12

Hello all, I have questions about concepts (it's related to Boost.ConceptCheckign and Boost.Generic, but it's really just about the concept syntax that was proposed and never adopted for C++11). What's the difference between typename new_type = old_type and typedef old_type new_type? Why are they both allowed? For example, what's the difference between this: auto concept HasFind < typename T > { typename key_type = typename T::key_type; // use typename typename mapped_type; std::pair<key_type, mapped_type> find ( T const&, key_type const& ); } And this: auto concept HasFind < typename T > { typedef typename T::key_type key_type; // use typedef typename mapped_type; std::pair<key_type, mapped_type> find ( T const&, key_type const& ); } Thanks a lot. --Lorenzo -- View this message in context: http://boost.2283326.n4.nabble.com/boost-concept-typenames-vs-typedefs-tp46… Sent from the Boost - Dev mailing list archive at Nabble.com.

2 2

question about C++11 guidelines
by Eric Niebler 06 May '12

06 May '12

Say I'm rewriting an existing Boost library and targeting C++11 users. I plan to ship C++03 and C++11 versions of my library side-by-side, so back-compat isn't an issue for the new code. Is there a reason to prefer using Boost's versions of utilities like enable_if, type traits, integral constant wrappers (e.g. mpl::int_), tuples, etc., over the now-standard ones? I'm leaning toward using std:: where I can, and falling back on Boost's versions only when there is a compelling reason. -- Eric Niebler BoostPro Computing http://www.boostpro.com

16 30

Latest version and status of lockfree
by Julien Nitard 06 May '12

06 May '12

Hi All, Where can I find the latest version of boost.lockfree ? There's nothing in the sandbox or the vault (it seems). The latest commit on Tim's public git repo was done more than 6 month ago. Now that atomic has been accepted, are there any roadblocks to have boost.lockfree released ? Many thanks, Julien

4 9

trac spam (was: [Boost C++ Libraries] #6866: affiliate revolution)
by Eric Niebler 06 May '12

06 May '12

Who maintains trac these days? Can we get this spammy ticket deleted? Thanks, Eric -------- Original Message -------- Subject: [Boost C++ Libraries] #6866: affiliate revolution Date: Fri, 04 May 2012 20:08:29 -0000 From: Boost C++ Libraries <noreply(a)lists.boost.org> CC: boost-bugs(a)lists.boost.org #6866: affiliate revolution ----------------------------------+----------------------------------------- Reporter: anonymous | Owner: eric_niebler Type: Tasks | Status: new Milestone: To Be Determined | Component: proto Version: Boost 1.37.0 | Severity: Cosmetic Keywords: affiliate revolution | ----------------------------------+----------------------------------------- [<link deleted> affiliate revolution] -- Ticket URL: <https://svn.boost.org/trac/boost/ticket/6866> Boost C++ Libraries <http://www.boost.org/> Boost provides free peer-reviewed portable C++ source libraries.

3 3

[polygon] Trunk write access
by Andrii Sydorchuk 05 May '12

05 May '12

I sent a message recently to the Boost owners list to get write access to the Boost trunk, but haven't got any response yet. I am going to merge lately discussed Voronoi library and some updates to the Boost.Polygon. Those are approved by the library owner: Simonson, Lucanus J. Sorry for the rush. Regards, Andrii

2 2

Red Hat Enterprise Linux Test Page
by Olaf van der Spek 05 May '12

05 May '12

Hi, This does not look right. ;) https://www.boost.org/ -- Olaf

3 2

[dynamic_bitset] Endianess and Adaption Vs Copying
by Joel 04 May '12

04 May '12

I've noticed that the dynamic_bitset seems to have endian issues. For masking out the ith bit in a block, it uses 1 shifted left by i. As a result, the bits are not consecutive. For example if the block_type is uint8_t, and we have 16 bits in the bitset, then bits are numbered: 00 01 02 03 04 05 06 07 15 14 13 12 11 10 09 08 in memory. That doesn't seem right---7th and 8th bits should be adjacent. Does anyone have suggestions for controlling this? Second, has anyone adapted dynamic_bitset to be an adaptor for an existing memory range to avoid copying? Thanks! Joel

4 9

[contract] syntax redesign
by Lorenzo Caminiti 04 May '12

04 May '12

Hello all, After a long time of inactivity for Boost.Contract, I am considering how to re-design its macro syntax to make it simpler. I can eliminate a large number of extra parenthesis based on a few pp tricks I've learned in processing Boost.Local's `const bind(type)& var`. Plus, I can provide (optional) support for variadics macros so to use comma-separated pp tuplets instead of parenthesized pp sequences on preprocessors with variadics. For example, I _think_ (but I've not implemented this yet) that I can simplify the syntax like this: #include <contract.hpp> #include <vector> #include "myvector/pushable.hpp" // Wrapper class that adds contracts to std::vector. CONTRACT_CLASS( template( typename T ) class (myvector) extends( public pushable<T> ) // Subcontracting. ) { CONTRACT_CLASS_INVARIANT( empty() == (size() == 0) // More invariants here (comma separated)... ) CONTRACT_FUNCTION( public void (push_back)( (const T&) element ) precondition( size() < max_size() // More preconditions here (comma separated)... ) postcondition( auto old_size = CONTRACT_OLDOF(size()), // Old value. size() == old_size + 1 // More postconditions here (comma separated)... ) ) { vector_.push_back(element); // Implementation. } // Rest of the class here (with more contracts if needed)... public: typedef typename std::vector<T>::size_type size_type; size_type size(void) const { return vector_.size(); } size_type max_size(void) const { return vector_.max_size(); } bool empty(void) const { return vector_.empty(); } const T& back(void) const { return vector_.back(); } private: std::vector<T> vector_; }; For a side-by-side comparison with N1962 syntax: http://svn.boost.org/svn/boost/sandbox/contract/libs/contract/doc/html/inde… For a comparison of the entire std::vector (plus Boost.ConceptCheck concepts): http://svn.boost.org/svn/boost/sandbox/contract/libs/contract/doc/html/cont… For a comparison for all Boost.Contract features (plus Boost.ConceptCheck concepts and Boost.Parameter named parameters): http://svn.boost.org/svn/boost/sandbox/contract/libs/contract/doc/html/cont… (Don't pay attention to the rest of the docs that are way out of date.) A few notes: * Extra parenthesis are still needed around class and function names. * Extra parenthesis are still needed around types (like for the parameter `(T) element`) but only if the type is not a C++ keyword (no parenthesis needed aournd int, double, void, etc) or it contains a symbol (parenthesis needed if & or * are used `(int&) x`, etc). * In postconditions, the `auto old_size = CONTRACT_OLDOF(size())` only copies the vector size (and not the entire vector :)) ). Similarly, `auto result = return` can be used to access the return value for non-void functions. (The `auto ...` is parsed by the pp and it's implemented using Boost.Typeof so no C++0x is required.) * Template declaration (but not instantiation) angular parenthesis <> are replaced by round parenthesis (). All of this _should_ be implementable in pure ISO C++. What do you think? Based on the discontent that the previous "parenthesized" syntax generated among Boosters, the key question is: Would you consider this new syntax usable?? Thanks, --Lorenzo

5 45

[Countertree + Suballocator] New Version
by Francisco José Tapia 03 May '12

03 May '12

Hi this message is to announce the new version of the [countertree + suballocator] library. You can find the zip file with the code and the documentation in https://docs.google.com/file/d/0B9lWJ1Nhb_RhRXVHSS14aGxUZjJjWFdRVC0xZ2czZw/… or if you want a quick look , you can see in my web page http://fjtapia.webs.com/works/countertree/index.html *COUNTERTREE * This library is an implementation of a binary red-black counter tree. This tree have an additional counter in each leaf. This permit the access to the elements by the position, like in a vector. It is a random access container with random access iterators . With this tree we have vectors (cntree::vector_tree) with identical interface than std::vector. The vector_tree have the same speed inserting and deleting in any position (all the operations are O(log N)).It is slower than std:vector inserting and deleting at end, but much faster for to insert and delete in any other position. With ordered information, we have in the cntree namespace the classes set, multiset, map and multimap, with identical interface than the STL classes, with the plus of access to the elements by position, like in a vector. The iterators are random access , and you can subtract two iterators in a O(log N) time for to know the number of nodes between them (even with the end( ) and rend( ) iterators) For to show the utility of this, imagine a large unordered file with the information about the employees of a big company. You have indexes implemented with multimaps, with pairs [value, position], and use the upper_bound and lower_bound functions. You need to select the employees in a range of age and weight. With the boost:multimap you can know the number of elements of the selection. In the weight query we found 100 elements and in the age query 10000 elements. To travel the elements of the weight query asking for the age, is faster than the opposite. *SUBALLOCATOR * A very hard test for the allocators are the data structures which need a very high number (several millions) of elements of the same size, like the STL list, set, multiset, map or multimap. When the number of elements grow, many allocators begin to have speed problems. The solution proposed for this problem are the custom allocators. These allocators are very fast, but many of them present additional problems related with the memory consumption. And they don't work well when they must manage many types of data. When the allocators receive the request from the program, they request memory to the Operating System, and the memory consumed by the program grows up. When the program return to the allocators the request, many allocators have problems for to return the memory freed to the Operating System (The std::allocator of GCC 4.6 don't return well the memory, and the std::allocator of Visual C++, return, but it is slower than the GCC allocator) If you use only one allocator, you have a bad management or in the speed of equal size elements, or with a wide variety of elements. If you use two allocators, the memory freed by an allocator can't be used by the other, and the memory consumption is very high, and when decrease the number of elements to manage, the memory don't decrease. These problems are specially important in two environments : a) When you have a limited resources, as occurs in the mobile phones, pads ... b) When the programs must run continuously in a multitask environment The solution is the suballocator. It is a mechanism for to manage in a fast way a greater number (hundred millions) of elements with the same size. The suballocator is a layer over the allocator (any allocator with the STL interface). The suballocator receives an allocator as template parameter. When the suballocator needs memory, request memory from the allocator, and when the memory is not used, is returned to the allocator. The suballocator present the same interface than the STL allocator. Form the view point of the data structures, the suballocator is other allocator The suballocator always return the first element free. This improve the cache performance and the speed of the data structures. This simple memory schema permit to the allocators return memory to the Operating System and decrease the memory used by the program, as demonstrate the programs in the benchmarks, and you can see in the benchmark point. With the suballocator a) We have a very *fast allocation* (3 times faster than GCC 4.6 std::allocator, 3.5 times faster than Visual Studio 10 std::allocator ) b) Return memory to the allocator, for to be used by others types of data. Many allocators, return this memory to the Operating System, and *decrease the memory used by the program * c) You *can use with any allocator* if according with the STL definition. The suballocator provides speed and memory management to any allocator. d) In the insertion in a std::set<uint64_t> , the time spent by the allocator is around 1%, but the suballocator save around 35% of time . The suballocator always provide the first position free, This provide us a very compact data are, which *improve the cache performance* All the information showed here is explained and detailed in the point Suballocator. All the information is extracted from the programs in the benchmarks folder. *COUNTERTREE + SUBALLOCATOR* The join of the two ideas provide us data structures with a suballocator built-in. They are, in the namespace cntree, the vector_tree_pool, set_pool, multiset_pool,map_pool and multimap_pool, with identical interface than the STL classes but better performance. Tray it. It fast, useful and easy to understand and use,. They are the STL classes with a few additional functions. I had checked this code with GCC 4.6 (32 and 64) , CLANG/LLVM 3.0 and Visual Studio 1010 (32 and 64). If you find any error or problem in the code , the documentation or in any other part ( as friendly do Mr Rene Rivera in the first version). Please mail me ( fjtapia(a)gmail.com) or if you mail Boost, please insert [countertree] in the head of the message. Some days I have not time to read all messages arrived to my mail, but if I see that I detect and respond first. If you have some idea, or have any comment, please mail me, always two legs run more than only one in the pursuit of the goal, to be useful to the community of programmers in the same way than our predecessors had been useful to us. Sincerely yours Francisco Tapia fjtapia(a)gmail.com

7 19