August 2010 - Boost - lists.boost.org

[fusion] [intro] ADAPT_STRUCT extensions
by Stefan Strasser 04 Oct '10

04 Oct '10

Hi, in the discussion about the library I called "Intro" at the time it has been suggested to use BOOST_FUSION_ADAPT_STRUCT of Boost.Fusion for data member access. based on that I'd like to propose two extensions to ADAPT_STRUCT, which I think are useful beyond my use case: 1) ADAPT_STRUCT can adapt public data members only. with the modifications I uploaded here: http://svn.boost.org/svn/boost/sandbox/intro/boost/fusion/adapted/struct/ all data members can be adapted. for example: class A{ private: friend class fusion::access; int a; }; BOOST_FUSION_ADAPT_STRUCT(A,(int,a) ) 2) adaption of a class including its base class members. for example: struct A{ int a; }; struct B{ int b; }; struct C : A,B{ int c; } BOOST_FUSION_ADAPT_STRUCT(A,(int,a) ) BOOST_FUSION_ADAPT_STRUCT(B,(int,b) ) BOOST_FUSION_ADAPT_DERIVED( C, (A)(B), (int,c) ) an instance of C is now a fusion sequence of size 3. http://svn.boost.org/svn/boost/sandbox/intro/boost/fusion/adapted/struct/ad… private inheritance is supported as above, virtual inheritance is not. I'm not sure if virtual inheritance can be supported.

8 30

[thread] Memory leak in Boost.Thread?
by Denis Arnaud 03 Oct '10

03 Oct '10

Hello, a Fedora user has reported a potential memory leak in Boost.Thread (see https://bugzilla.redhat.com/show_bug.cgi?id=627875 for details), detected with Valgrind in (at least) versions 1.41.0 and 1.44.0. Following is a code snippet allowing to reproduce the issue: ==================================== #include <boost/thread.hpp> void someWork() { double a; for(int i= 0;i< 1000;i++) { a+=log((double)i); } } int main() { for(int i = 0; i< 10; ++i) { boost::thread_group pool; for(int j = 0; j< 100; ++j) { pool.create_thread(someWork); } pool.join_all(); } } ==================================== Then, following is Valgrind's report: ==================================== ==6442== Memcheck, a memory error detector ==6442== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al. ==6442== Using Valgrind-3.5.0 and LibVEX; rerun with -h for copyright info ==6442== Command: ./boost_leak ==6442== ==6442== ==6442== HEAP SUMMARY: ==6442== in use at exit: 8 bytes in 1 blocks ==6442== total heap usage: 5,967 allocs, 5,966 frees, 701,720 bytes allocated ==6442== ==6442== 8 bytes in 1 blocks are still reachable in loss record 1 of 1 ==6442== at 0x4C2615D: malloc (vg_replace_malloc.c:195) ==6442== by 0x4E3F989: boost::detail::get_once_per_thread_epoch() (in /usr/lib64/libboost_thread-mt.so.1.44.0) ==6442== by 0x4E39923: ??? (in /usr/lib64/libboost_thread-mt.so.1.44.0) ==6442== by 0x4E39BC8: boost::detail::get_current_thread_data() (in /usr/lib64/libboost_thread-mt.so.1.44.0) ==6442== by 0x4E3A528: boost::this_thread::interruption_enabled() (in /usr/lib64/libboost_thread-mt.so.1.44.0) ==6442== by 0x4E3A548: boost::this_thread::disable_interruption::disable_interruption() (in /usr/lib64/libboost_thread-mt.so.1.44.0) ==6442== by 0x404DC4: boost::shared_mutex::lock() (in /tmp/boost_leak) ==6442== by 0x40588D: boost::lock_guard<boost::shared_mutex>::lock_guard(boost::shared_mutex&) (in /tmp/boost_leak) ==6442== by 0x405DB5: boost::thread* boost::thread_group::create_thread<void (*)()>(void (*)()) (in /tmp/boost_leak) ==6442== by 0x403B91: main (in /tmp/boost_leak) ==6442== ==6442== LEAK SUMMARY: ==6442== definitely lost: 0 bytes in 0 blocks ==6442== indirectly lost: 0 bytes in 0 blocks ==6442== possibly lost: 0 bytes in 0 blocks ==6442== still reachable: 8 bytes in 1 blocks ==6442== suppressed: 0 bytes in 0 blocks ==6442== ==6442== For counts of detected and suppressed errors, rerun with: -v ==6442== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 6 from 6) ==================================== Is that really a memory leak? Kind Regards Denis

3 5

Interest in specialized types
by Henning Basold 28 Sep '10

28 Sep '10

Hello, in http://permalink.gmane.org/gmane.comp.lib.boost.devel/207794 Robert Ramey talked about wrapping some POD to increase type safety. Some time ago I used something similar to ensure that misuse of values can be found by the compiler. So I think that is something that can be generalized. The concept is to wrap a type into a class and restrict the interface. This ensures that values from one context (e.g. an id) can't be used in another context (e.g. adding of number or as an id for other objects). Attached is a very simple implementation where the needed concepts can be specified as parameter. To distinguish for example between different id types also a tag type can be specified. Do you think this might be a useful utility? Or is there something similar already available? I've searched the vault but did not find anything. Regards Henning

5 11

[Boost-users] [BGL] Stoer–Wagner min-cut algorithm
by Daniel Trebbien 26 Sep '10

26 Sep '10

> The usual idiom for that in BGL algorithms is to use an > iterator_property_map on the graph's vertices, built using a vector and > indexed by the vertex_index property map of the graph. You can also use a > shared_array_property_map, which manages its storage internally. If you > are doing a generic algorithm, the logic to manage these maps correctly is > somewhat difficult. One place to look for a template of what to do is the > distance map handling at the bottom of > <boost/graph/dijkstra_shortest_paths.hpp>, particularly > dijkstra_shortest_paths() and detail::dijkstra_dispatch1(). The basic > logic is to look at the named parameter structure that the user passes is > and see if there is an assignment map there. If so, use it; otherwise, > look for a vertex_index map in the named parameter structure, defaulting > to get(vertex_index, g), then use the found vertex_index map to create an > iterator_property_map or shared_array_property_map. Now that compilers > are more compliant, there are probably simpler ways to implement the logic > than to use multiple dispatch functions, but the approach in > dijkstra_shortest_paths.hpp is known to work. > > When you get this algorithm done, you may want to contribute it to BGL to > be added to Boost. We are always interested in new algorithms. > > -- Jeremiah Willcock Hello Jeremiah, I would very much like to contribute my implementation of the Stoer–Wagner min-cut algorithm to BGL. In preparation for this, I have attached a "pre-release" version to this e-mail which has everything needed to build the test case with g++ and GNU Make. Before I add in all of the template code to support "default" template parameters and other niceties, I figured that it would be good to have a review of the code to make sure that I am headed in the right direction. Also, I have tested my code against the example from Stoer & Wagner (1997). It appears to be working correctly, but there might be bugs. I think that it would be good to have more testing. Would someone please review my code? Also, is anyone aware of good examples for testing min-cut implementations? Daniel

4 57

[serialization] feedback on a possible port of the XML archive grammar to Qi
by Bryce Lelbach aka wash 22 Sep '10

22 Sep '10

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 I've recently started working on porting Boost.Serialization's XML parser from Spirit Classic to Spirit Qi (I've got some free time on my hands, and I heard that there was some interest in this task). Before I start putting more time into this, I'd love to get some feedback/suggestions and make sure someone else isn't already working on this. My understanding is that porting the parser from Spirit Classic to Spirit Qi will not only speed up XML serialization, but would also increase portability (on some compilers, Serialization only works with Spirit 1.6, which is not shipped with the latest Boost release). My current plan is to rewrite the grammar in Qi, and modify the existing XML archive classes to use the new parser without changing the interface or the outputted XML. - Bryce Lelbach -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.9 (GNU/Linux) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/ iEYEARECAAYFAkx9e9oACgkQO/fqqIuE2t4IRwCdGOUqHtLhWeVIK3ruTipf4jHu +j8AoIP7CUssPlkBpLTWLHYRcPls0/ZJ =ki/H -----END PGP SIGNATURE-----

2 11

[Review] Formal Review: Boost.Move
by OvermindDL1 19 Sep '10

19 Sep '10

Greetings Boost Developers and Users, It's my pleasure to announce that the review of Ion Gaztañagas' Move library starts May 10th and lasts until May 24th, 2010, unless an extension occurs. What is it? =========== The Boost.Move library would supply an emulated C++1x Move semantics interface, aka RValue References, allowing for a wide variety of easy to use and easy to add in optimization abilities. The most used function it would add would be: val_b = boost::move( val_a ); Which would move val_a to val_b; val_a should not be used after this line. This semantic allows for a vast amount of optimizations, especially in regards to temporaries, see the documentation for further examples and use. Other patterns emulated are && rvalue references for functions/members and constructors. There are also a number of STL containers in the sandbox that support move semantics using this library for higher efficiency. Getting the library =================== The latest version of this library may be downloaded from SVN: http://svn.boost.org/svn/boost/sandbox/move/ and the docs may be viewed here Docs: http://igaztanaga.drivehq.com/libs/move/doc/html/index.html and do note, this library is header-only and is designed to be absolutely generic to be useful in all areas of C++ programming. Writing a review ================ If you feel this is an interesting library, then please submit your review to the developer list (preferably), or to the review manager. Here are some questions you might want to answer in your review: - What is your evaluation of the design? - What is your evaluation of the implementation? - What is your evaluation of the documentation? - What is your evaluation of the potential usefulness of the library? - Did you try to use the library? With what compiler? Did you have any problems? - How much effort did you put into your evaluation? A glance? A quick - reading? In-depth study? - Are you knowledgeable about the problem domain? And finally, every review should answer this question: - Do you think the library should be accepted as a Boost library? Be sure to say this explicitly so that your other comments don't obscure your overall opinion. Special considerations ====================== If you want or need a primer on the subject, please look at the working draft for C++1x. This linked site has also been shown to be quite useful in describing move usefulness: Want Speed? Pass by Value.: http://cpp-next.com/archive/2009/08/want-speed-pass-by-value/ Move It With Rvalue References: http://cpp-next.com/archive/2009/09/move-it-with-rvalue-references/ And there are further links in that series, but those two will get you started in the domain. Best regards, OvermindDL1, Review Manager (Boost.Move)

15 78

[local_function] any interest in a LocalFunction library?
by Lorenzo Caminiti 17 Sep '10

17 Sep '10

Hello all, Is there interest in a library that implement local functions for C++? Boost.LocalFunction (PROPOSAL DRAFT) This library allows to define and invoke a function locally within a code block. In addition to the parameters that can be passed to the function as usual upon its invocation, any variable within scope can be /binded/ to the local function declaration and used by the local function definition code. MOTIVATING EXAMPLE Consider the following example: #include <boost/local_function.hpp> class c { public: c(double const& x): x_(x) {} void f(double& x) { double y = x * 10.0; bool r; { double z = x * 100.0; // Local function definition. BOOST_LOCAL_FUNCTION( (bool) (l)( (char* const)(a) // Usual non-binded param. (bool)(b) // Another usual non-binded param. (binded)( (&x) // Binded param by reference. (const& x_) // Binded param by const reference. (y) // Binded param by value (copy). (const z) // Binded param by const value (copy) (const this) // Binded const object (by pointer). // (this) // Or, binded non-const object. ) ) ) { // Use `this_` here (not `this`) to access binded object. assert( this_->eq(x_) ); ... // Local function definition code. } BOOST_LOCAL_FUNCTION_END // Local function call only specifies non-binded params. bool r1 = BOOST_LOCAL_FUNCTION_CALL(l)("hello", true); bool r2 = BOOST_LOCAL_FUNCTION_CALL(l)("bye", false); r = r1 || r2; } // Local function goes out of scope here. ... } bool eq(double const& x) const { return x_ == x; } private: double x_; }; Note the following: 1) The local function `l` is only defined locally within a code block of the function `f`. 2) The parameter `x` of the function `f`, the member variable `x_`, the local variables `y` and `z`, and the object `this` are binded to the declaration of the local function. Therefore, they can all be used by the local function definition code even if they are not explicitly passed to the local function when it is invoked. (Also note that the binding syntax conveniently does not require the user to specify the types of the binded parameters but just their /binding-qualified/ names.) 3) The local function can be invoked (multiple times) from within the scope of its declaration. As usual, each invocation specifies the non-binded parameters and, for non-void functions, it returns the function result value. BACKGROUND I have not yet implemented Boost.LocalFunction. I will be implementing local-function features as part of Boost.Contract development (in order to support constant-correct block invariants and loop variants). I am probing for interest to understand how much effort I shall invest in making the local-function features a standalone library like Boost.LocalFunction separated from Boost.Contract. On Thu, Apr 15, 2010 at 7:02 PM, Alexander Nasonov <alnsn(a)yandex.ru> wrote: > vicente.botet wrote: >> VBE> Boost.ScopeExit showed a technique that can be used to >> emulate local functions. Alexander proposed long time ago to provide >> it independently from ScopeExit but to my knowledge this has not >> been done. > > Sorry for the late reply, I'm not following every boost thread, I got > this message via google alerts. > > Yes, this has not been done. Local function can borrow argument > binding syntax from ScopeExit but there are other things I need to think > of. For instance, in > > int BOOST_LOCAL_FUNCTION(f, > (BOOST_LOCAL_FUNCTION_BIND( (a)(&b) ), int c)) { > // ... > } BOOST_LOCAL_FUNCTION_END > > syntax, is there any way to shorten BOOST_LOCAL_FUNCTION_BIND to "bind"? > > The syntax doesn't have to be exactly as above. If someone could > take a lead on this it would be great. I don't have time for this, > I'm afraid. The Boost.LocalFunction implementation will largely rely on parameter binding techniques similar to the ones currently used by Boost.ScopeExit as suggested to me by Steven Watanable, Vicente Botet, and Alexander Nasonov. Thank you. -- Lorenzo

9 35

Any interest in dynamic dispatching mechanism from "interface" to template functions ?
by Raffi Enficiaud 16 Sep '10

16 Sep '10

Hello all, The idea behind is not new and consists in dispatching a call of an interface function to the correct template instance, depending on the runtime or compile time parameters. The field of application is (to me) the release of static/dynamic libraries including functions with a predefined set of types combination. This way, the library (compiled once) can easily be plugged to another framework or a script program (I personally use it with boost.python). An example of use could be (general idea, not a real code of course): // -------------- template <class real_type> int template_function(real_type const& r_class1, double param_d, int& param_out) { // ... return 0; } int interface_function(MyInterface const* i_class1, variant const& param, variant& out) { // return value int return_value; // constructs the dispatcher object with a reference to the values passed to interface_function dispatcher<int, MyInterface const*, variant const&, variant&> dispatch_object(return_value, i_class1, param, out); bool res = dispatch_object.calls_first( fusion::vector_tie( template_function < class_t1 >, template_function < class_t2 > //... ) ); if(res) return return_value; return -1; } // -------------- The dispatch_object tests for the convertibility of each instance ui of the arguments Ui of the interface function, with the corresponding argument Ti of the template function. The type of matching is defined by external objects, with a simple interface providing two methods: a convertibility test and a conversion. The types are "cleaned" in order to have a limited number of conversion structures. Currently this mechanism is used in a generic image processing library. The images have all the same virtual interface and the dispatch calls the correct template function based on the concrete type of the image. It also includes a "back conversion" for Ui's that are non-const reference or pointers. The dispatch mainly makes use of boost.fusion, boost.mpl and boost.function_types. I have checked a little bit the Boost.Vault but, correct me if I am wrong, the current dispatching mechanisms do not address exactly this issue. The code is already open-source released under the boost license. I can put some samples in the Vault if there is any interest. Your comments are very welcome ! Kind regards, Raffi Enficiaud

4 11

[array] Invalid data: accessing 'elems'
by Mateusz Loskot 06 Sep '10

06 Sep '10

Hi, I compile a small test program using Visual C++ 10.0 (Visual Studio 2010 Premium) with static code analysis turned on (option /analyze): #include <boost/array.hpp> int main() { typedef int T; // short, char, etc. boost::array<T, 2> x; T a = x[0]; } and whichever integer type I use for T, the analyser throws similar reports every time: 1>------ Build started: Project: boost_array_test, Configuration: Debug Win32 ------ 1> boost_array_test.cpp 1>g:\workshop\boost\boost_test\array\boost_array_test.cpp(5): warning C4189: 'a' : local variable is initialized but not referenced 1>g:\dev\boost\_svn\trunk\boost\array.hpp(111): warning C6385: Invalid data: accessing 'elems', the readable size is '8' bytes, but '12' bytes might be read: Lines: 110, 111 1> G:\dev\boost\_svn\trunk\boost/array.hpp(109) : while compiling class template member function 'int &boost::array<T,N>::operator [](boost::array<T,N>::size_type)' 1> with 1> [ 1> T=int, 1> N=0x2 1> ] 1> boost_array_test.cpp(4) : see reference to class template instantiation 'boost::array<T,N>' being compiled 1> with 1> [ 1> T=int, 1> N=0x2 1> ] 1> boost_array_test.vcxproj -> G:\workshop\boost\boost_test\array\Debug\boost_array_test.exe ========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ========== Shall I report a ticket? No warnings are reported for the std::array provided with Visaul C++ 10.0. Best regards, -- Mateusz Loskot, http://mateusz.loskot.net

2 3

[multi_index] Multi-Index as fast running median solver
by Ryan Fogarty 05 Sep '10

05 Sep '10

I'm hoping to use multi-index' ordered_index (non-unique) to do a fast running median. Given a set of M numbers and a window size of N compute the medians (for each of M - N + 1 solutions). Here is my solution: template<typename T> class FastMedianSolver { private: // boost::multi_index does most of the heavy lifting for this FastMedianSolver. // This index is given both "sequence" and "tree" semantics. typedef typename boost::multi_index_container< T,indexed_by<sequenced<>,ordered_non_unique<identity<T> > > > SortedList; typedef typename SortedList::template nth_index<0> SeqIndex; typedef typename SeqIndex::type SIndex; typedef typename SortedList::template nth_index<1> TreeIndex; typedef typename TreeIndex::type TIndex; SortedList mQueue; const size_t mSize; const size_t mHalfSize; public: typedef typename SIndex::iterator iterator; /** * Create a FastMedianSolver with queue size as argument * * @param size - size of the queue. */ // Note: fast divide by 2 is: X >> 1 FastMedianSolver(size_t size) : mSize(size), mHalfSize(size >> 1) {} /** * insert a value into the median queue */ void insert(const T& value) { mQueue.push_front(value); if(mQueue.size() > mSize) mQueue.pop_back(); } /** * Get the median for the elements within the queue. Note: * the algorithm requires a full queue, o.w. may throw an exception. */ const T& getMedian() { // Ensure queue is filled up before we ask for median! assert((mQueue.size() >> 1) == mHalfSize); typename TIndex::iterator tNdx(mQueue.get<1>().begin()); // Now grab the median element // Note that unfortunately the root() node is not exposed so the only way to get the central node // is to iterate to it :( (this will incur a O(N) operation on this function which is a little unfortunate for(int i = 0; i < mHalfSize; ++i,++tNdx); // This would be better if it were available and accurate! // typename TIndex::iterator tNdx(mQueue.get<1>().beginAtRoot()); // TODO: Check if we need to average the output of 2 positions if mSize is even return *tNdx; } }; Note, that to get to the central node I just iterate the ordered list half way through set: for(int i = 0; i < mHalfSize; ++i,++tNdx); However, what I was hoping was that I could get the root node directly. ordered_index doesn't expose an iterator to root() so I put it in ordered_index.hpp as: iterator beginAtRoot(){return make_iterator(root());} However, this isn't working out because the tree isn't always balanced. My question is 2-fold is there any way to force the internal red-black tree to stay balanced; and secondly, would that have an appreciable performance penalty. Thank you, Ryan

2 1