- Boost - lists.preview.boost.org

BoostCon '09 Sessions
by David Abrahams 05 Mar '09

05 Mar '09

Hartmut Kaiser and the BoostCon Program committee have done a stellar job assembling a list of sessions for this year's BoostCon, including everything from C++ compiler developer presentations, to hands-on C++0x development, to talks on eexperimental metaprogramming enhancements, to expression templates for running code on GPUs. I can honestly say I want to go to almost every session. It's going to be hard to choose. Please see the session list at: http://www.boostcon.com/program/sessions and then, of course, head on over to http://www.boostcon.com/registration to register for the conference. Best regards to all. See you there! -- Dave Abrahams BoostPro Computing http://www.boostpro.com

1 0

[serialization] string serialization
by Nikolay Mladenov 04 Mar '09

04 Mar '09

Hi, I the basic_binary_iprimitive.ipp (and I suppose other files) the size of the strings is serialized as std::size_t and not as serialization::collection_size_type. Is that intentional? Thanks, Nikolay Mladenov

4 11

Design conventions; passing functors
by Joachim Faulhaber 04 Mar '09

04 Mar '09

Hi, I am pondering about functor passing. Functors occur in my library (ITL) e.g. for the aggregation of associated values on insertion in interval_maps (aggregation on overlap): template<class Domain, class Codomain, ...> class interval_map{ ... //(1) My current implementation is this: // Combinator is the aggregating functor template, // instantiated at compiletime template<template<class>class Combinator> interval_map& add(const value_type& value_pair) { /*Combinator template passed or instantiated somewhere*/ } ... } //I like this definition, because it's abstract: // The functor has to be a matching template e.g. inplace_max interval_map<int,int> m; m.add<inplace_max>(some); //(1) template<class Domain, class Codomain, ...> class interval_map{ //(2) The more traditional definition template<class Combinator> interval_map& add(const value_type& value_pair) { /*Combinator type passed or called somewhere*/ } ... m.add<inplace_max<int> >(some); //(2) I prefer (1) but both definitions (1) and (2) are purely static denotations. To have adaptable functors or functors that can have states, like in ... m.add(some, max_under(42)); ... I am afraid I have to say sayonara to definition (1) and use this instead: template<class Domain, class Codomain, ...> class interval_map{ //(3) Adaptable functor template<template<class>class Combinator> interval_map& add(const value_type& value_pair, const Combinator<Codomain>& combine) { /*combine functor passed or called somewhere*/ } Now, there seems to be a convention from the STL that functors shall be passed BY VALUE. template<template<class>class Combinator> interval_map& add(const value_type& value_pair, Combinator<Codomain> combine); This is stated in [Sutter & Alexandrecu 2005, C++ Coding Standards] item 89: "Function objects are modeled on function pointers. Like function pointers, the convention is to pass them by value. All of the standard algorithms pass objects by value, and your algorithms should too." I do not really understand this convention and feel some resistance to follow it. In addition the call by value implementation can (and will) lead to heavy inefficiency by unaware usage of fat functors. So I browsed through some boost libraries and found that functors are passed by reference there (e.g. accumulators, fusion). Final question: What is the boost standard on passing functors, that I can adapt to? Cheers Joachim

6 20

[serialization] problems implementing free-standing functions
by Thorsten Ottosen 04 Mar '09

04 Mar '09

Hi, I'm having some annoying problems when implementing serialization for the attached class. Basically I define boost::serialization::load()/save(). I do just like done in e.g. boost.ptr_container, so I'm really confused about what's going on here. From the error message it looks like the free-standing functions are not found. Any help will be greatly appreciated. Thanks -Thorsten

3 12

[serialization] automation of class version sanity checking
by troy d. straszheim 04 Mar '09

04 Mar '09

Hey (Robert), Use case. It is possible (and does happen) that a user tries to deserialize version N+1 of a class C with software that only understands versions up to N. What typically happens is that C appears to deserialize OK, but it has eaten too many (or few) bytes from the archive. This means that the next class that gets loaded from the archive will fail in some unpredictable way. To deal with this we've started adding the following to all of our classes: struct C { double x; // this was present in version 0 double y; // this arrived with version 1 template <typename Archive> void serialize(Archive& ar, const unsigned int version); }; BOOST_CLASS_VERSION(C, 1); template <typename Archive> void C::serialize(Archive& ar, const unsigned int version) { if (version > 1) throw unsupported_version(version, 1); if (version == 0) ar & x; if (version == 1) ar & y; } ( Note the two arguments to unsupported_version ). This has the pleasant side effect of often catching errors in *other* classes. Eg if I'm trying to deserialize C and that exception is thrown, you can generate a message "trying to read version 3243856293 of class C, but I only know about version 0-1". Now I know that something has gone quite wrong, for instance someone has removed a member from my enclosing class without correctly incrementing and handling the version there, and what I've been given as 'version' is garbage. If the message is instead "trying to read version 4 of class C but I only know about versions 0-3", it looks like I simply need to update my software, nothing more sinister. This greatly simplifies these situations, which otherwise could spiral into a long, painful back-and-forth over a segfault in a serialization routine involving questions about what software the user has, where the data came from, what software was used to write it, etc. So: 1. I can't think of a situation where having file_version greater than BOOST_CLASS_VERSION isn't a catastrophic error. 1a. It'd be nice to configurably auto-check for this kind of versioning error. 2. As far as I can tell, these checks could be done cleanly inside the library, in serialize_adl() (?). 3. We don't actually use that unsupported_version exception, which takes no arguments and is thrown from serialization of variant (I wrote that and now find it confusing). I think the variant error should be specific to variant (or just totally generic), and unsupported_version should be used for the case currently under consideration... and to enable the 'pleasant side effect' above, I think the exception should carry the greatest version known to the code and the attempted-to-read version. Sanity check please, say so if you want me to try implementing... -t

2 2

Re: [boost] [optional_io] InputStreamable refinement
by Andrew Troschinetz 04 Mar '09

04 Mar '09

Just heard back from Robert, I figure it's ok to forward this information: On Feb 26, 2009, at 10:00 AM, Robert Ramey wrote: > The serialization library does no depend up optional or it's > implementation. If you > change the implemenation of optional, just make the changes > are consistent with the requirements of the serialization library. > > The fact that the serialization of optional is implemented and tested > as part of the serialization library is an anomoly. In fact, this > code and test should be moved into the optional library. I checked the optional test in the serializable library and it doesn't seem to even include optional_io.hpp. And given Robert's comments, it seems like it would be ok to make changes to optional_io.hpp. With respect to the change I suggested for operator>>() (I think in my last post I typoed and wrote operator<<(), I always get those silly things backwards!): In the case where we fail to extract optional<T>::value_type, I'm not sure what would be the best thing to do with respect to the position of the get pointer or other state bits. I had suggested this: if (in.fail () && !in.eof ()) { in.clear (); in.get (); } The intent of calling get() there is to enable this use case: stringstream sin ("one 2 three 4 five 6"); optional<int> i; while (sin >> i) { if (i) cout << "found int: " << i << endl; } // which finds 2, 4, and 6 But why move the get pointer up by one? Why one? Does this make sense? I can't provide a reasoning as to why it does, if it does. So another possibility is this: if (in.fail () && !in.eof ()) { in.clear (); in.setstate (std::ios::eofbit); } This has the added benefit of of making the following possible w/o any code change to lexical_cast: // doesn't throw, returns 0 lexical_cast<optional<unsigned> > ("-1").get_value_or (0); And if it's well documented that extracting an uninitialized optional<T> sets the eofbit on the istream, then a prudent user could (if they really wanted to) reformulate the first use case as: stringstream sin ("one 2 three 4 five 6"); optional<int> i; while (sin >> i) { if (i) cout << "found int: " << i << endl; else { sin.clear (); sin.get (); } } This leaves the why of moving the get pointer up to the user, where I think it really belongs. Because I can image some use cases where you'd want to do something other than just call get(). For example, maybe you'd want to call getline() and ignore an entire line before trying to extract another optional<T>. Or maybe you'd want to read until you found some delimiter before trying again. -- Andrew Troschinetz Applied Research Laboratories

4 9

boost versioned namespace ?
by Roland Schwarz 04 Mar '09

04 Mar '09

I am seeking advice on how I could package some of boosts libraries as part of a library I am writing. Given: "libboost_1_35" a boost lib at ver. 1_35 which is used by my "libmy". I need to be able to ship binary versions of "libmy" and "libboost_1_35". A customer writing an application "app" and using "libmy" and "libboost_1_39". The problem: libboost_1_39 and libboost_1_35 likely will have common symbols, which either prevents the customer to use 1_39 or forces me to also upgrade to 1_39 (altough everything is fine with 1_35). The questions: What would boosters recommend? Is there a way to use kind of a versioned boost namespace? Regards, speedsnail

3 4

Re: [boost] An extension to boost::variant
by Catalytic 04 Mar '09

04 Mar '09

Chris Hamilton-3 wrote: > > While boost::variant is very capable at what it does, there is one thing > it doesn't do .. > > ..My question is this: why can't boost::variant be clever about reference > data types.. > > The reason I want this, is to have a nice String variant, that > encapsulates the various forms a string can take in a current project: > std::strings, char*'s, and std::string* and > boost::shared_ptr<std::string>. I want functions to be able to handle > all of these types transparently by using variants as the argument > types. Allowing "const std::string&" as a variant type allows this to > be done while not requiring a wasteful string copy. > .. > (I have a small custom variant class implementing this, and it appears > to work well. It's not as 'full fledged' as the boost::variant class, > but the approach I've taken could surely be grafted on to boost::variant.) > > An example will be better than a lengthy explanation, please have a look at the test-cases in the boost distribution: libs/variant/test/: specially variant_reference_test.cpp IMHO, it will answer all your queries. -Cat -- View this message in context: http://www.nabble.com/An-extension-to-boost%3A%3Avariant-tp21881442p2189668… Sent from the Boost - Dev mailing list archive at Nabble.com.

5 13

Re: [boost] [math] Does any one interesting in calculating derivative for a expression automatically?
by Dongfei Yin 04 Mar '09

04 Mar '09

Hi John, 1. I have tried that if you write d(d(d(d(x*x*x*x, x), x), x), x), it will take a long compile time without optimized. I have do something to optimized it. I need to write a lot of specialized template class for most of the operators. 2. Because of the C++ grammar, I think it can just accept expression like C++ style. think about operator^, the priority is lower in C++ than in math. 3. As I said, high derivative will cost lots of compile time without "simplify", so you are right, the expression should be simplified. but at compile time, it is a little difficult to do it, but I'll do my best to optimized it. Dongfei. > Good idea, and this is all very neat, but I see a couple of issues: > > 1) Compile times for a compile time derivative is likely to be slow? > 2) Isn't it easier to just calculate the derivative within a symbolic math > package and then cut and paste the result into your code (Yacas is free for > example)? > 3) What happens for very complex expressions? Can the compile time code > simplify the resulting derivative so that it is optimally evaluated? Most > symbolic math packages will have a "simplify" function that does just that, > without it, code might be very inefficient to evaluate, with it, compile > times might be way too long :-( > > Regards, John. >

2 1

Re: [boost] [math] Does any one interesting in calculating derivative for a expression automatically?
by Dongfei Yin 04 Mar '09

04 Mar '09

Hi Mukkul, I have implement the trigonometric terms. only sin and cos. it can add new operator into it easily. this expression d(cos(_x * _x) , _x) will return a functor, at last, the computation is done by std::sin : ) Dongfei. > HI Dongfei, > > I am interested in it. But what the plan is exactly ? How you are going to do it > for say expressions involving trigonometric terms ? For polynomial expressions > things are manageable, how you are going to parse other complex expressions ? > > BTW how you are going to take care of algebra at many places ? > > With Regards, > Reetesh Mukul >

1 0

Re: [boost] [math] Does any one interesting in calculating derivative for a expression automatically?
by Dongfei Yin 04 Mar '09

04 Mar '09

Hi Kasra, I am very glad that you are interesting in it. Now, it can just calculate polynomial, and sin, cos. what should I do to upload the source? I am not so familiar with this system. Dongfei. > I think the function are rather interesting in fact I really like differential calculations with the way you have implemented it. > > If you give more information about your implementation maybe we could work something out. > > > -- Kasra >

1 0

[math] Does any one interesting in calculating derivative for a expression automatically?
by Dongfei Yin 04 Mar '09

04 Mar '09

Hi, Recently, I am working on some mathematical issues, most of my working time, I am calculating the derivative of function manually, it is such a tedious work that I write a piece of code to do it for me. now I want to share it with others. Let me show it for you. it it something like lambda expression, I mean boost::lambda. but the main purpose is to calculate derivative. As lambda do, I defined some variables like _x, _y in advance. A function named "d" can calculate derivative. then we can use it like this. d(_x * _x , _x)(1.0); // f(x)=x*x, f '(x) = 2x. so the result will be f '(1.0) = 2.0. d(d(_x * _x, _x), _x)(4.0); // f(x)=x*x, f ''(x) = 2, so the result will be f ''(4.0) = 2.0; this argument is just used to determine the return type. of cause it can work with more than one variables, such as, d(_x * _y, _x)(2.0, 1.0); // f(x,y)=x*y, f 'x(x,y)=y, so the result will be f 'x(x,y)=1.0; // the first argument will be ignored. d(d(_x * _y, _x), _y)(1.0); // f(x,y)=x*y, f ''xy(x,y)=0, so here one or two argument are all OK. and it can calculate derivative for some complicated expressions. theoretically, it can calculate high derivative for a expression as high as you want until the expression become zero. I want to share it with others, but it is not so perfect now. I need some suggestion to make it better. by the way, I am a new face, and English is not my native language, so if I did not explain some thing clearly, please do ask me. I will do my best to clarify.

5 4

[convert] Default Syntax Idea
by Stewart, Robert 04 Mar '09

04 Mar '09

I was thinking a bit about syntax for the default value for the notional boost::convert() and kin. How about the following: int const i(3); string const s("something"); int const j(convert<int>(s) | 5); convert<DestType,SourceType>(SourceType) can return a type which throws on failure in operator DestType(), but has an operator |(SourceType) which returns a second type constructed with the SourceType value. The second type provides its own operator |(SourceType) which returns that value in its operator DestType() on failure. Returning a default value in lieu of an exception is a special case; it ought not be treated like formatting. Thus, while Boost.Parameter might be appropriate to package the extra information desired for formatting, I don't like the idea of writing "default_ = 5" in the call, and I don't think ", 5" in the argument list is as clear as it could be. The syntax above is obvious and concise while being distinct from whatever may be done for formatting. _____ Rob Stewart robert.stewart(a)sig.com Software Engineer, Core Software using std::disclaimer; Susquehanna International Group, LLP http://www.sig.com IMPORTANT: The information contained in this email and/or its attachments is confidential. If you are not the intended recipient, please notify the sender immediately by reply and immediately delete this message and all its attachments. Any review, use, reproduction, disclosure or dissemination of this message or any attachment by an unintended recipient is strictly prohibited. Neither this message nor any attachment is intended as or should be construed as an offer, solicitation or recommendation to buy or sell any security or other financial instrument. Neither the sender, his or her employer nor any of their respective affiliates makes any warranties as to the completeness or accuracy of any of the information contained herein or that this message or any of its attachments is free of viruses.

9 32

[thread] thread-safe static local
by Oliver Kowalke 04 Mar '09

04 Mar '09

Hi, I need a function 'get_default_X()' returning a reference to a singleton in a multithreaded env. I choosed Scott Meyers singleton pattern (static local) together with boost::call_once(). My this be a reasonable, threadsafe implementation? regards, Oliver -- Computer Bild Tarifsieger! GMX FreeDSL - Telefonanschluss + DSL für nur 17,95 ¿/mtl.!* http://dsl.gmx.de/?ac=OM.AD.PD003K11308T4569a

5 5

Boost.Test: documenting a little Mac OS X usage nit
by Owen Smith 03 Mar '09

03 Mar '09

Greetings! I'd like to present a little tiny puzzle that took me an embarrassingly long time to solve--a year, to be specific. (OK, maybe a day poking around, followed by a year being buried in the bug queue. :-) ) With this comes a couple of requests for the Boost.Test documentation. If i understand correctly, the Boost.Test library boost_unit_test_framework is a little bit odd in that the static version of the library carries a main() routine (which I intend to take advantage of) whereas the dynamically linked version does not. In Mac OS X, with the standard MacPorts installation of boost, this poses a problem because both static and dynamic libraries are built and installed to the same location. When linking with gcc using my usual -L and -l options, given the choice, the linker will always select the dynamic library, and I will be missing my main(). (I should point out this would be a non-issue if the main() routine were in a different library that you could choose to include or not include as you wish, but I'm assuming this battle has long since been fought and resolved.) First, I know the main() issue has been mentioned many times on the list before, but I couldn't find any documentation of it in the 1.38.0 manual. This seems like a significant issue to document--am I just missing it somewhere? Second, the best workaround we found for this problem was to explicitly select the static library by foregoing the -L and -l options and directly specifying <full-path>/libboost_unit_test_framework-mt.a as one of the linker arguments. And this is what I'd like to see documented--either as a footnote to "Unit Test Framework > User's guide > Usage variants > Static library", or maybe as part of the topic "Unit Test Framework > Usage recommendations > Generic". I'm happy to prepare documentation patches if desired. Thanks! -- O

1 0

[math] Does any one interesting in calculating derivative for a expression automatically?
by Kasra 03 Mar '09

03 Mar '09

Hi, I think the function are rather interesting in fact I really like differential calculations with the way you have implemented it. If you give more information about your implementation maybe we could work something out. -- Kasra

1 0

boost::bind, problem with result type deduction and calling conventions
by Ingo.Loehken＠boc-eu.com 03 Mar '09

03 Mar '09

hi, anybody able to explain, why the code for the result type, related to special calling conventions defines an void return type ? template< class R, class T > struct add_cref< R (T::*) (), 1 > { typedef void type; }; so that code like class A { public: int __stdcall x() { return 0; } void const y() {} explicit A() { typedef boost::function<int()> fun_t; fun_t const f(boost::bind(&A::x,this)); } }; ends up with an warning at bind 1>G:\boost\boost_1_37_0\boost/bind.hpp(1643) : warning C4180: qualifier applied to function type has no meaning; ignored 1> G:\boost\boost_1_37_0\boost/bind.hpp(1682) : see reference to class template instantiation 'boost::_bi::add_cref<Pm,I>' being compiled 1> with 1> [ 1> Pm=int (__stdcall Ado::A::* )(void), 1> I=1 1> ] 1> G:\dev\workspace\files\ado\ado_bind.hxx(36) : see reference to class template instantiation 'boost::_bi::dm_result<Pm,A1>' being compiled 1> with 1> [ 1> Pm=int (__stdcall Ado::A::* )(void), 1> A1=Ado::A * 1> ] because the proposed specialization is not choosen by the compiler. Adding an __stdcall to the function signature type in add_cref fixes that problem, but still i do no understand, why the defintion is not like template< class M, class T > struct add_cref< M (__stdcall T::*) (), 1 > { typedef M const& type; }; and of course that fix is only applicable for __stdcall, where specialzations for other calling conventions can easily be generated, like for mem_fn_cc in respect to requested support for calling conventions. Thanks for your help, ILo. compiler : msvc 8.0 library : boost 1.38

2 1

Headers erased after the first building in VC8 of boost 1.38
by Trimoldi, F. (Filippo) 03 Mar '09

03 Mar '09

I generated a Boost.sln solution for VC8 with the new system CMake. ( using this command: cmake -DCMAKE_IS_EXPERIMENTAL=YES_I_KNOW CMakeLists.txt in root directory of the boost ) When I try to build the entire solution all thinks goes good without problem. But only the first time. In fact, at the end of this first building all the headers are erased from the boost the directory. So I cannot make another building and I have to recover the headers file by other ways. Have you got the same problem? This e-mail and its contents are subject to the DISCLAIMER at http://www.tno.nl/disclaimer/email.html

2 1

[Review] Reminder: Boost.RangeEx review is going on
by Thorsten Ottosen 02 Mar '09

02 Mar '09

Dear Developers and Users, The review of Neil Groves' RangeEx library lasts until March 3, 2009. Please find the time to do a review if you are interested in this library. The discussion so far may be found here: http://archives.free.net.ph/message/20090220.122836.73bdbd04.en.html Below you will find a description of the library and information on how to write a review. best regards Thorsten, review manager What is it? +++++++++++ The library provide two very useful extensions to the range library 1. Range-based algorithms. E.g. boost::sort( rng ); which is a convenient wrapper of instead of std::sort( boost::begin(rng), boost::end(rng) ); But the new interface also allows for more expressive code because (on the fly) composition of algorithms suddenly is possible. 2. Range adaptors. E.g. std::vector<int> vec = ...; boost::copy( vec | boost::adaptors::reversed, std::ostream_iterator<int>( std::cout ) ); where the expression "vec | boost::adaptors::reversed" wraps the iterators of the range on the left in reverse iterators. The library provides a wide range (no pun intended) of Range adaptors, and they are a powerful way to create ranges on the fly and pass them to algorithms. Getting the library +++++++++++++++++++ The library may be downloaded from http://www.cs.aau.dk/~nesotto/boost/range_ex.zip or from the Boost vault under "Algorithms". The docs may be browsed online here http://www.cs.aau.dk/~nesotto/boost/libs/range/ Please note that the documentation is integrated with the current Range ilbrary. Therefore the relevant sections for the review is http://www.cs.aau.dk/~nesotto/boost/libs/range/doc/adaptors.html and http://www.cs.aau.dk/~nesotto/boost/libs/range/doc/algorithms.html The code may be browsed here: http://www.cs.aau.dk/~nesotto/boost/boost/range/ Notice the library is header only (exception: the adaptor tokenized() depends on Boost.Regex). 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 ++++++++++++++++++++++ Various RangeEx like libraries have been implemented in the past. You might want to compare with those libraries when you form your oppinion: 1. John Torjo's range lib http://rangelib.synesis.com.au/libs/boost-rangelib-20040913.zip http://torjo.com/rangelib/index.html 2. Adobe's ASL libraries include range-based algorithms: http://stlab.adobe.com/group__algorithm.html I'm looking forward to your review. best regards Thorsten, Review Manager

4 5

[threadpool] parallel_sort example
by vicente.botet 02 Mar '09

02 Mar '09

Hi, I have implemented a parallel sort with the threadpool library (version 21 http://tiny.cc/HVOOa )+patch to have tp::task default constructibe, and the Boost.Range reviewed currently. (attached the test file). Well a have implemented a generic algorithm that should works to other partition and compose problems. template < typename DirectSolver, typename Composer, typename AE, typename Range > void inplace_solve( AE & ae, boost::sub_range<Range> range, unsigned cutoff ); template < typename DirectSolver, typename Composer, typename AE, typename Range > void inplace_solve( AE & ae, boost::sub_range<Range> range, unsigned cutoff) { unsigned size = boost::size(range); if ( size <= cutoff) DirectSolver()(range); else { partition<Range> parts(range, BOOST_PARTS); task_type tasks[BOOST_PARTS]; for (unsigned i=0;i < BOOST_PARTS-1; ++i) { task_type tmp(ae.submit( boost::bind( &inplace_solve<DirectSolver,Composer,AE,Range>, boost::ref(ae), parts[i], cutoff ))); tasks[i] = tmp; } inplace_solve<DirectSolver,Composer,AE,Range>(ae, parts[BOOST_PARTS-1], cutoff); for (unsigned i=0;i < BOOST_PARTS-1; ++i) { tasks[i].wait(); }; Composer()(range); } } struct sort_fct { template<class RandomAccessRange> RandomAccessRange& operator()(RandomAccessRange rng) { return boost::sort(rng); } }; struct inplace_merge_fct { template<class BidirectionalRange> BidirectionalRange& operator()( BidirectionalRange rng) { return boost::inplace_merge(rng, boost::begin(rng)+(boost::size(rng)/2)); } }; // this implementation mask the ThreadPool. template <typename Range> void parallel_sort(Range& range, unsigned cutoff=10000) { pool_type pool( boost::tp::poolsize( 2) ); boost::sub_range<Range> rng(boost::begin(range), boost::end(range)); inplace_solve<sort_fct,inplace_merge_fct,pool_type,Range>( pool, rng, cutoff); } The differences in time on my computer are not too good. The sort has been done on a reversed container and the container sorted for 400000 elements parallel_sort xxx: where xxx is the cutoff parameter with BOOST_PARTS=2 std::sort: reverse 0..400000 37 milli seconds std::sort: 0..400000 35 milli seconds boost::sort: reverse 0..400000 38 milli seconds boost::sort: 0..400000 34 milli seconds parallel_sort 200000: reverse 0..400000 24 milli seconds parallel_sort 200000: 0..400000 24 milli seconds parallel_sort 100000: reverse 0..400000 28 milli seconds parallel_sort 100000: 0..400000 26 milli seconds parallel_sort 50000: reverse 0..400000 31 milli seconds parallel_sort 50000: 0..400000 29 milli seconds parallel_sort 25000: reverse 0..400000 32 milli seconds parallel_sort 25000: 0..400000 34 milli seconds parallel_sort 12500: reverse 0..400000 37 milli seconds parallel_sort 12500: 0..400000 34 milli seconds My computer has only two cores. I expected that with a cutoff of 50.000 we will have a better time that withh a cutoff of 200.000. Could someone having access to a computer with more cores run the test in order to compare the results I have also implemented parallel_sort without masking the pool template <typename AE, typename Range> void parallel_sort(AE& ae, Range& range, unsigned cutoff=10000) { boost::iterator_range<typename boost::range_iterator<Range>::type> rng(range); inplace_solve<sort_fct,inplace_merge_fct,pool_type,Range>( ae, rng, cutoff); } and in this case we win ~3 mili seconds for the creation of the Thread Pool. std::sort: reverse 0..400000 37 milli seconds std::sort: 0..400000 35 milli seconds boost::sort: reverse 0..400000 36 milli seconds boost::sort: 0..400000 34 milli seconds parallel_sort 200000: reverse 0..400000 27 milli seconds parallel_sort 200000: 0..400000 23 milli seconds parallel_sort 100000: reverse 0..400000 29 milli seconds parallel_sort 100000: 0..400000 27 milli seconds parallel_sort 50000: reverse 0..400000 29 milli seconds parallel_sort 50000: 0..400000 30 milli seconds parallel_sort 25000: reverse 0..400000 31 milli seconds parallel_sort 25000: 0..400000 29 milli seconds parallel_sort 12500: reverse 0..400000 32 milli seconds parallel_sort 12500: 0..400000 27 milli seconds This let me think that the application should not create ThreadPools for specific algorithms, but use a default one. The V21 of Boost.ThreadPool provide a boost::this_task::get_thread_pool<pool_type>(), but this function works only if called from a task. It should be great if the Boost.ThreadPool provided a default pool which could be recovered with this function on threads that are not worker threads of a ThreadPool. Otherwise the application is forced eother to add a parameter to all the functions or define its own default thread pool statically. Oliver you are free to take this as example for the ThreadPool documentation, if you consider this can improve the understanding of what can be done with your library. Best, Vicente

4 8

N2346 - Defaulted and Deleted Functions emulation
by vicente.botet 02 Mar '09

02 Mar '09

Hi, is there an interest in a N2346 - Defaulted and Deleted Functions emulation http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm The idea been to use some macros that will use the =default, =delete if the compiler provides it and replace this macros by whatever has the same semantics. Alexandrescu introduced already two macros NON_ALIAS and NON_HEAP_ALLOCATED when talking about strict locks. Attached a draft for the default and deleted functions. Only one remark the macors must be used on the public part and without trailing ';', e.g. class X { BOOST_NEW_DELETE(X) Any coments are welcome, Vicente

3 6

Re: [boost] [utility] new auto_buffer class --- RFC
by Felipe Magno de Almeida 02 Mar '09

02 Mar '09

On Mon, Mar 2, 2009 at 3:46 PM, Daniel Hulme <st(a)istic.org> wrote: > On Mon, Mar 02, 2009 at 03:21:58PM -0300, Felipe Magno de Almeida wrote: >> is rarely what the user wants. I wanted auto_buffer to be a SBO class with >> a STL interface. > > Neither Google nor Wikipedia know what you mean by "SBO". (I'm guessing > it's not Small Bowel Obstruction.) Could you clarify this term in your > next post to the list, please? Sorry, It means Small Buffer Optimization. Regards, -- Felipe Magno de Almeida

1 0

[geometry] gtl review pre-announcement
by Tom Brinkman 02 Mar '09

02 Mar '09

I'm doing a session at boostcon about GIL and making a bunch of examples, including some about GTL. You can include those as part of your unit test cases if you like. //Tom

3 2

RPC library in the sandbox
by Jon Shuler 02 Mar '09

02 Mar '09

Does any know if the author(s) of this library are still around and plan to make any more updates to it? Jon

2 1

[config] borland/codegear problems with C++0x macros
by Beman Dawes 01 Mar '09

01 Mar '09

* trunk/boost/config/compiler/borland.hpp: It looks like John Maddock and I independently added C++0x macros. The resulting inconsistencies need to be reconciled. The BOOST_CODEGEAR_0X_SUPPORT macro doesn't appear to be documented, by the way. John, do you want to take a whack at this? * trunk/boost/config/compiler/codegear.hpp: Doesn't have the negative C++ macros yet. I'd like to borland.hpp finished before trying to do codegear.hpp. Thanks, --Beman

2 2