February 2012 - Boost - lists.preview.boost.org

[PREDEF] Review
by Dan Price 29 Feb '12

29 Feb '12

Hi everyone, This is my first review of a boost library but I have been a long-time boost user. I am excited by this proposal because it is a library that I would use on the day that it is accepted and it fills the need for what is otherwise a hackish and inconsistent task. My review of the library is included below. Thank you, Dan Price **What is your evaluation of the design?** The macros are clear. The BOOST_ARCHITECTURE_ macros are a little too long to type; I would advocate for changing them to BOOST_ARCH_ to make it quicker to type. Note that the operating system macro is BOOST_OS_ and not BOOST_OPERATINGSYSTEM, and BOOST_CXX vs. BOOST_COMPILER, so there is already a precedent for shorter names. The other ones are easy to type and appropriate. Within the headers there are human-readable strings that are intended to be used with a built-in test. It seems as if these might be useful to make these available for other purposes such as debugging. I wanted to add a comment to a question that showed up prevalently on the mailing lists regarding NULL vs. zero for definitions. Before reading this thread, but after having read the documentation, I assumed that definitions took on a NULL (undef) value. That is to say that even after reading the documentation, I made a faulty assumption because of my previous experience with platform detection. I would therefore advocate that an #undef approach be used rather than the zero-based one in order to avoid any gotchas. **What is your evaluation of the implementation?** The design goals of minimal "weight" from the predef headers is a good one. I personally do not think there is much to worry about regarding the implementation as long as the user-facing features (names, completeness) are good. **What is your evaluation of the potential usefulness of the library?** This is a library that I would use on the day that it was introduced to boost and I would even consider patching the distribution of boost I have in version control with this library. **Did you try to use the library? With what compiler? Did you have any problems?** I compiled the tests on a 64-bit version of ubuntu Linux and they worked as expected. **How much effort did you put into your evaluation? A glance? A quick reading? In-depth study?** My effort consisted of reading through the documentation and exploring the headers. I also compiled the tests on one platform and they worked as expected. **What is your evaluation of the documentation?** The documentation is acceptable, but I think that version number description can be cleaned up a bit. Specifically, rather than repeating "Version number available as major, minor, and patch." over and over, perhaps a graphic or an abbreviation can be used? Alternatively this may be better laid out as a table. One error in the documentation (also in the source): "American Micro Devices" -> "Advanced Micro Devices" **Are you knowledgeable about the problem domain?** I am knowledgeable of the preprocessor symbols of the 3 compilers and 3 systems I typically use. My normal habit for systems I am unfamiliar with is to search for information at predef.sourceforge.net but this library would clean up and simplify that work considerably. Additionally, I can see my team members who are not as familiar with detection mechanisms finding this library very useful. **Summary** In summary, I think that this library should be *conditionally accepted* as a boost library, provided that the issue regarding the NULL vs. 0 values for preprocessor symbols be worked out. I am an advocate of the NULL-based approach because it best matches what my expectations are.

1 0

[PREDEF] Review for the Boost.Predef library by Rene Riviera
by Joel Falcou 29 Feb '12

29 Feb '12

The review of BOOST.PREDEF by Rene Riviera is scheduled between Monday, February 20th to February 29th. ================ Contents & Scope ================ BOOST.PREDEF defines a set of compiler, architecture, operating system, and library version numbers from the information it can gather of C++ predefined macros or those defined in generally available headers. The idea for this library grew out of a proposal to extend the Boost Config library to provide more, and consistent, information than the feature definitions it supports. What follows is an edited version of that brief proposal. =============== How to get it ? =============== Sources and documentation can be retrieved from http://tinyurl.com/73n6a3k ================ Writing a Review ================ The reviews and all comments should be submitted to the developers list, and the email should have "[PREDEF] Review" at the beginning of the subject line to make sure it's not missed. Please explicitly state in your review whether the library should be accepted. The general review checklist: - 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.

15 34

[PREDEF] Review ends today
by Joel Falcou 29 Feb '12

29 Feb '12

The review of Boost.PRedef by Rene Rivera is ending today, February 29th. I recall to all people wanting to submit a formal review to do so. Regards

1 0

[Predef] Pre-review comments
by Mathias Gaunard 28 Feb '12

28 Feb '12

Misc ==== - This stuff partially exists in Boost.Config. How will this be integrated? - AMD stands for Advanced Micro Devices, not American Micro Devices - The whole set of C and C++ standard libraries doesn't seem to be covered. Are we supposed to infer it from the compiler or operating system? Naming ====== - BOOST_ARCHITECTURE_ is maybe a bit long. Have you considered a shorter name like BOOST_ARCH_ALPHA ? Same comment for BOOST_LANGUAGE_ - BOOST_LANGUAGE_XXX uses a STD prefix for most languages except for Objective-C. How about dropping the STD prefix? Also why not use CXX instead of CPP? - Standard C library is identified by LIBC, but standard C++ library is identified by LIBSTD. I find that confusing, it should be orthogonal. I take it LIBCXX wasn't chosen due to possible confusion with libc++. It's their fault for choosing a ridiculously broad name. glibc is often just called libc as well, yet this is not a problem. - BOOST_CXX_GNUC might be better as BOOST_CXX_GNU or BOOST_CXX_GCC - BOOST_OS_DRAGONFLY_BSD might be better as BOOST_OS_BSD_DRAGONFLY to indicate that "macro refinement" goes left to right. It could be BOOST_OS_BSD_FREEBSD for FreeBSD. Compiler frontend vs backend ============================ The BOOST_CXX_ macros is used to define both frontends (BOOST_CXX_CLANG, BOOST_CXX_EDG) and backends (BOOST_CXX_LLVM) and things that can be both (BOOST_CXX_GNUC) As for BOOST_CXX_CYGWIN, I have no idea what it's doing there. Cygwin should be exclusively in BOOST_OS_CYGWIN. The compiler is a normal GCC. As such it might be hard to tell which set of flags might be defined at the same time. Maybe the solution would be to split the set of frontends and backends, with each value in each set being mutually exclusive. Most compilers do not decouple frontends and backends, so it will end up with a lot of unnecessary duplication though. Non-mutually exclusive macros ============================= Currently, the only macros that are not mutually-exclusive (outside of the CXX macros outlined above, since they cover two different things) are the BOOST_OS_BSD macros along with BOOST_OS_UNIX and BOOST_OS_SVR4. It might be a good idea to expand on that on the architecture side (i.e. any x86, 32 or 64 bit), and the compiler side (GCC-like compilers). There are many variants of ARM as well, and a new 64-bit ARM will be released soon. The design needs to be flexible enough to integrate this. It might be good as well to put a clear distinction between a set of mutually-exclusive macros and more global macros that can cover several configurations. My use-cases ============ Just a few real use cases for which I use custom code in my software today, and that I'd be glad to replace: - Work-around a bug in the GCC frontend - Use a feature present in GCC-like frontends - Work-around a bug in the GCC backend - Define special versions of functions for x86 both 32- and 64-bit - Define special versions of functions for x86-64 only - Use special code for Windows or POSIX operating systems (for that, I currently use BOOST_SYSTEM_WINDOWS_API / BOOST_SYSTEM_POSIX_API)

4 11

Re: [boost] [git] neglected aspects
by David A. Greene 28 Feb '12

28 Feb '12

> The only downside (I can see) with GIT is that it has a bit of a learning curve. It is a bit more complicated but I believe (and experienced myself) that a lot of that learning curve is unnecessarily steep due to the way many of the tutorials out there are written. For some reason most of them start out describing the guts and inner workings of git (blobs, trees, packs, etc.) rather than teaching workflows. The one great exception I've found to this is Scott Chacon's fabulous _Pro_Git_ (http://progit.org/book) It teaches you how to use git to manage sources. Reading that is what make it "click" for me. -Dave

17 42

Is there interest in portable integer overflow detection, with policy based handling?
by Ben Robinson 28 Feb '12

28 Feb '12

The implementation is complete, with 5 policies created (and users can always create and use more). The policies are: ignore_overflow throw_overflow assert_overflow saturate_overflow nan_overflow The implementation is fully portable, and it provides integer types which can be used like the builtin integers, except they will trigger their policy on an overflow. Also, this library will integrate seamlessly with the Boost Constrained Value Library (contributed by Robert Kawulak). Does this pique anyone's interest? Thank you, Ben Robinson

11 37

Please use BOOST_ASSERT_MSG(x, "message") instead of BOOST_ASSERT(x && "message")
by Mathias Gaunard 28 Feb '12

28 Feb '12

Several libraries, including Boost.Array, use things like BOOST_ASSERT( i < N && "out of range" ); This causes warnings with EDG-based compilers. It would be nice if library authors could replace this with something like BOOST_ASSERT_MSG( i < N, "out of range" ); Not only will it make those warnings disappear, it will also enable users to use those messages more efficiently in custom assert handlers. Thank you.

3 3

[test] Dynamic linking problem?
by Matthijs Möhlmann 28 Feb '12

28 Feb '12

Hello all, Attached a testcase how I use the boost test library. Compiling goes well, but when I try to run it I get a 'symbol lookup error': matthijs@hammer % ./main ./main: symbol lookup error: ./main: undefined symbol: _ZN5boost9unit_test9ut_detail24auto_test_unit_registrarC1ENS0_13basic_cstringIKcEE I compile my files with the following lines: g++ -o main.o -c -I/usr/src/boost_1_49_0 -g -Werror -Wall -std=c++0x main.cpp g++ -o test.o -c -I/usr/src/boost_1_49_0 -g -Werror -Wall -std=c++0x test.cpp g++ -o main -L/usr/src/boost_1_49_0/stage/lib main.o test.o -lboost_unit_test_framework This is done with a fresh install of boost 1.49. (Compiled with ./bootstrap.sh && ./b2 -j3) Compiler: gcc-4.6 If I use the most recent version of trunk (r77131) then everything works as expected. If more information is needed, please let me know. Regards, Matthijs Möhlmann

1 0

[uBLAS] array_adaptor, shallow_array_adaptor, interoperability and bugs
by Guillermo Ruiz Troyano 28 Feb '12

28 Feb '12

It is my first post. I still write worst in English than in C++. I hope don't mess it up… INTEROPERABILITY I'm been trying to use array_adaptor and shallow_array_adaptor to modify data with uBLAS. Yes, both classes are undocumented but it is useful (not this implementation) in some cases to have this kind of adaptor. For example: // Statistics accumulator for regression, correlation, etc. struct simple_regression { void operator()(double x, double y) { … } double mean_x; double var_x; double mean_y; double var_y; double covar; vector_wrapper<double> v() { … } // Return vector with a reference array adapter }; Now, you need (for example) to interpolate two accumulators. Then you should to be able to do: simple_regression sr, sr1, sr2; … double w = 0.5; sr.v() = sr1.v()*w+sr2.v()*(1-w); And you don't want that uBLAS copies data from you objects to inner containers continuously. UNDOCUMENTED ATTEMPT array_adaptor<T> has deep copy semantics. You can to construct an array_adaptor that use the external data, but vector call to copy constructor and this makes a copy: struct point { double x; double y; double z; }; point p = { 1, 2, 3 } array_adaptor<double> a(3, &p.x); // Ok, a holds p address vector<double, array_adaptor<double> > v(a); // v now holds a new address! Well, a bit confusing class. If the only purpose of this class template is to pass plain data as arguments. Why not to put that constructor in unbounded_array and bounded_array? unbounded_array(size_t size, T* data) : size_(size), data_(new value_type[size]) { std::copy(data, data+size, data_); } Then, I found shallow_adaptor_array, more dangerous and funny. It has shallow copy semantics and a dummy shared_array with reference counting... ¿? // Yes, I want troubles… #define BOOST_UBLAS_SHALLOW_ARRAY_ADAPTOR struct point { double x; double y; double z; }; void test() { point p = { 1, 2, 3 } shallow_array_adaptor<double> a(3, &p.x); // Ok, a holds p address vector<double, shallow_array_adaptor<double> > v(a); // Ok, v holds p address v += v; // Ok, now p = { 2, 4, 6 } v /= 2; // Ok, now p = { 1, 2, 3 } v = 2*v; // ¡¡¡What!!! p = { 1, 2, 3 } } // Dummy functor of shared_array in shallow_array_adaptor called, ok. When you assign v with an expression, this constructs a temporary and then swaps between the temporary and v. Here is the issue: class shallow_array_adaptor<T> : … { ... // Swapping BOOST_UBLAS_INLINE void swap (shallow_array_adaptor &a) { if (this != &a) { std::swap (size_, a.size_); std::swap (own_, a.own_); std::swap (data_, a.data_); // This is definitely infidelity } } ... }; This is not a good idea. This member function should have a dual behavior: class shallow_array_adaptor<T> : … { ... // Swapping BOOST_UBLAS_INLINE void swap (array_adaptor& a) { if (own_ && a.own_) { // If they own the data do wife-swapping if (this != &a) { std::swap(size_, a.size_); std::swap(own_, a.own_); std::swap(data_, a.data_); } } else if (&data_[0] != &a.data_[0]) std::swap_ranges(data_, data_+size_, a.data_); // Childs is another thing } ... }; Modifying this function I get: void test() { point p = { 1, 2, 3 } shallow_array_adaptor<double> a(3, &p.x); // Ok, a holds p address vector<double, shallow_array_adaptor<double> > v(a); // Ok, v holds p address v = 2*v; // Ok, now p = { 2, 4, 6 } and v holds p address } // 0kills of dynamic memory WHY NOT? 1. An unbounded_array and bounded_array constructor for C plain arrays and copy semantics. 2. To discontinue this adaptor_array (with a #ifndef) or modify. Its behavior can do it point nº1. 3. To fix, test and document shallow_array_adaptor (or another name). It should be useful. Yes, I know about memory leaks. But there are things like vector proxies, iterator ranges, etc. The problem comes when you have not a clear semantic. Regards, Guillermo Ruiz Troyano.

2 2

[exception] RFC: patch for printing stacktraces during exceptions.
by Brett Lentz 27 Feb '12

27 Feb '12

Hi folks! It's been a few months since I last mailed the list. I've been working on bringing some forked changes from the Passenger project into Boost due to their more general applicability. With some help, I've got a working patch against SVN trunk that enables one of Passenger's more useful features: obtaining exception stacktraces all the way through the stack. However, due to the size of the patch and some namespacing choices made by the Phusion people, I'd like to get some feedback on this patch to ensure it's suitable for being brought into Boost. First, there's some helper classes that Phusion has put in an "oxt" namespace that I'm not really sure where they should be put or if suitable analogues already exist within Boost. For the current version of the patch, these files are simply put into 'boost/oxt' until I have a better location for them. Second, the current patch uses boost::tracable_exception. I'd like to confirm whether that is acceptable or whether I should move this to a different location in the boost namespace. Finally, any other comments about this patch are welcome. I have attached both the patch, and some example code that will demonstrate the functionality. The patch and a simple example are available here: http://wakko666.fedorapeople.org/boost/ ---Brett.

5 9