March 2011 - Boost - lists.boost.org

[context review] Review starts next Monday, Mars 21st
by Vicente BOTET 20 Mar '11

20 Mar '11

Hi all, The review of Oliver Kowalke Context library starts next Monday Mars 21st 2011, and will end on Mars 30th. Boost.Context is a basic building block library that is used for more higher abstractions. It is used by Boost.Fiber, Boost.Tasklet and Boost.Task from the same author. I really hope to see your vote and your participation in the discussions on the Boost DEVELOPMENT mailing lists! Please use [context review] as prefix of your post to make easier the review follow up. You can already download a frozen version for the review from the Vault, TinyURL: http://tinyurl.com/5r77rel or --------------------------------------------------- About the library: Boost.Context provides a possibility to switch between different user-level context and is intended to be the basis for a higher abstraction like coroutine and fiber. A user-level context represents the current execution state, including all registers and CPU flags, the instruction pointer, the stack pointer. boost::context encapsulates such a user-level context and is able to store/restore its associated user-level context. This allows multiple execution paths running on a single thread using a sort of cooperative scheduling (in contrast a thread is preemptively scheduled) - the running boost::context decides explicitly when its yields to allow another boost::context to run (user-level context switching). A context can only run on a single thread at any point in time but may be migrated between thread. A context switch between threads costs usually thousands of CPU cycles on x86 compared to a user-level context switch with few hundreds of cycles. Boost.Context differes to setjmp()/longjmp() in the fact that the C99 standard does not require that longjmp() preserves the current stack frame, e. g. jumping into a function which was exited via a call to longjmp() is undefined. Boost.Context allows to select the mechanism provided by the operating system (ucontext on UNIX, Windows Fibers on Windows) or a faster implementation provided by this library (fcontext using assembler). --------------------------------------------------- Please always state in your review, whether you think the library should be accepted as a Boost library! Additionally please consider giving feedback on the following general topics: - 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? Regards Vicente Review Manager

2 1

Status of boost-build at sourceforge?
by Steve M. Robbins 19 Mar '11

19 Mar '11

Hi, The Boost Sourceforge project has a bunch of directories that appear un-maintained. The following are all a year or more old; are they still relevant? boost-jam 2010-03-22 707,245 downloads boost-build 2007-10-01 174,174 downloads boost-subparts 2006-11-09 In particular: Debian has packages based on boost-build, but I'm not sure really if these 3-year old files have any value today. Do they? Thanks, -Steve

1 0

GSOC: concept_traits
by Vicente Botet 19 Mar '11

19 Mar '11

Hi, Now that we will have operator traits with the reviewed library and member traits macros with Boost.TTI, it left just to define the traits for the concepts/requirements of standard library and why not some boost libraries. This would completely resurrect the abandoned ConceptTraits library. Could be this an acceptable subject for GSOC? Thanks, Vicente -- View this message in context: http://boost.2283326.n4.nabble.com/GSOC-concept-traits-tp3388859p3388859.ht… Sent from the Boost - Dev mailing list archive at Nabble.com.

2 3

[1.47] New libraries
by Daniel James 19 Mar '11

19 Mar '11

As far as I'm aware, there are three new libraries intended for 1.47 - chrono, ratio and geometry. Any others? Daniel

13 19

[Review] Boost.Type Traits Extension by Frederic Bron
by Edward Diener 19 Mar '11

19 Mar '11

This is my review of the Boost Type Traits Extension by Frederick Brron. * What is your evaluation of the design? The design is very straightforward, and easy to use. Although I do not anticipate the need to check the return from the operator traits I am glad that is part of the library. The only suggestion I would like to make regarding the design is in the default argument for the return value, which tells the implementation not to check for the return value. While it is wildly improbable that any user of the operator traits would actually want to have a trait whose return is actually 'void', it is still theoretically possible. Therefore I think that the default for the return value, which means to not check for the return value, should be an unspecified marker type in the type_traits::detail namespace. It is a convention of all Boost libraries that any library's detail namespace is to be used only by the implementation of that library and not by a user of that library. So using an unspecified marker type in the type traits detail namespace should be fine. * What is your evaluation of the implementation? I did not look at the source code. I do have a large reservation from reading the documentation, so let me explain it now. The ideal situation when using template metaprogramming constructs, such as the type traits operators metafunctions, is that an instantiation of the metafunction should never produce a compiler error. This is particularly true of metafunctions which return a boolean constant value, since the boolean value can encapsulate the notion of true or false when using the metafunction based on input types. Of course it may be the nature of C++ that this ideal situation can not be met. But then the user of the metafunction has to be able to instruct his end-users about whatever limitation exists and make allowance for it. In the type traits operators library there are documented two major situations where the use of a type will produce a compiler error and not just a false boolean constant value. This is a painful situation. I realize these two situations are fully documented in the "Known Issues" area of the Operator Type Traits documentation. But now let us take a look at the template metaprogrammer who wishes to use some subset of the type traits operators in his own library based on a type his end-user may pass to him. What this programmer wishes to do is to use a type traits operator if a type passed to him supports it, otherwise not use the operator at all. Unfortunately the end-user of that library passes a type which may or may not support such functionality, not knowing that the type will trigger a compiler error because the type traits operators are being used internally and some known issues exist which that type encompasses. What that template metaprogrammer must then do is to add another template parameter to his template, and documentation which explains to his end-user the specific situations whch trigger compiler errors in the type traits operators, that if a type is being passed which could cause the type traits compiler error conditions he must set this other parameter to false so that the compiler error can be avoided. This is a difficult way to program metafunctions successfully. So it is very disappointing that these "Known Issues" exist and it would be very worthwhile if a way could be found around them, by something different in the internal implementation, if that were possible. * What is your evaluation of the documentation? The documentation is thorough and complete. * What is your evaluation of the potential usefulness of the library? I think it is very useful. * Did you try to use the library? With what compiler? Did you have any problems? Tested with VC 8,9,10 and everything worked as expected. I have also integrated into another library on which I am working and that was successful also. * How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? I read the docs, tested the library under Windows, and tried it in my own library, so it was pretty thorough. * Are you knowledgeable about the problem domain? Yes. 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. I vote for the library to be accepted into Boost. I would also like to see if the "Known Issues" could not be solved, not necessarily by the author of the library who has put so much effort and work into it, but possibly by other Boost experts who might find some solution to these issues which mar the library somewhat for me. But even if these issues could never be solved the library is worthwhile enough to be accepted. Edward Diener

3 5

[tasklet] micro-tasks with cooperative scheduler
by Oliver Kowalke 19 Mar '11

19 Mar '11

Hi, I've uploaded version 0.2.0 of boost.tasklet: http://www.boostpro.com/vault/index.php?action=downloadfile&filename=boost.… boost.tasklet provides a framework for cooperatively scheduling micro-tasks (some kind of user-level threads). It comes with an scheduler, synchronisation primitives - mutex, condition, barrier, event-variables (auto- and manual-reset and count-down variable), future and channel. boost::tasklets::packaged_task< std::string > pt( helloworld_fn); boost::tasklets::unique_future< std::string > fu = pt.get_future(); boost::tasklet t( boost::move( pt), boost::tasklet::default_stacksize); boost::scheduler::schedule( t); boost::scheduler::schedule( my_function, 1, "abc"); for (;;) { while ( boost::scheduler::run() ); if ( boost::scheduler::empty() ) break; } std::cout << fu.get() << std::endl; In order to let functions/actions be executed in a separate thread boost.tasklet provides a scheduler_thread: boost::scheduler_thread st; boost::shared_future< void > f1( st.schedule( some_fn ) ); boost::shared_future< std::string > f2( st.schedule( other_fn) ); f1.wait(); std::cout << "future 2 result: " << f2.get() << std::endl; regards, Oliver

2 5

lambda compile error
by Andy Venikov 19 Mar '11

19 Mar '11

Hi, I thought that lambda expressions of the form: (var(actual_var) = _1)(new_value) are supposed to work. Here's a small code that does not compile with boost 1.42 and gcc4.5: #include <map> #include <boost/lambda/lambda.hpp> using namespace std; void foo() { using namespace boost::lambda; typedef multimap<int, int> MP; MP mp1; MP mp2; (var(mp1) = _1)(mp2); //compile-time error here } Are standard maps special in that regard? Thanks, Andy.

2 4

Re: [boost] [Review] Boost.Type Traits Extension by Frederic Bron
by Jeffrey Lee Hellrung, Jr. 19 Mar '11

19 Mar '11

On 3/14/2011 12:48 AM, Joel Falcou wrote: > Dear All, > > This is the first day of the fast track review of Frédéric Bron's > extensions to the Type Traits Library.This reviews will last until March > 18th, 2011 under my management. All comments and reviews are > very welcome. [...] I vote for inclusion, pending resolution of my comments below (that is, I'm hoping the community will reach some consensus, not necessarily that all my suggestions will be adopted). I've perused a few pages of the documentation and a good chunk of the implementation source. As far as the naming, I'm fine with the has_operator_xxx convention. In my own implementation of such traits, I use names such as is_pre_incrementable, is_left_shiftable, etc., which I find equally good, but as John Maddock pointed out, the has_operator_xxx names are conveniently grouped in the alphabetical reference. Perhaps an additional section of the documentation under "Type Traits by Category" should be added called "Operator Traits" which can section out these new operator traits, and then the fact that all the operator traits are nicely grouped together in the alphabetical reference would be less of an issue. For the arithmetic operators, I prefer "plus" and "minus" to "add" and "subtract", respectively, and likewise "plus_equal" to "add_assign", but it's not a strong preference, and perhaps consistency with other Boost libraries should dictate these, I don't know. I do more strongly prefer "post_decrement" to "postfix_decrement", and to have "increment" and "decrement" spelled out. "bit_op" versus "bitwise_op" is another one that I have no strong preference either way, so I would probably look at other Boost libraries for precedent. One could provide aliases for the more contentious trait names...? There is precedent for this in Boost.Fusion with accumulate and fold... At least one example in the documentation utilizing one of these operator traits would be useful. I like the idea posited earlier of a generic streaming function, maybe for debugging purposes, which uses << if available, else streams out some default string containing the type of the argument. It is implicit in the documentation, and likewise verified from looking at the implementation, that all arguments are assumed to be lvalues. That is, a reference qualifier is automatically added to the argument types given to an operator trait. Thus, the only way to query if an operator is applicable to an rvalue is to query using a const-qualified type, and even then I think you could get back false negatives in C++0x and even C++03 with Boost.Move rvalue-reference emulation (consider only operator_xxx(T&&) available). Further, rvalueness and lvalueness does enter into overload resolution (rvalues can't bind to T& when T is deduced), hence it does influence the result type of the operation. For these reasons, I believe the traits should strive to differentiate between lvalue and rvalue argument types. In either case, whether arguments are treated as presently or as propositioned above, this treatment of the arguments should be spelled out explicitly. As Vicente pointed out, the use of make in the implementation can be replaced with the declval that common_type uses. I don't have strong feelings on whether to use "void" to signify that one "doesn't care" about the result type or to use some "dont_care" type. I've personally used "void" in my operator traits implementation. If the latter solution is settled upon, I believe it should be a documented part of the interface, and not in a detail namespace, to allow users to explicitly supply it. I still believe an extra template parameter representing a Boost.MPL metafunction to apply to the result type would be useful, relatively easy to add, and will not change the existing interface. It seems, however, that I'm the only one that likes this idea, and it's use cases are relatively limited. I've mostly used such a feature to further constrain the result beyond just "convertible". For example, one may want to prevent returning references to locals from functions. That is, the function's return type is fixed to be T const &, and the function logically returns the result of an operator applied to a local variable. If the operator returns U which is implicitly convertible to T, then everything compiles fine but it's probably asking for a crash, as the function's return value is a dangling reference. You'd hope you'd get a compiler warning, but better to either create a hard error in such cases or provide an alternate implementation of the function. I think that covers everything. Well done Frederic! - Jeff

2 1

[Review] Boost.Type Traits Extension by Frederic Bron
by Joel Falcou 18 Mar '11

18 Mar '11

Dear All, This is the first day of the fast track review of Frédéric Bron's extensions to the Type Traits Library.This reviews will last until March 18th, 2011 under my management. All comments and reviews are very welcome. =========== What is it? =========== This extension adds 37 new traits corresponding to the following 37 operators: - binary: ==, !=,<,<=,>,>=, , +, -, *, /, %, +=, -=, *=, /=, %=, , &&, ||, ,&, |, ^,<<,>>,&=, |=, ^=,<<=,>>= - prefix: ++, --, +, -, !, ~, * - postfix: ++, -- Each trait can detect if the operator can be used with particular types and if needed, if the return type is convertible to some type. =================== Getting the library =================== The latest version can be downloaded by different ways: - from the vault with unix line ending: http://www.boostpro.com/vault/index.php?action=downloadfile&filename=type_t… - from the vault with dos line ending: http://www.boostpro.com/vault/index.php?action=downloadfile&filename=type_t… - from the sandbox:http://svn.boost.org/svn/boost/sandbox/type_traits/ The entry point of the documentation is type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html The library has been tested with: - MSVC 8, 9, 10 on Windows, - g++ 4.4.5 on Linux, - intel 10.0 and 11.1 on Linux. To test the library, the simplest is to untar the headers in your boost include directory. For this, you can download the header part of the extension: - from the vault with unix line ending: http://www.boostpro.com/vault/index.php?action=downloadfile&filename=type_t… - from the vault with dos line ending: http://www.boostpro.com/vault/index.php?action=downloadfile&filename=type_t…

12 63

bcp (and config.hpp, user.hpp, shared_ptr.hpp) problem
by Michael Matthews 18 Mar '11

18 Mar '11

I am trying to compile (with VS2008) using a few boost tools pulled out using bcp. I've used bcp before without trouble, but I just upgraded to boost_1_46_1, and now I'm having trouble. I pulled the boost subset out with: C:\Program Files\boost\boost_1_46_1>bcp filesystem.hpp foreach.hpp property_tree shared_ptr.hpp fromBoost\ During compile, the problem is with shared_ptr. The shared_ptr.hpp file includes this line at the top: #include <boost/config.hpp> // for broken compiler workarounds which causes config.hpp to be used (and it is correctly pulled by bcp), which then causes this compile error (because user.hpp is not pulled, though other files in boost/config/ are): \fromboost\boost\config.hpp(26) : fatal error C1083: Cannot open include file: 'boost/config/user.hpp': No such file or directory which is from these lines in the config.hpp file: // if we don't have a user config, then use the default location: #if !defined(BOOST_USER_CONFIG) && !defined(BOOST_NO_USER_CONFIG) # define BOOST_USER_CONFIG <boost/config/user.hpp> #endif // include it first: #ifdef BOOST_USER_CONFIG # include BOOST_USER_CONFIG #endif What is the source of the problem, and what can I do to fix it? I am not familiar with config.hpp or what it's used for, but a quick look at the documentation makes me think that I shouldn't have to worry about it as a library user. Should I manually being #defining BOOST_NO_USER_CONFIG? That seems like a hack. Thanks, Michael

2 3