- Boost - lists.boost.org

Re: [boost] [Containers] Marshalling deques
by Brian Wood 24 Aug '11

24 Aug '11

Ion Gazta?aga: El 24/08/2011 20:06, Brian Wood escribi?: >> >> If I could get the number of elements in the first chunk and the >> size of the chunks, that would be sufficient. (I believe the size >> of the chunks is constant within a deque instance.) > > Not necessarily, but I think all implementations do that. The question > is whether we should have a standard-friendly and implementation > agnostic interface or an interface just for boost::deque implementation. How about both? First a boost::deque implementation and then if someone is inclined to delve into this further a more general implementation that might replace the earlier implementation. Since this wasn't addressed by C++11, I'm not sure how long it will take to get attention. If the interface we come up with has weaknesses, someone else will figure out how to improve upon it. Regards, Brian Wood Ebenezer Enterprises http://webEbenezer.net

1 0

[interest] underlying type library
by Julian Gonggrijp 24 Aug '11

24 Aug '11

Dear Boost developers, std::swap is commonly implemented by copying the arguments. For non-POD types this can be very inefficient. Two solutions are available. The first option, which is commonly employed, is to manually override std::swap for every non-POD type, making use of the implementation details of the type. The other option is to provide a library which makes it possible to implement the swap algorithm once, in a way that is efficient for any type (POD or non-POD), and which works even if a type isn't copyable. The latter is what I'll be proposing here. Back in March, Vicente Botet posted a link to the highly inspiring 'Notes on Programming' by Alexander Stepanov [1]. Lectures 4 and 5 cover the (hypothetical) move_raw algorithm and the (hypothetical) UNDERLYING_TYPE type function, as well as their relevance to the swap algorithm. I'll try to reproduce the essential points of this discussion below. move_raw(s, t) moves the value of s to t. t is guaranteed to be left in a valid state but s isn't. In particular, the destruction of s might corrupt t because they point to the same additional resources. Another move operation into s, say, move_raw(r, s) will however restore s into a new valid state. UNDERLYING_TYPE(T) represents a type which is (conceptually speaking) a POD-type with the same member data (and hence the same alignment) as T. The underlying type can be used to allocate space for a T object and to temporarily store the state of a T object. Using move_raw and UNDERLYING_TYPE, a swap algorithm can be implemented which works and is efficient for any type: template <class T> void swap (T& x, T& y) { UNDERLYING_TYPE(T) temp; move_raw (x, temp); move_raw (y, x); move_raw (temp, y); } The benefits of an underlying type library go far beyond the swap algorithm. For a start, any algorithm which moves values around without an inherent need to copy them could use the same mechanism as the swap algorithm above. Apart from that, it can help to simulate rvalue references and move semantics in pre-C++11 compilers in an efficient way. Concluding, a library which provides these tools has an immense potential for improving efficiency and convenience anywhere C++ is used. After reading the lecture notes, I came up with an idea on how to realise such a library in a fully generic way. Alexander Stepanov and Sean Parent have been so kind to review my idea. The idea seemed feasible and they encouraged me to submit something to Boost. In the meanwhile I have successfully managed to implement my idea, so here I am. :-) Apart from its fundamental nature in general, my library might bear special relevance to Boost.Swap and Boost.Move. Is your interest piqued? Kind regards, -Julian [1] http://www.stepanovpapers.com/notes.pdf

16 72

[proto] Problems with operator <<
by John Maddock 24 Aug '11

24 Aug '11

Folks, I'm having no end of problems with operator<< and proto. In the beginning, operator << was overloaded for stream output and everything worked OK, then I added the left shift operator<< to the list of protoized operators in the grammar and everything broke. The strange thing is that: std::cout << a+b; correctly finds my stream out overload: template <class Exp> inline std::ostream& operator << (std::ostream& os, const big_number_exp<Exp>& r) But std::cout << a; no longer calls: template <class Backend> inline std::ostream& operator << (std::ostream& os, const big_number<Backend>& r) But calls the proto << operator instead. I'm at a complete loss to explain this, both of my overloads are in the same namespace as their respective types, and as far as I can see both should be preferred to the proto versions. Before I start tearing my hair out, anyone any ideas? Thanks, John.

2 1

Re: [boost] [Boost-users] [Containers] Marshalling deques
by Brian Wood 24 Aug '11

24 Aug '11

Ion Gazta?aga: > >El 22/08/2011 19:44, Brian Wood escribi?: >> Would you be willing to add a function that gives that? Tia. > > Yes, I think we need to think about a useful interface for that, maybe > something like local_iterator in unordered containers or something like > segmented iterator described by Matt Austern in his "Segmented Iterators > and Hierarchical Algorithms" paper If I could get the number of elements in the first chunk and the size of the chunks, that would be sufficient. (I believe the size of the chunks is constant within a deque instance.) I find it disappointing that the latest version of the standard doesn't have anything related to this and would rather just get something working than figuring out what would be a flexible, general interface. Shalom, Brian Wood Ebenezer Enterprises http://webEbenezer.net

2 1

[Locale] On Mac OS X 10.6 fails to find iconv
by Artyom Beilis 24 Aug '11

24 Aug '11

Hello, I need a help from Mac OS X users, I have many faults on Darwin: http://beta.boost.org/development/tests/trunk/developer/locale.html Where all GCC's are related to inability to find iconv for some reason. On my darwin 8.01 x86 I have no problems to compile this simple program: has_iconv.cpp #include <iconv.h> int main() { iconv_t d = iconv_open(0,0); (void)(d); } With g++ has_iconv.cpp -liconv Also BBv2 script of Boost.Locale finds the iconv without a problem, so I'm quite lost. So if anybody that uses Boost from svn-trunk can check why has_iconv test fails (if it is on their machines) and see if ./bjam libs/locale/test prints ....... - iconv (libc) : no - iconv (separate) : no ....... And for what reason (if the sample code above compiles) I would be grateful. Because I have no idea what happens there and I don't have Mac only Darwin 8 which handles it properly. Artyom Beilis -------------- CppCMS - C++ Web Framework: http://cppcms.sf.net/ CppDB - C++ SQL Connectivity: http://cppcms.sf.net/sql/cppdb/

3 5

[Boost.Interprocess] Chronic performance on Win7
by Gav Wood 24 Aug '11

24 Aug '11

Hi, we're using the Boost Interprocess layer to do some shared-memory-based IPC and after getting awful performance characteristics out of sync primitives (in particular the condition variables, but similar results with semaphores) decided to do some profiling. Our platform is a (dual-core) Intel Core 2 Duo, running 64-bit Windows 7 and a 64-bit build environment in MSVC 10. One thing we wished to see was the performance of process hand-offs; i.e. getting one process to block as it unblocked a second symbiotic process and vice versa. To this aim we made a tight loop looking like: boost::interprocess::named_mutex m(boost::interprocess::create_or_open, "ProfileCache-Mutex"); boost::interprocess::named_condition c(boost::interprocess::create_or_open, "ProfileCache-Condition"); scoped_lock<named_mutex> l(m); for (int i = 0; i < 1024; ++i) { c.notify_all(); c.wait(l); } and another, running in another process with the wait & notify_all() reversed. It was checked to make sure that hand-offs were happened properly (no spurious wakeups &c.). I don't have any graphs to hand (though they would be quite easy to create), but as a rough figure, assuming a relatively unfettered execution environment - no browsers running/music playing - we were getting about 45 second run times. That's approximately 40ms per round-trip between the processes or 20ms per forced context switch. I suspect it's no mere coincidence that the Windows scheduling timeslice happens to be 20ms in duration; for Windows the sched_yield call is implemented by a Sleep(1); this, on Windows 7 at least, has the effect of putting the thread to sleep for the rest of its timeslice. Not ideal for low-latency IP-hand-offs. The obvious way to gain far higher performance is to Sleep(0). This has had the meaning since Vista of "run any other thread that's ready to run" (it used to mean any other thread of equal priority that's ready to run, hence priority inversion could ensue and people favoured the more aggressively passive Sleep(1)). Changing to a Sleep(0)-based sched_yield gave appropriately speedy results; of the order of 600us for the 1024 roundtrips, about 300ns per forced context switch. Though the loop around the Sleep(0) is a nice, yielding spin loop, if all processes are waiting (perhaps on an external event), then it will needlessly use 100% of each of the used cores. Also far from ideal. My proposed solution, for which I have attached a draft patch, introduces an argument to sched_yield ("_iteration"), in order to allow sched_yield to customise its behaviour depending on how long it has been waiting so far. All loops around sched_yield() (yield-loops) have been changed to track the number of iterations and pass it as an argument to sched_yield(). Ideally we would like to Sleep(0) in the case that the yield-loop's exit condition will be satisfied within the next 20ms and Sleep(1) in all other cases. As a completely unknown prior, we can use an exponential PDF with the 0.5 point occuring at the duration that we have already been waiting for. Optimising for this model, we Sleep(1) once we have already been waiting 20ms, which puts it at around 50000-100000 Sleep(0) calls. The was tested empirically and gave a simple Sleep(0)-yield performance, but while reducing the CPU consumption to near 0 on indefinite wait()s. We tested to make sure performance wasn't hindered should the threads be of unequal priorities; this indeed wasn't the case. Comments? Regards, Gavin -- Save Ferris!

4 7

Conversion review
by Jeroen Habraken 23 Aug '11

23 Aug '11

My review of the Conversion library: Please note that I'll be referring to the pre-review thread which can be found here: http://lists.boost.org/Archives/boost/2011/07/183525.php. * What is your evaluation of the design? Please refer to the section discussing the potential usefulness of this library. * What is your evaluation of the implementation? The code looks clean but I'm worried about the abundant use of boost::enable_if. While it is a useful tool SFINAE does make code fragile, possibly using something akin the following is an option: template <typename Target, typename Source, bool CA, bool EEC, bool A> struct assigner_impl { // No cookies BOOST_STATIC_ASSERT(sizeof(Target) == 0); }; template <typename Target, typename Source> struct assigner_impl<Target, Source, true, true, false> { // Copy-assignable, extrinsically explicitly convertible and not assignable ... }; template <typename Target, typename Source, bool CA, bool EEC> struct assigner_impl<Target, Source, CA, EEC, true> { // Assignable ... }; template <typename Target, typename Source> struct assigner : assigner_impl< Target, Source, is_copy_assignable<Target>::value, is_extrinsically_explicitly_convertible<Source, Target>::value is_assignable<Target, Source>::value > { }; (Note, this was written on the fly in this email, it may not actually compile.) * What is your evaluation of the documentation? Everything seems to be covered well, small comment though: template <> struct is_assignable<X&, X const&> : true_type { }; I initially missed that true_type is boost::true_type, this should be made more obvious. * What is your evaluation of the potential usefulness of the library? Let me tackle this in several parts: - type-to-string and string-to-type conversions In the pre-review we came to the following conclusions: "Coming back to the string to int conversion, if we can not have a default string-to-type or type-to-string, Boost.Conversion must remove these specializations." "I don't think that Boost.Conversion can provide a string-to-type conversion that is configurable. It could provide one if there is a consensus of a default. We should see Boost.Conversion customization as if we were adding some methods to one of the classes. For the string to float conversions, it is as if we were adding explicit operator float() const; to the std::string class. " I still maintain that this is the case, there is no sane way to let the user select between Convert or LexicalCast at the moment and possibly Coerce in the future and it's not something this library should be tackling. - STL conversions I believe these functions are of little use as when I would have to convert a list of integers to a list of doubles I'd simply write a loop (possibly aided by BOOST_FOREACH) instead of looking up a library (and reading the necessary documentation) to do it for me. With the offered customization points the cure seems to be worse than the disease, if I had to convert a std::pair<int, int> to a std::pair<double, double> I'd write a quick function to do so. The Conversion documentation however shows the following: template <typename Target1, typename Target2, typename Source1, typename Source2> struct implicit_converter_cp< std::pair<Target1,Target2>, std::pair<Source1, Source2> , typename enable_if_c< is_extrinsically_convertible<Source1, Target1>::value && is_extrinsically_convertible<Source2, Target2>::value >::type > : true_type { std::pair<Target1, Target2> operator()(std::pair<Source1, Source2>& v) { return std::pair<T1, T2>(implicit_convert_to<T1>(from.first), implicit_convert_to<T2>(from.second)); } }; This is a more generic solution but it seems like an awful lot of trouble for something this simple. - The Boost conversions These do seem very useful, but as discussed in the pre-review: "You are right and the same applies to any type-to-type conversion. And maybe this is the MAJOR flaw of Boost.Conversion: to think that we can define extrinsically THE conversion between two types. Every body admit that if a class T defines a constructor from a std::string THE conversion from std::string to T is the one defined by this constructor." I do believe that this library isn't the place for the conversions, they should be added to the specific libraries themselves in the form of constructors. * Did you try to use the library? With what compiler? Did you have any problems? I've tried several examples with GCC 4.2.1 (the default shipped with OS X), 4.5.3 and clang 2.9 on OS X. Both versions of GCC worked fine, clang however was unable to compile the examples with the following error: In file included from no_throw.cpp:13: In file included from ../../../boost/conversion/include.hpp:20: In file included from ../../../boost/conversion/convert_to.hpp:22: In file included from ../../../boost/conversion/explicit_convert_to.hpp:38: In file included from ../../../boost/conversion/implicit_convert_to.hpp:40: In file included from ../../../boost/conversion/type_traits/is_convertible.hpp:25: In file included from ../../../../library/boost-trunk/boost/fusion/tuple.hpp:10: In file included from ../../../../library/boost-trunk/boost/fusion/tuple/tuple.hpp:11: In file included from ../../../../library/boost-trunk/boost/fusion/container/vector/vector.hpp:11: In file included from ../../../../library/boost-trunk/boost/fusion/container/vector/detail/vector_n_chooser.hpp:14: In file included from ../../../../library/boost-trunk/boost/fusion/container/vector/vector10.hpp:14: In file included from ../../../../library/boost-trunk/boost/fusion/sequence/intrinsic/begin.hpp:17: In file included from ../../../../library/boost-trunk/boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp:11: In file included from ../../../../library/boost-trunk/boost/fusion/iterator/segmented_iterator.hpp:13: In file included from ../../../../library/boost-trunk/boost/fusion/container/list/cons.hpp:14: In file included from ../../../../library/boost-trunk/boost/fusion/sequence/intrinsic/end.hpp:17: ../../../../library/boost-trunk/boost/fusion/sequence/intrinsic/detail/segmented_end.hpp:33:70: error: invalid use of incomplete type 'fusion::nil' segmented_end_impl<Sequence, fusion::nil>::call(seq, fusion::nil())); ^~~~~~~~~~~~~ Not sure what's going on here exactly. * How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? Something between a quick reading and an in-depth study. * Are you knowledgeable about the problem domain? As the author of Coerce I'm knowledgeable about the string-to-type and type-to-string domain, less so about the generic type-to-type domain though. * 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. NO, the library should not be accepted as a Boost library in the current form. However the following should be done: - There are several type traits which can possibly be added to Boost.TypeTraits. This is not something I can judge, it is up to the auteurs of Conversion and TypeTraits to judge which are useful. - The conversions regarding Boost classes should be added to the respective libraries in the form of constructors if the respective auteurs believe this adds value to their library. Kind regards, Jeroen Habraken

3 4

[GSoC] Coerce summary and request for feedback
by Jeroen Habraken 23 Aug '11

23 Aug '11

Hi, As the Google Summer of Code has ended yesterday I'd like to thank Google and my mentor Hartmut Kaiser for the opportunity and guidance. Whilst Coerce is an on-going project (it's more than a year old already, time does fly when you're having fun) the GSoC sped up development significantly. To summarize Coerce for those not familiar with it, it's a type-to-string and string-to-type conversion library aiming at speed and extensibility. During the GSoC the following major things have happend: * Added tests, catching bugs and allowing me to prevent bugs in the future (hopefully). * Rewritten the tag system to be more flexible. * Added documentation, the latest version of which can be found over at http://vexocide.org/coerce/. In general the library matured, and while it's not done yet (the documentation in particular) I believe it's approaching production stability with the number of impacting changes dropping significantly over time. The current code can be found at http://svn.boost.org/svn/boost/sandbox/coerce/ and as usual I'd be grateful for any comments or critique. If you have questions do not hesitate to contact me. Kind regards, Jeroen Habraken P.S. If you're still using construe_cast (a previous incarnation of this project) please consider migrating to Coerce as I plan on removing https://github.com/VeXocide/construe_cast soon.

1 0

[Units] test_trig fails on Sandia-darwin-4.4 (caused by compile-time evaluation of math functions)
by Michel MORIN 23 Aug '11

23 Aug '11

The Units' test (libs/units/test/test_trig.cpp) fails on Sandia-darwin-4.4: http://tinyurl.com/3wherck The failure is caused by the fact that the results of `std::acos(0.2)` and `std::acos(d)` (double d = 0.2) are NOT equal on Sandia-darwin-4.4. On gcc-4.3 and newer versions, built-in math functions having constant arguments are evaluated at compile time using the MPFR (Multiple Precision Floating-Point Reliable) library. This happens even if optimization is disabled. So, the results of std::acos(0.2); // evaluated by the MPFR library at compile time and double d = 0.2; std::acos(d); // evaluated by the built-in function at run time are different. (If we compile with optimization enabled, the latter code is also evaluated by the MPFR library at compile time.) The solution to this problem is * Change BOOST_CHECK_EQUAL to BOOST_CHECK_CLOSE_FRACTION. or * Change `std::acos(0.2)` to `std::acos(d)` (with `double d = 0.2`) An interesting thing is that the test fails only on Sandia-darwin (x86-64) platform. On other platforms using gcc 4.3-4.6, the test runs successfully. I suspect that they have 80-bit registers and so the result of `std::acos(d)` is as accurate as the result of the MPFR library. Do you have any thoughts about this? Regards, Michel

3 3

[odeint] GSoC Summary and Feedback request
by Mario Mulansky 23 Aug '11

23 Aug '11

Hi, this is a summary of the progress of the odeint-library during this years GSoC. First of all I would like to thank Andrew for mentoring this project and also for the many fruitful comments and hints he gave during the past months. The aim of the project was to finalize odeint and prepare it for a boost review. This goal has been, more or less, achieved, I think. Although some work on docs and maybe some minor usability improvements are to be done we think we have reached a state of development ready for a review and we might try take this step in the near future. The puropose of odeint is to provide algorithms to numerically solve ordinary differential equations (ODEs) given as initial value problems: x'(t) = f(x,t) , x(0) = x0. It is written by Karsten Ahnert and myself. Please visit the docs to find out more about the features and abilities of odeint: http://headmyshoulder.github.com/odeint-v2/doc/index.html During the GSoC project, we switched from a svn branch in the boost sandbox to a new git project called odeint-v2: https://github.com/headmyshoulder/odeint-v2 In terms of code, I have made the following improvements to odeint: * Implementation and performance tests of a generic Runge-Kutta algorithm. * Implementation of several algorithms using the generic Runge-Kutta scheme (rk4, rk54ck, rk78) * Redesign of the construction/destruction of temporary states by use of a state_wrapper * Redesign of the resizing functionality by usage of boost::bind * Redesing of the algebra implementation to now use instances instead of static functions. * Creating mkl_operations to make use of Intel's MKL for optimal performance * major refactorings (e.g. renaming stepper classes) * Implementation of a Bulirsch-Stoer stepper with dense output * Improvement of integrate functions so they have consistent behavior * Adding integrate_times function to allow for observation at user defined time points * Adding unit tests for integrate functions Additionally, I worked on the documentation: * Created an overview over all implemented algorithms * Adding a resizing example to the tutorials section * Adding a description of the integrate functions * Adding a brief concept description of steppers, system and observer * Adding a brief overview on the Algebra/Operations and how they interact Besides his fruitful input and discussions related to my work presented above, Karsten also put quite some effort into odeint during the GSoC period, e.g. providing examples and tutorials in the docs section or adding multistep and implicit algorithms (adams-bashforth, rosenbrock4). We are very happy about any feedback on the work done within this GSoC or on odeint in general. If you have any further question please feel also invited to contact us. Finally, I want to thank the boost communtity for giving me the possibility to take part in this years GSoC as part of the boost organization. I have learned a lot during this time and I think odeint took a major step forward in terms of design and extent. Regards, Mario

4 5