- Boost - lists.preview.boost.org

[log] Release candidate 1
by Andrey Semashev 11 Mar '13

11 Mar '13

Hi, I've finished the docs update and released the RC1 of Boost.Log v2. The code can be downloaded here: http://sourceforge.net/projects/boost-log/files/boost-log-2.0-RC1-r847.zip/… The code can also be checked out from SVN: svn co https://boost-log.svn.sourceforge.net/svnroot/boost-log/trunk/boost-log The updated docs are available online: http://boost-log.sourceforge.net/libs/log/doc/html/index.html Aside from the docs updates there were a few changes I made as a part of the reviewing process (some were pointed out by users): - The add_attr manipulator was renamed to add_value. The new name better follows the terminology of the library. - The attribute value visitation API no longer forwards the result of the visitor. This feature is rarely needed but it slows down compilation significantly. To acquire the result one can use the new save_result function object wrapper. - Formatter and sink factories for settings parsers are now classes rather than simple function objects. This follows the pattern set by filter factories, which were classes before. - Fixed a few bugs and compilation problems. Sadly, there was almost no discussion of the library in this list. I received a few private emails on the library, mostly concerning some problems here and there and porting issues from v1. While valuable, this feedback can hardly replace a good review of the Boost community. I encourage everyone interested to take a look at the library, however deep you like, and provide your feedback. I don't plan to make any significant changes to the code, except maybe some include optimization and fixing the problems. If everything's fine, I'm going to post a request for permission to merge to trunk in a week or two.

6 25

Re: [boost] [log] Release candidate 1 usage question
by Alex Perry 11 Mar '13

11 Mar '13

Hi, I've been following with interest the development of this Log v2 code which looks very useful. However having read through the documentation I can't see any easy way of solving the following issue. I'm wondering if I'm just missing something obvious so thought I'd ask. I was hoping to replace some existing logging in an application which has been built on top of log4cpp - as far as I can see all the functionality of log4cpp we use is included (or some equivalent behaviour) in the boost log v2 and in a much more "natural looking" C++ idiom. However I can't see any easy way of solving the main problem we have with our current logging which is why I am looking to change it in the first place. The application is delivered as a group of related processes rather than as a single individual process - the logging is currently configured for this group and so messages need to be formatted with a source pid as well as a source tid - then grouped together and output to the appropriately configured streams (be it to a rolling file appender or syslog appender to use log4cpp names). Currently this is implemented by having one process taking the role of logging-server which is responsible for reading and managing the configuration for log4cpp, setting up the appropriate named loggers and appenders, then reading output from a shared memory circular buffer. The other logging-client processes then simply write their log output to this shared memory. Other than a bit of faffing around with timestamps to make sure that the timestamp recorded for a log message is the one when the message was written to the shared memory rather than when it was written to the log4cpp layer by the server, the server simply reads the shared memory and outputs the log messages to the current log4cpp configuration. The biggest issue with this setup is supporting the "filtering" required of log messages - obviously there is quite a large overhead in formatting a log message, locking the shared memory and writing to it. To avoid this overhead the server process writes the maximum severity of messages required for a "named log stream" to the shared memory - in the client processes this severity is checked before proceeding with the formatting of the log message. However unfortunately there is currently only support for a fixed number of these "named streams" - this actually means in practise (though wasn't the original design intention) that all logging output is written to one of 2 named log streams "trace" and/or "audit". Whilst this has worked well enough up to now enabling "trace" at "DEBUG" level can generate huge amounts of logging information which can be very time-consuming to parse when diagnosing a problem. I would like to go to a much more granular approach in the logging - so each component or sub-process, particularly for the general purpose "trace", "DEBUG" log messages, has its own name and may be switched on independently - preferably dynamically rather than by being loaded from some static configuration file. Having looked through the boost.log documentation I can't see anything that directly supports this type of multi-process logging. Whilst I'd be very happy to write a sink backend which writes to some shared memory in a similar manner to our current implementation and a custom log source to read from this and write in one "elevated" process , I'm not quite sure that this is the correct design. It appears to me that I really want to share the majority of the configuration of the logging "core" between the processes. Ie the configuration of filtering in particular needs to be shared between the processes. I see that support for loading the configuration of the core from a boost.ptree already exists. Would a good approach be to get the "server" process to write the configuration into a ptree which is then serialised and passed to the other processes by some mechanism (+some way of signalling that a change to logging configuration has occurred)? Or is there some way that the logging core could be maintained in boost interprocess containers or some such avoiding complex message passing between the processes (actually probably a bad idea - how do you avoid locking contention in the filtering check)? I can't imagine that I'm the only one ever to want this sort of "logger server/daemon" behaviour however what is other peoples experience with this sort of logging? Is it just simpler to let each process write to its own separate log for debug tracing? Whilst this will make for more searching when diagnosing issues (which process actually fulfilled the particular request I'm interested in) the simplicity will win out provided that more general "audit" messages are collated and in a single output to make finding which log output to search possible. Alex

2 1

[sandbox] [tree_node] Major update
by Cromwell Enage 11 Mar '13

11 Mar '13

Hello, fellow Boosters. In the hope that some of you here are still interested in easily extensible / augmented tree implementations, I've updated my Boost.TreeNode library in the sandbox. It provides adaptors for augmenting counts (a la countertree), heights, and even Boost.Accumulator values (which can solve the use cases mentioned in <http://je4d.blogspot.com/2013/01/boostintrusive-annotated-trees-part-1.html>), as well as concepts against which you can write your own adaptors. For a quick glance, documentation is at <http://svn.boost.org/svn/boost/sandbox/tree_node/libs/tree_node/doc/html/in…>. I'm still looking at the other two proposals. They have performance benchmarks which my library does not currently possess. However, at first glance I see no comparably straightforward way to augment user-defined data (e.g. Boost.Accumulator features) in either library. Feedback appreciated! Cromwell D. Enage

5 6

[test] spurious clang complier warnings
by Ian Emmons 10 Mar '13

10 Mar '13

When I compile my test code with clang on Macintosh (now Apple's default compiler), I get the two compiler warnings listed below. Could these be suppressed, please? I know this is a low priority item, but I expect it's pretty easy to fix. -Ian Emmons ============================== In file included from MyTest.cpp:6: In file included from ./MyTest.h:7: In file included from /Users/iemmons/dev/boost_1_53_0/boost/test/unit_test.hpp:19: In file included from /Users/iemmons/dev/boost_1_53_0/boost/test/test_tools.hpp:21: /Users/iemmons/dev/boost_1_53_0/boost/test/floating_point_comparison.hpp:251:25: warning: unused variable 'check_is_close' [-Wunused-variable] check_is_close_t const& check_is_close = unit_test::ut_detail::static_constant<check_is_close_t>::value; ^ /Users/iemmons/dev/boost_1_53_0/boost/test/floating_point_comparison.hpp:273:25: warning: unused variable 'check_is_small' [-Wunused-variable] check_is_small_t const& check_is_small = unit_test::ut_detail::static_constant<check_is_small_t>::value; ^ 2 warnings generated.

4 3

boost::interprocess::unique_ptr vs Boost.SmartPtr
by Adam Romanek 09 Mar '13

09 Mar '13

Hi! If I'm correct then the first "serious" implementation of unique_ptr for C++03 was written by Howard Hinnant, which was later adopted to Boost.Interprocess library. Unfortunately, I suppose not many people are aware of the fact that unique_ptr for C++03 is available in Boost. Even worse, I know people who are aware of it but who are afraid of using it just because it is provided by Boost.Interprocess, not by Boost.SmartPtr. Therefore, here's my proposal: - boost::interprocess::unique_ptr could be pulled into the top-level boost namespace - Boost.SmartPtr could provide a header file for unique_ptr that would pull the implementation from Boost.Interprocess; such a header file could also be placed in the top-level boost directory so that it could be accessed more easily - boost::unique_ptr could be documented in the documentation for Boost.SmartPtr library, providing use cases, emulation limitations etc. I believe that would make unique_ptr for C++03 available to wider audience. What do you think about this idea? With best regards, Adam Romanek

3 2

Context support for power architecture and mach-o ABI
by John Gleeson 09 Mar '13

09 Mar '13

I am interested in developing *ppc*_macho_gas.S implementations for the Boost.Context library. Has anyone already done some work on this combination? Any suggestions are welcome. I have prior experience in assembly programming and some understanding of processor scheduling concepts, but I have not done any work in these areas for a long time. I expect my re-learning curve to be steep. Thanks, John

1 0

[Serialization] Link issue on Mac OSX 10.8 (Mountain lion)
by Sean Farrow 08 Mar '13

08 Mar '13

Hi, I'm currently working with a client and we are facing an issue where by we can successfully build the boost libraries using the version of gcc that comes with xcode 4.6. However when we try to compile a project including serialization, the library and hence symbols cannot be found. We are using the latest mac os (mountain lion) and xcode 4.6. The strange thing is that this all worked under SnowLepard. If anyone can help this would be much appreciated. Moving to clang is not an option due to other dependencies. The entire log is as follows: Ld /Users/tim/Library/Developer/Xcode/DerivedData/SurfaceReader-fwryryuvfvwihnglkuymbbjtxpac/Build/Products/Debug/SurfaceReader.app/Contents/MacOS/SurfaceReader normal x86_64 cd /Users/tim/Developer/SurfaceReader setenv MACOSX_DEPLOYMENT_TARGET 10.8 /Applications/Xcode.app/Contents/Developer/usr/bin/llvm-g++-4.2 -arch x86_64 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.8.sdk -L/Users/tim/Library/Developer/Xcode/DerivedData/SurfaceReader-fwryryuvfvwihnglkuymbbjtxpac/Build/Products/Debug -L/usr/local/lib -L/Users/tim/Developer/SurfaceReader/../Libraries/cryptopp561 -F/Users/tim/Library/Developer/Xcode/DerivedData/SurfaceReader-fwryryuvfvwihnglkuymbbjtxpac/Build/Products/Debug -filelist /Users/tim/Library/Developer/Xcode/DerivedData/SurfaceReader-fwryryuvfvwihnglkuymbbjtxpac/Build/Intermediates/SurfaceReader.build/Debug/SurfaceReader.build/Objects-normal/x86_64/SurfaceReader.LinkFileList -mmacosx-version-min=10.8 -L/Users/tim/developer/libraries/wxwidgets-2.9.4/build-debug/lib -framework IOKit -framework Carbon -framework Cocoa -framework AudioToolbox -framework System -framework OpenGL /Users/tim/developer/libraries/wxwidgets-2.9.4/build-debug/lib/libwx_osx_cocoau_xrc-2.9.a /Users/tim/developer/libraries/wxwidgets-2.9.4/build-debug/lib/libwx_osx_cocoau_webview-2.9.a /Users/tim/developer/libraries/wxwidgets-2.9.4/build-debug/lib/libwx_osx_cocoau_qa-2.9.a /Users/tim/developer/libraries/wxwidgets-2.9.4/build-debug/lib/libwx_baseu_net-2.9.a /Users/tim/developer/libraries/wxwidgets-2.9.4/build-debug/lib/libwx_osx_cocoau_html-2.9.a /Users/tim/developer/libraries/wxwidgets-2.9.4/build-debug/lib/libwx_osx_cocoau_adv-2.9.a /Users/tim/developer/libraries/wxwidgets-2.9.4/build-debug/lib/libwx_osx_cocoau_core-2.9.a /Users/tim/developer/libraries/wxwidgets-2.9.4/build-debug/lib/libwx_baseu_xml-2.9.a /Users/tim/developer/libraries/wxwidgets-2.9.4/build-debug/lib/libwx_baseu-2.9.a -framework WebKit -lexpat -lwxregexu-2.9 -lwxtiff-2.9 -lwxjpeg-2.9 -lwxpng-2.9 -lz -lpthread -liconv -stdlib=libc++ -fobjc-arc -fobjc-link-runtime -lboost_filesystem -lboost_iostreams -lboost_serialization -lboost_system -lcryptopp -framework CoreMIDI -framework CoreAudio -framework Cocoa -o /Users/tim/Library/Developer/Xcode/DerivedData/SurfaceReader-fwryryuvfvwihnglkuymbbjtxpac/Build/Products/Debug/SurfaceReader.app/Contents/MacOS/SurfaceReader Undefined symbols for architecture x86_64: "boost::filesystem::path_traits::convert(wchar_t const*, wchar_t const*, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, std::codecvt<wchar_t, char, __mbstate_t> const&)", referenced from: void boost::filesystem::path_traits::dispatch<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, std::codecvt<wchar_t, char, __mbstate_t> const&)in SurfaceFrame.o "boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_start(char const*)", referenced from: void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > >(boost::serialization::nvp<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > > const&, int)in SurfaceFrame.o void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(boost::serialization::nvp<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > const&, int)in SurfaceFrame.o void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::vector<long, std::allocator<long> > >(boost::serialization::nvp<std::vector<long, std::allocator<long> > > const&, int)in SurfaceFrame.o void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, MessageDefinition, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, MessageDefinition> > > >(boost::serialization::nvp<std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, MessageDefinition, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, MessageDefinition> > > > const&, int)in SurfaceFrame.o void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, DisplayDefinition, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, DisplayDefinition> > > >(boost::serialization::nvp<std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, DisplayDefinition, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, DisplayDefinition> > > > const&, int)in SurfaceFrame.o void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::map<unsigned char, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::less<unsigned char>, std::allocator<std::pair<unsigned char const, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > > > > >, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::pair<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::map<unsigned char, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::less<unsigned char>, std::allocator<std::pair<unsigned char const, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > > > > > > > > >(boost::serialization::nvp<std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::map<unsigned char, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::less<unsigned char>, std::allocator<std::pair<unsigned char const, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > > > > >, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::pair<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::map<unsigned char, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::less<unsigned char>, std::allocator<std::pair<unsigned char const, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > > > > > > > > > const&, int)in SurfaceFrame.o void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::pair<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >(boost::serialization::nvp<std::pair<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&, int)in SurfaceFrame.o ... "boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override(boost::archive::version_type&, int)", referenced from: void boost::archive::xml_wiarchive_impl<boost::archive::xml_wiarchive>::load_override<boost::archive::version_type>(boost::archive::version_type&, int)in SurfaceFrame.o "boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override(boost::archive::class_id_type&, int)", referenced from: void boost::archive::xml_wiarchive_impl<boost::archive::xml_wiarchive>::load_override<boost::archive::class_id_type>(boost::archive::class_id_type&, int)in SurfaceFrame.o "boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override(boost::archive::tracking_type&, int)", referenced from: void boost::archive::xml_wiarchive_impl<boost::archive::xml_wiarchive>::load_override<boost::archive::tracking_type>(boost::archive::tracking_type&, int)in SurfaceFrame.o "boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override(boost::archive::object_id_type&, int)", referenced from: void boost::archive::xml_wiarchive_impl<boost::archive::xml_wiarchive>::load_override<boost::archive::object_id_type>(boost::archive::object_id_type&, int)in SurfaceFrame.o "boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_end(char const*)", referenced from: void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > >(boost::serialization::nvp<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > > const&, int)in SurfaceFrame.o void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(boost::serialization::nvp<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > const&, int)in SurfaceFrame.o void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::vector<long, std::allocator<long> > >(boost::serialization::nvp<std::vector<long, std::allocator<long> > > const&, int)in SurfaceFrame.o void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, MessageDefinition, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, MessageDefinition> > > >(boost::serialization::nvp<std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, MessageDefinition, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, MessageDefinition> > > > const&, int)in SurfaceFrame.o void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, DisplayDefinition, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, DisplayDefinition> > > >(boost::serialization::nvp<std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, DisplayDefinition, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, DisplayDefinition> > > > const&, int)in SurfaceFrame.o void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::map<unsigned char, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::less<unsigned char>, std::allocator<std::pair<unsigned char const, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > > > > >, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::pair<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::map<unsigned char, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::less<unsigned char>, std::allocator<std::pair<unsigned char const, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > > > > > > > > >(boost::serialization::nvp<std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::map<unsigned char, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::less<unsigned char>, std::allocator<std::pair<unsigned char const, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > > > > >, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::pair<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::map<unsigned char, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::less<unsigned char>, std::allocator<std::pair<unsigned char const, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > > > > > > > > > const&, int)in SurfaceFrame.o void boost::archive::basic_xml_iarchive<boost::archive::xml_wiarchive>::load_override<std::pair<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >(boost::serialization::nvp<std::pair<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&, int)in SurfaceFrame.o ... "boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_start(char const*)", referenced from: void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<bool>(boost::serialization::nvp<bool> const&, int)in SurfaceFrame.o void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<boost::serialization::collection_size_type>(boost::serialization::nvp<boost::serialization::collection_size_type> const&, int)in SurfaceFrame.o void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<boost::serialization::item_version_type const>(boost::serialization::nvp<boost::serialization::item_version_type const> const&, int)in SurfaceFrame.o void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<long const>(boost::serialization::nvp<long const> const&, int)in SurfaceFrame.o void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<unsigned char const>(boost::serialization::nvp<unsigned char const> const&, int)in SurfaceFrame.o void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<unsigned char>(boost::serialization::nvp<unsigned char> const&, int)in SurfaceFrame.o void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > >(boost::serialization::nvp<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > > const&, int)in SurfaceFrame.o ... "boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::end_preamble()", referenced from: void boost::archive::save_access::save_primitive<boost::archive::xml_woarchive, bool>(boost::archive::xml_woarchive&, bool const&)in SurfaceFrame.o void boost::archive::save_access::save_primitive<boost::archive::xml_woarchive, boost::serialization::collection_size_type>(boost::archive::xml_woarchive&, boost::serialization::collection_size_type const&)in SurfaceFrame.o void boost::archive::save_access::save_primitive<boost::archive::xml_woarchive, boost::serialization::item_version_type>(boost::archive::xml_woarchive&, boost::serialization::item_version_type const&)in SurfaceFrame.o void boost::archive::save_access::save_primitive<boost::archive::xml_woarchive, long>(boost::archive::xml_woarchive&, long const&)in SurfaceFrame.o void boost::archive::save_access::save_primitive<boost::archive::xml_woarchive, unsigned char>(boost::archive::xml_woarchive&, unsigned char const&)in SurfaceFrame.o void boost::archive::save_access::save_primitive<boost::archive::xml_woarchive, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > >(boost::archive::xml_woarchive&, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > const&)in SurfaceFrame.o void boost::archive::save_access::save_primitive<boost::archive::xml_woarchive, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(boost::archive::xml_woarchive&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)in SurfaceFrame.o ... "boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override(boost::archive::version_type const&, int)", referenced from: boost::archive::xml_woarchive& boost::archive::detail::interface_oarchive<boost::archive::xml_woarchive>::operator<< <boost::archive::version_type const>(boost::archive::version_type const&)in SurfaceFrame.o "boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override(boost::archive::class_id_type const&, int)", referenced from: boost::archive::xml_woarchive& boost::archive::detail::interface_oarchive<boost::archive::xml_woarchive>::operator<< <boost::archive::class_id_type const>(boost::archive::class_id_type const&)in SurfaceFrame.o "boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override(boost::archive::tracking_type const&, int)", referenced from: boost::archive::xml_woarchive& boost::archive::detail::interface_oarchive<boost::archive::xml_woarchive>::operator<< <boost::archive::tracking_type const>(boost::archive::tracking_type const&)in SurfaceFrame.o "boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override(boost::archive::object_id_type const&, int)", referenced from: boost::archive::xml_woarchive& boost::archive::detail::interface_oarchive<boost::archive::xml_woarchive>::operator<< <boost::archive::object_id_type const>(boost::archive::object_id_type const&)in SurfaceFrame.o "boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override(boost::archive::class_name_type const&, int)", referenced from: boost::archive::xml_woarchive& boost::archive::detail::interface_oarchive<boost::archive::xml_woarchive>::operator<< <boost::archive::class_name_type const>(boost::archive::class_name_type const&)in SurfaceFrame.o "boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override(boost::archive::object_reference_type const&, int)", referenced from: boost::archive::xml_woarchive& boost::archive::detail::interface_oarchive<boost::archive::xml_woarchive>::operator<< <boost::archive::object_reference_type const>(boost::archive::object_reference_type const&)in SurfaceFrame.o "boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override(boost::archive::class_id_optional_type const&, int)", referenced from: boost::archive::xml_woarchive& boost::archive::detail::interface_oarchive<boost::archive::xml_woarchive>::operator<< <boost::archive::class_id_optional_type const>(boost::archive::class_id_optional_type const&)in SurfaceFrame.o "boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override(boost::archive::class_id_reference_type const&, int)", referenced from: boost::archive::xml_woarchive& boost::archive::detail::interface_oarchive<boost::archive::xml_woarchive>::operator<< <boost::archive::class_id_reference_type const>(boost::archive::class_id_reference_type const&)in SurfaceFrame.o "boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_end(char const*)", referenced from: void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<bool>(boost::serialization::nvp<bool> const&, int)in SurfaceFrame.o void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<boost::serialization::collection_size_type>(boost::serialization::nvp<boost::serialization::collection_size_type> const&, int)in SurfaceFrame.o void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<boost::serialization::item_version_type const>(boost::serialization::nvp<boost::serialization::item_version_type const> const&, int)in SurfaceFrame.o void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<long const>(boost::serialization::nvp<long const> const&, int)in SurfaceFrame.o void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<unsigned char const>(boost::serialization::nvp<unsigned char const> const&, int)in SurfaceFrame.o void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<unsigned char>(boost::serialization::nvp<unsigned char> const&, int)in SurfaceFrame.o void boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::save_override<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > >(boost::serialization::nvp<std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > > const&, int)in SurfaceFrame.o ... "boost::archive::basic_xml_oarchive<boost::archive::xml_woarchive>::~basic_xml_oarchive()", referenced from: boost::archive::xml_woarchive_impl<boost::archive::xml_woarchive>::~xml_woarchive_impl()in SurfaceFrame.o boost::archive::xml_woarchive_impl<boost::archive::xml_woarchive>::~xml_woarchive_impl()in SurfaceFrame.o boost::archive::xml_woarchive_impl<boost::archive::xml_woarchive>::~xml_woarchive_impl()in SurfaceFrame.o "boost::archive::xml_wiarchive_impl<boost::archive::xml_wiarchive>::load_override(boost::archive::class_name_type&, int)", referenced from: boost::archive::xml_wiarchive& boost::archive::detail::interface_iarchive<boost::archive::xml_wiarchive>::operator>><boost::archive::class_name_type>(boost::archive::class_name_type&)in SurfaceFrame.o "boost::archive::xml_wiarchive_impl<boost::archive::xml_wiarchive>::load(std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >&)", referenced from: void boost::archive::load_access::load_primitive<boost::archive::xml_wiarchive, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > >(boost::archive::xml_wiarchive&, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >&)in SurfaceFrame.o "boost::archive::xml_wiarchive_impl<boost::archive::xml_wiarchive>::load(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)", referenced from: void boost::archive::load_access::load_primitive<boost::archive::xml_wiarchive, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(boost::archive::xml_wiarchive&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)in SurfaceFrame.o "boost::archive::xml_wiarchive_impl<boost::archive::xml_wiarchive>::xml_wiarchive_impl(std::basic_istream<wchar_t, std::char_traits<wchar_t> >&, unsigned int)", referenced from: boost::archive::xml_wiarchive::xml_wiarchive(std::basic_istream<wchar_t, std::char_traits<wchar_t> >&, unsigned int)in SurfaceFrame.o "boost::archive::xml_wiarchive_impl<boost::archive::xml_wiarchive>::~xml_wiarchive_impl()", referenced from: boost::archive::xml_wiarchive::xml_wiarchive(std::basic_istream<wchar_t, std::char_traits<wchar_t> >&, unsigned int)in SurfaceFrame.o boost::archive::xml_wiarchive::~xml_wiarchive()in SurfaceFrame.o boost::archive::xml_wiarchive::~xml_wiarchive()in SurfaceFrame.o "boost::archive::xml_woarchive_impl<boost::archive::xml_woarchive>::save(std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > const&)", referenced from: void boost::archive::save_access::save_primitive<boost::archive::xml_woarchive, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > >(boost::archive::xml_woarchive&, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > const&)in SurfaceFrame.o "boost::archive::xml_woarchive_impl<boost::archive::xml_woarchive>::save(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)", referenced from: void boost::archive::save_access::save_primitive<boost::archive::xml_woarchive, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(boost::archive::xml_woarchive&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)in SurfaceFrame.o "boost::archive::xml_woarchive_impl<boost::archive::xml_woarchive>::xml_woarchive_impl(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >&, unsigned int)", referenced from: boost::archive::xml_woarchive::xml_woarchive(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >&, unsigned int)in SurfaceFrame.o "boost::archive::basic_text_oprimitive<std::basic_ostream<wchar_t, std::char_traits<wchar_t> > >::~basic_text_oprimitive()", referenced from: boost::archive::xml_woarchive_impl<boost::archive::xml_woarchive>::~xml_woarchive_impl()in SurfaceFrame.o boost::archive::xml_woarchive_impl<boost::archive::xml_woarchive>::~xml_woarchive_impl()in SurfaceFrame.o boost::archive::xml_woarchive_impl<boost::archive::xml_woarchive>::~xml_woarchive_impl()in SurfaceFrame.o ld: symbol(s) not found for architecture x86_64 collect2: ld returned 1 exit status Regards Sean.

1 0

[unordered_map] assert fail
by Steve Lorimer 08 Mar '13

08 Mar '13

I got an assert fail on a call to: return _map.insert(std::make_pair(newKey, value.second)); The assertion was in delete_buckets() BOOST_ASSERT(!this->size_); Here is a stack trace: #0 0x00007f3b7c645945 in raise () from /lib64/libc.so.6 #1 0x00007f3b7c646f21 in abort () from /lib64/libc.so.6 #2 0x00007f3b7c63e810 in __assert_fail () from /lib64/libc.so.6 #3 0x000000000075d59f in boost::unordered::detail::buckets<std::allocator<std::pair<char const* const, Spl::Market::Symbol*> >, boost::unordered::detail::ptr_bucket, boost::unordered::detail::ptr_node<std::pair<char const* const, Spl::Market::Symbol*> >, boost::unordered::detail::mix64_policy<unsigned long> >::delete_buckets (this=0x7f3b772ac0b0) at /hostname/trading/sdk/include/boost-1.51.0/boost/unordered/detail/buckets.hpp:834 #4 0x000000000075d125 in boost::unordered::detail::buckets<std::allocator<std::pair<char const* const, Spl::Market::Symbol*> >, boost::unordered::detail::ptr_bucket, boost::unordered::detail::ptr_node<std::pair<char const* const, Spl::Market::Symbol*> >, boost::unordered::detail::mix64_policy<unsigned long> >::~buckets (this=0x7f3b772ac0b0, __in_chrg=<optimized out>) at /hostname/trading/sdk/include/boost-1.51.0/boost/unordered/detail/buckets.hpp:805 #5 0x000000000075cebe in boost::unordered::detail::table_impl<boost::unordered::detail::map<std::allocator<std::pair<char const* const, Spl::Market::Symbol*> >, char const*, Spl::Market::Symbol*, Spl::String::Map<Spl::Market::Symbol*>::HashFunction, Spl::String::Map<Spl::Market::Symbol*>::Predicate> >::rehash_impl (this=0xfd1670, num_buckets=64) at /hostname/trading/sdk/include/boost-1.51.0/boost/unordered/detail/unique.hpp:746 #6 0x000000000075c915 in boost::unordered::detail::table<boost::unordered::detail::map<std::allocator<std::pair<char const* const, Spl::Market::Symbol*> >, char const*, Spl::Market::Symbol*, Spl::String::Map<Spl::Market::Symbol*>::HashFunction, Spl::String::Map<Spl::Market::Symbol*>::Predicate> >::reserve_for_insert (this=0xfd1670, size=33) at /hostname/trading/sdk/include/boost-1.51.0/boost/unordered/detail/table.hpp:413 #7 0x000000000075c48b in boost::unordered::detail::table_impl<boost::unordered::detail::map<std::allocator<std::pair<char const* const, Spl::Market::Symbol*> >, char const*, Spl::Market::Symbol*, Spl::String::Map<Spl::Market::Symbol*>::HashFunction, Spl::String::Map<Spl::Market::Symbol*>::Predicate> >::emplace_impl<std::pair<char const* const, Spl::Market::Symbol*> >(char const* const&, std::pair<char const* const, Spl::Market::Symbol*>&&) (this=0xfd1670, k=@0x7f3b772ac360: 0x10f0da40 "XJO.5025P13.AX") at /hostname/trading/sdk/include/boost-1.51.0/boost/unordered/detail/unique.hpp:464 #8 0x000000000075c0a1 in boost::unordered::detail::table_impl<boost::unordered::detail::map<std::allocator<std::pair<char const* const, Spl::Market::Symbol*> >, char const*, Spl::Market::Symbol*, Spl::String::Map<Spl::Market::Symbol*>::HashFunction, Spl::String::Map<Spl::Market::Symbol*>::Predicate> >::emplace<std::pair<char const* const, Spl::Market::Symbol*> >(std::pair<char const* const, Spl::Market::Symbol*>&&) (this=0xfd1670) at /hostname/trading/sdk/include/boost-1.51.0/boost/unordered/detail/unique.hpp:430 #9 0x000000000075bebf in boost::unordered::unordered_map<char const*, Spl::Market::Symbol*, Spl::String::Map<Spl::Market::Symbol*>::HashFunction, Spl::String::Map<Spl::Market::Symbol*>::Predicate, std::allocator<std::pair<char const* const, Spl::Market::Symbol*> > >::emplace<std::pair<char const* const, Spl::Market::Symbol*> >(std::pair<char const* const, Spl::Market::Symbol*>&&) (this=0xfd1670) at /hostname/trading/sdk/include/boost-1.51.0/boost/unordered/unordered_map.hpp:239 #10 0x000000000075bcf0 in boost::unordered::unordered_map<char const*, Spl::Market::Symbol*, Spl::String::Map<Spl::Market::Symbol*>::HashFunction, Spl::String::Map<Spl::Market::Symbol*>::Predicate, std::allocator<std::pair<char const* const, Spl::Market::Symbol*> > >::insert(std::pair<char const* const, Spl::Market::Symbol*>&&) (this=0xfd1670, x=...) at /hostname/trading/sdk/include/boost-1.51.0/boost/unordered/unordered_map.hpp:388

2 1

[compute] GPGPU Library - Request For Feedback
by Kyle Lutz 08 Mar '13

08 Mar '13

Hi everyone, A while back I posted a message asking for interest in a GPGPU computing library and the response seemed positive. I've been slowly working on it for the last few months and it has finally reached a usable state. I've made an initial release on GitHub (details below) and would like to get feedback from the community. The Boost Compute library provides a partial implementation of the C++ standard library for GPUs and multi-core CPUs. It includes common containers (vector<T>, flat_set<T>) and standard algorithms (transform, sort, accumulate). It also features a number of extensions including parallel-computing focused algorithms (exclusive_scan, scatter, reduce) along with a number of fancy iterators (transform_iterator, permutation_iterator). The library is built around the OpenCL framework which allows it to be portable across many types of devices (GPUs, CPUs, and accelerator cards) from many different vendors (NVIDIA, Intel, AMD). The source code and documentation are available from the links below. Code: https://github.com/kylelutz/compute Documentation: http://kylelutz.github.com/compute Bug Tracker: https://github.com/kylelutz/compute/issues I've tested the library with GCC 4.7 and Clang 3.3 on both NVIDIA GPUs and Intel CPUs. However, I would not yet consider the library production-ready. Most of my time has been devoted to reaching a solid and well-tested API rather than on performance. Over time this will improve. Feel free to send any questions, comments or feedback. Thanks, Kyle

7 13

[graph]Direct Edge Access
by Takatoshi Kondo 08 Mar '13

08 Mar '13

Hello, I'm using Boost.Graph version 1.53.0. I'm trying to write some graph algorithms and I want to minimize the requirements of the input graph. I have a question about Boost.Graph concepts. I wrote a very simple code as follows: typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::bidirectionalS> G; int main() { G g; boost::add_edge(0, 1, g); auto res = boost::edge(0, 1, g); // Why can I call it? std::cout << std::boolalpha << res.second << std::endl; boost::graph_traits<G>::edge_descriptor e = res.first; std::cout << boost::source(e, g) << "," << boost::target(e, g) << std::endl; } It works, but I don't understand why I can call boost::edge(). According to the following document, AdjacencyMatrix concept provides Direct Edge Access functionality, so I can call edge(u,v,g) : http://www.boost.org/doc/libs/1_53_0/libs/graph/doc/AdjacencyMatrix.html The class template adjacency_list is a model of VertexAndEdgeListGraph, MutablePropertyGraph, CopyConstructible, Assignable, and Serializable. http://www.boost.org/doc/libs/1_53_0/libs/graph/doc/adjacency_list.html So, adjacency_list is not satisfied AdjacencyMatrix concept. I checked which function template is called, then I found the following function is called: boost/graph/detail/adjacency_list.hpp:1582 template <class Config, class Base> inline std::pair<typename Config::edge_descriptor, bool> edge(typename Config::vertex_descriptor u, typename Config::vertex_descriptor v, const adj_list_helper<Config, Base>& g_) { typedef typename Config::graph_type Graph; typedef typename Config::StoredEdge StoredEdge; const Graph& cg = static_cast<const Graph&>(g_); typedef typename Config::out_edge_iterator out_edge_iterator; const typename Config::OutEdgeList& el = cg.out_edge_list(u); typename Config::OutEdgeList::const_iterator it = graph_detail:: find(el, StoredEdge(v)); return std::make_pair( typename Config::edge_descriptor (u, v, (it == el.end() ? 0 : &(*it).get_property())), (it != el.end())); } Also, I found the following document: http://www.boost.org/doc/libs/1_53_0/libs/graph/doc/using_adjacency_list.ht… This document describes that: edge() The time complexity for this operation is O(E/V) when the OutEdgeList type is a Sequence and it is O(log(E/V)) when the OutEdgeList type is an AssociativeContainer. It seems that edge() is a part of the public interface of adjacency_list. But I think that it is not a part of any graph concepts. If I want to write an algorithm that depends on several graph concepts, not actual classes such as adjancency_list, I can use edge(u,v,g) only if the input graph class satisfies AdjacencyMatrix concept. Am I understanding correctly? Thanks, Taka

2 3

[locale] Memory leaks?
by Jookia 07 Mar '13

07 Mar '13

Hello! I've been debugging my application that uses Boost.Locale for the past five hours or so, and I've found it curious that it leaks memory. In order to stop it, I have to do a couple of weird things, such as including ICU in to my projects and calling u_cleanup at the end of my application. I also have to disable certain facets. I've put all this together in some source code, that by default won't leak, but uncommenting various parts will cause it to leak: // ---- BEGIN CODE ---------------------------------------------------- #include <boost/locale.hpp> #include <unicode/uclean.h> #include <iostream> using namespace boost::locale; using namespace std; int main() { generator gen; gen.categories( convert_facet | //collation_facet | // Various errors. //formatting_facet | // Various errors. //parsing_facet | // Various errors. message_facet | //codepage_facet | // Various errors. boundary_facet | calendar_facet | information_facet); locale newLoc = gen("zh_CN.GB18030"); locale::global(newLoc); cout.imbue(newLoc); // ios_info::get doesn't clean up after itself. //cout << as::date << time(0) << endl; // Do this at the end of the program to clean up resources. locale::global(std::locale("C")); cout.imbue(std::locale("C")); u_cleanup(); } // ---- END CODE ------------------------------------------------------ Dumping this as 'hello.cpp' and running this is how I'm debugging it: g++ hello.cpp -lboost_locale -licuuc && valgrind --leak-check=full --show-reachable=yes ./a.out Thanks, Jookia.

1 0

[interprocess] leaked named mutexes
by Eric Niebler 07 Mar '13

07 Mar '13

I recently discovered that a process can very easily leave a named mutex dangling. Consider the following: #include <cstdlib> #include <iostream> #include <boost/interprocess/sync/named_mutex.hpp> #include <boost/interprocess/sync/scoped_lock.hpp> namespace ip = boost::interprocess; char const *name = "mynamedmutex"; int main(int argc, char*argv[]) { ip::named_mutex mtx(ip::open_or_create, name); std::cout << "acquiring named mutex" << std::endl; ip::scoped_lock<ip::named_mutex> lock(mtx); std::cout << "acquired" << std::endl; exit(EXIT_FAILURE); // whoops } On my Linux box, this runs fine the first time, but the second time it hangs waiting to acquire the mutex. I have to manually delete the semaphore in /dev/shm/. This will happen whenever the process exits without calling destructors of locals; for instance: - std::exit - std::quick_exit - std::abort - std::terminate - a crash - assert failure - an unhandled exception - etc.. I find I can handle *some* of this by registering a terminate handler, an exit handler (and on C++11, a quick_exit handler) that calls boost::interprocess::named_mutex::remove. This raises a few questions, though... - Is there a better way? - Is it safe to `remove` the same named mutex multiple times? - Does this clean up only this process's use of the named_mutex, or does it nuke it from the system, even if another process is using it? (The docs suggest the latter, which is not what I want, is it?) Thanks, -- Eric Niebler Boost.org

5 5

[Graph][Parallel][PBGL] Bug deleting self loop edges
by bminano 07 Mar '13

07 Mar '13

Hello, I think I found a bug in the graph parallel library. I have a bidirectional adjacency list which has some self loop edges. When I try to delete them with remove_edge_if (or remove_out_edge_if or remove_in_edge_if) the edges are deleted, but it seems that some reference gets broken in the graph. If I iterate over the in_edges a reference to a self loop is found. But it does not happen if I iterate over the out_edges. If the graph is written in a graphviz file the self loop edges does not appear. I think there is some broken reference into the adjacency list that keeps the in_edges. I have two different pieces of code (one with pbgl and the other with bgl). They do the same, create a graph, delete the self-edges and print the in_edges. Could someone have a look at this problem? We want to use this library in our research but with this problem will not be possible. Thank you pbgl_in_edges.cpp <http://boost.2283326.n4.nabble.com/file/n4643903/pbgl_in_edges.cpp> bgl_in_edges.cpp <http://boost.2283326.n4.nabble.com/file/n4643903/bgl_in_edges.cpp> -- View this message in context: http://boost.2283326.n4.nabble.com/Graph-Parallel-PBGL-Bug-deleting-self-lo… Sent from the Boost - Dev mailing list archive at Nabble.com.

1 0

make_shared causes stack overflow with large objects
by Gregor Jasny 07 Mar '13

07 Mar '13

Hello, the bug described in #7965 causes stack overflows and sometimes hard to track crashes. I'd really appreciate if anyone could have a look. Thanks, Gregor

2 3

[thread] thread_specific_ptr leaks on VS2012 when using std::async()
by Klaim - Joël Lamotte 05 Mar '13

05 Mar '13

Hi, The title says it all. I think I found a memory leak with the help of boost.log author Andrei Semashev. I was using Boost.Log in Visual Studio 2012 (released one) and tried to use Visual Leak Detector because Visual Studio basic leak detector was reporting leaks. I isolated the leaks to usage of log and switched to VLD to check if the basic detector wasn't giving me false positive. I contacted Andrei to see if he could check it but he don't have VS2012 available so I setup some tests to isolate the problem. In the end of our exchange we concluded it was a false positive (it only leak on end of program). However it is still an annoying noise in the leak report logs, so people not understanding the source of this problem might be interested in this email. I attach the whole email exchange to this email, tell me if leak logs are necessary too. The last version of my test is at the end of the email (first program). Basically, the leak appear only when using std::async() in combination of boost::thread_specific_ptr : - using exclusively boost threading libraries (both with dynamic and static linking) result in no leak - using exclusively std threading libraries but not std::async() result in no leak - using std::async() result in a leak The second test program shows that using Intel Threading Building Blocks, I get leaks only if : - I use std::async() in combination with boost::thread_specific_ptr, as before (I mean I use tbb without a leak, then I add a std::async() call to the same task function and there is a leak) - I don't use std::async() but I don't manage the lifetime of tbb task scheduler We think the threads spawned by both tbb (that is supposed to be a superset of ppl) and std::async() (that is supposed to use ppl/concrt task scheduler) are not ended yet when the program reach the end of main (which seems logical as the task scheduler is then managed as a static global), making boost::thread_specific_ptr not release some data on thread destruction, as it is notified too late and any leak detection tool willl generate noise due to this. A way to fix this is to explicitely end the task scheduler, being tbb or ppl/concrt. I will use tbb task scheduler explicitely initialized/terminated in my project so it will solve the problem on my side. Joel Lamotte ------------------------------------ // this program was used to see the memory leak #define TEST_ASYNC // comment this to make it linear and not leak //#define WITH_BOOST_THREADS #define WITH_STD_ASYNC // uncomment this to leak //#define WITH_BOOST_LOG // boost log also leak if std::async is used #include <boost/thread.hpp> #ifdef WITH_BOOST_THREADS # include <boost/thread/future.hpp> # include <boost/chrono.hpp> # define THIS_THREAD boost::this_thread # define THREAD_LIB boost::thread # define CHRONO_LIB boost::chrono # define MY_FUTURE boost::future #else # include <future> # include <thread> # include <chrono> # define THIS_THREAD std::this_thread # define THREAD_LIB std::thread # define CHRONO_LIB std::chrono # define MY_FUTURE std::future #endif #ifdef WITH_BOOST_LOG # include <boost/log/trivial.hpp> # define MY_LOG BOOST_LOG_TRIVIAL(info) #else # include <iostream> # define MY_LOG std::cout << '\n' #endif #define BASIC_VS_LEAK_DETECTOR 0 #define VISUAL_LEAK_DETECTOR 1 #define LEAK_DETECTOR VISUAL_LEAK_DETECTOR #if LEAK_DETECTOR == BASIC_VS_LEAK_DETECTOR # define _CRTDBG_MAP_ALLOC # include <stdlib.h> # include <crtdbg.h> #else # include "vld.h" #endif struct my_data { char data[1024]; my_data() { MY_LOG << "CONSTRUCTOR my_data - " << THIS_THREAD::get_id(); } ~my_data() { MY_LOG << "DESTRUCTOR my_data - " << THIS_THREAD::get_id(); } }; boost::thread_specific_ptr< my_data > ts_ptr; void my_thread_foo() { ts_ptr.reset(new my_data()); } int work() { for( int i = 0; i < 42; ++i ) { MY_LOG << "THIS IS A MESSAGE - I = " << i; MY_LOG << "ts_ptr = " << ts_ptr.get(); my_thread_foo(); THIS_THREAD::sleep_for( CHRONO_LIB::milliseconds(10) ); } return 0; } int main(int argc, char *argv[]) { #if LEAK_DETECTOR == BASIC_VS_LEAK_DETECTOR // First simple memory leak detection for Visual Studio // use _crtBreakAlloc to put a breakpoint on the provided memory leak id allocation //_crtBreakAlloc = 1149; _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); #endif //int* k = new int[42]; // to check that memory leak detection does work MY_LOG << "Hello, World!"; #ifdef TEST_ASYNC # ifndef WITH_BOOST_THREADS std::vector< std::future<int> > work_in_progress(2); # ifdef WITH_STD_ASYNC for( auto& ftr : work_in_progress ) { ftr = std::async( work ); } # else for( auto& ftr : work_in_progress ) { std::packaged_task< int() > task(work); ftr = task.get_future(); std::thread thread( std::move(task) ); thread.detach(); } # endif for( auto& ftr : work_in_progress ) { ftr.get(); } # else std::vector< boost::unique_future<int> > work_in_progress(42); for( auto& ftr : work_in_progress ) { boost::packaged_task<int> task(work); // boost's packaged_task don't take the full signature as parameter, it takes the return type only ftr = task.get_future(); boost::thread thread( boost::move(task) ); thread.detach(); } for( auto& ftr : work_in_progress ) { ftr.get(); } # endif #else for( int i = 0; i < 42; ++i ) { work(); } #endif MY_LOG << "END"; return EXIT_SUCCESS; } -------------------------------------- // this program tests if the memory leaks appear with Threading Building Blocks #define BASIC_VS_LEAK_DETECTOR 0 #define VISUAL_LEAK_DETECTOR 1 #define LEAK_DETECTOR VISUAL_LEAK_DETECTOR #define WITH_ROOT_TASK //#define WITH_BOOST_LOG //#define WITH_STD_ASYNC // uncomment to leak #ifdef WITH_STD_ASYNC # include <future> #endif #include <thread> #include <atomic> #include <boost/thread.hpp> #include <tbb/tbb.h> #include <tbb/task_scheduler_init.h> #ifdef WITH_BOOST_LOG # include <boost/log/trivial.hpp> # define MY_LOG BOOST_LOG_TRIVIAL(info) #else # include <iostream> # define MY_LOG std::cout << '\n' #endif #if LEAK_DETECTOR == BASIC_VS_LEAK_DETECTOR # define _CRTDBG_MAP_ALLOC # include <stdlib.h> # include <crtdbg.h> #else # include "vld.h" #endif namespace test { struct my_data { char data[1024]; }; boost::thread_specific_ptr< my_data > ts_ptr; void my_thread_foo() { ts_ptr.reset(new my_data()); } class UpdateTask : public tbb::task { public: UpdateTask() : idx( s_idx++ ) { MY_LOG << "[UpdateTask " << idx << " ] " << std::endl; } ~UpdateTask() { MY_LOG << "[/UpdateTask " << idx << " ]" << std::endl; } tbb::task* execute() { MY_LOG << "[" << std::this_thread::get_id() << "] Tick "<< m_count <<std::endl; my_thread_foo(); ++m_count; if( m_count < 100 ) { // make sure this is re-executed this->increment_ref_count(); this->recycle_as_safe_continuation(); } return nullptr; } private: static std::atomic<int> s_idx; std::atomic<int> m_count; const int idx; }; std::atomic<int> UpdateTask::s_idx = 0; class TaskScheduler // using TBB { public: #ifdef WITH_ROOT_TASK TaskScheduler() : m_root_task( *new (tbb::task::allocate_root()) tbb::empty_task ) { m_root_task.increment_ref_count(); } ~TaskScheduler() { m_root_task.destroy(m_root_task); } #endif void register_update_task() { #ifdef WITH_ROOT_TASK m_root_task.increment_ref_count(); UpdateTask& updater = *new(m_root_task.allocate_child()) UpdateTask(); #else UpdateTask& updater = *new(tbb::task::allocate_root()) UpdateTask(); #endif m_task_list.push_back( updater ); } void run_and_wait() { #ifdef WITH_ROOT_TASK m_root_task.spawn( m_task_list ); m_root_task.wait_for_all(); #else tbb::task::spawn_root_and_wait( m_task_list ); #endif } private: tbb::task_list m_task_list; // uncomment the following line to not leak tbb //tbb::task_scheduler_init m_engine_instance; // We explicitly create and destroy the TBB task scheduler to avoid memory leak warning noises. #ifdef WITH_ROOT_TASK tbb::task& m_root_task; #endif }; void tbb_test() { TaskScheduler task_scheduler; for( int i = 0; i < 50; ++i ) { task_scheduler.register_update_task(); } task_scheduler.run_and_wait(); } } int main(int argc, char *argv[]) { #if LEAK_DETECTOR == BASIC_VS_LEAK_DETECTOR // First simple memory leak detection for Visual Studio // use _crtBreakAlloc to put a breakpoint on the provided memory leak id allocation //_crtBreakAlloc = 148; _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); #endif #ifdef WITH_STD_ASYNC std::atomic<bool> finished = false; std::async( [&]{ while( !finished ) { MY_LOG << "POP"; test::my_thread_foo(); std::this_thread::sleep_for( std::chrono::milliseconds(500) ); } } ); #endif test::tbb_test(); #ifdef WITH_STD_ASYNC finished = true; #endif MY_LOG << "\nEND"; std::this_thread::sleep_for( std::chrono::seconds(4) ); return 0; }

3 5

[thread] C++11 once_flag enabled when constexpr is not available
by Andrey Semashev 05 Mar '13

05 Mar '13

Hi, Vicente! I see you applied my patch for call_once but you seem to forgot to disable the C++11 call_once interface when the compiler does not support constexpr. Was that intentional or you just missed it? Anyway, please find the patch attached.

3 3

[locale] Composing asymmetric locale for character encoding conversion
by Andrey Semashev 05 Mar '13

05 Mar '13

Hi, Suppose I have a logging application that writes log records in wide (wchar_t, UTF-16) and narrow (char, UTF-8) encodings and I want these logs to be stored in a UTF-16LE encoded file. For simplicity, let's assume that I write log files with std::wofstream. Now, the standard says that the file stream buffer is supposed to convert wide characters to byte sequences using the locale imbued into the buffer. However, it seems that the locale should be the same as the one imbued into the stream (basic_ostream::imbue makes sure of that). What this leads to is that in order to achieve my goal the locale should be able to convert narrow characters of UTF-8 to wide characters of UTF-16 and wide characters of UTF-16 to narrow characters representing byte sequence of UTF16LE. Is it possible to make such an asymmetric locale with Boost.Locale? Or maybe there is another way of doing this? An additional question. Is it possible to to achieve my goal with std::ofstream (as opposed to std::wofstream)? I have a very strong suspicion that the answer is no because the narrow characters will pass on unconverted to the file instead of being translated from UTF-8 to UTF-16LE, but maybe I'm missing something. Thank you.

3 4

[coroutine] documentation comment
by Brian Wood 05 Mar '13

05 Mar '13

I wrote about this last month on Boost users but there wasn't a reply. I have a comment about a sentence on this page: http://www.boost.org/doc/libs/1_53_0/libs/coroutine/doc/html/coroutine/intr… "The principal difference between coroutines and routines is that a coroutine enables explicit suspend and resume their progress via additional operations by preserving local state ..." I'm wondering if it would be helpful to change that to this: The principal difference between coroutines and routines is that coroutines enable explicit suspend and resume of their progress via additional operations by preserving local state ... Shalom Brian Wood Ebenezer Enterprises http://webEbenezer.net (651) 251-9384

2 1

[tweener] Preliminary Submission
by Julien Jorge 05 Mar '13

05 Mar '13

Hello, I would like to propose the Boost.Tweener library for preliminary submission. The purpose of the Boost.Tweener library is to provide solutions to interpolate the intermediate values between two given values during a time interval. Various easing functions can be applied to control the computation of the intermediate values. I felt the need of such a library while developing games but I have also seen this need in various animation softwares. The library provides the following functionalities: - Interpolation is done on the value of a given variable or using an user-provided callback function, - The interpolated values are computed using a predefined easing function or any user-provided function respecting the contract, - Several tweeners can easily be executed simultaneously or in a row, - The type of the interpolated values are user defined. Please follow this link to download a Zip of the library: http://sourceforge.net/projects/libclaw/files/boost/boost-tweener-rc1.tar.g… Can you check that the library works as expected or tell me what should be fixed before submitting for review? There are various example programs in the archive. Regards, Julien Jorge

6 15

[thread] boost::thread and thread safety annotations
by Wladimir 04 Mar '13

04 Mar '13

Hello, The Clang C++ compiler project is currently working on a thread safety analyzer. By making use of so-called thread safety annotations within the source code, several problems with synchronization primitives can be found statically. For example: usage of a data structure without acquiring its guarding lock. See here for an overview of the available attributes: http://clang.llvm.org/docs/LanguageExtensions.html#threadsafety It is customary to use these attributes by defining macros, for compatibility: http://www.mail-archive.com/linuxkernelnewbies@googlegroups.com/msg01455.ht… At one time, it was also supposed to end up in G++, but this was abandoned in favor of clang (see http://gcc.gnu.org/wiki/ThreadSafetyAnnotation) But at least the annotations are fairly standardized. I think it would be useful to add these annotations to boost::thread, so that projects using that library can make use of the static checking. As I understand it, is only a matter of marking data structures that serve as lock/scoped_lock (such as boost::mutex, boost::recursive_mutex, ...), and methods that act upon the lock with the appropriate attributes. Any interest in this? Regards, Wladimir

2 1

[thread] barrier::wait() not marked as interruption_point
by Oliver Kowalke 04 Mar '13

04 Mar '13

In the documentation (1.53 beta) barrier::wait() is not marked as interruption-point nor that it will throw thread_interrupted if thread blocked inside barrier::wait() if it gets interrupted. Because barrier::wait() calls condition_variable::wait() and condition_variable::wait() is a interruption-point barrier::wait() should it be too - or do I miss something? Oliver

2 1

Re: [boost] [persistent] Library preview: Persistent
by Stefan Strasser 04 Mar '13

04 Mar '13

Am 04.03.2013 16:52, schrieb Jarrad Waterloo: > So if your library is in need, which it is, than release it, preferably > to boost under the boost license. You can always improve, add on latter. > You may solicit architecture and requirements from the list to increase > its usefulness and minimize rewrites. If you can't provide enough > manpower to complete it or even if you can, than solicit help. If four > people throughout the world can get it done in half the time of one > person than WOO HOO! There are many who would like to contribute from > the beginning, which also can't hurt acceptance. The important thing is > to have a vision, preferably shared, and to release something usable, > useful and working, as quickly as possible before interest dries up and > in a timely manner. > > Thanks for your remarks! Specifically for Persistent: > Have you considered an MVCC [option] where there are no updates from a > users perspective but are rather inserts; This sacrifices hard drive > space for a lock free/low lock database. yes, the entire storage backend is based on MVCC [1]. there currently is no lock-based option. objects are MVCC in memory for concurrency (see section "concurrent transactions" [2]), and on disk to achieve atomic updates. when an update is safely synced to disk the old object versions are discarded. I haven't written much about the backend in the documentation for two reasons: the interface is most important, and I actually don't think it would get used much in the long term. as much as I try to make it safe and efficient, a backend using an industrially proven storage engine like BerkeleyDB or SQLite would almost always be preferred, if the stored data has any value. I've written more about this in a previous reply to Klaim-Joël Lamotte in this thread. Would you like to share anything on the architecture of the interface? > Since you in some ways may be competing against relational databases by > making a object oriented database, maybe equivalent administrative > functionality are in order such as import and export into some textual > representations. > On a related note, ways to access system information such external > id/OIDS, timestamps, version numbers via an API for tooling and maybe > querying purposes > ?File format specifications? this and much more is certainly needed for database applications. but since we don't have the resources to implement an industrial-strength storage engine, my approach was to provide one "black-box" implementation for applications that would have used (boost.)serialization or other files otherwise, and provide resource managers using external databases later on. > > Concerning my interest, why haven't you given this to me two years ago, > how much longer must I wait. [Ha Ha Ha] *pointing to the copyright notice* :p Regards, Stefan [1] http://en.wikipedia.org/wiki/Multiversion_concurrency_control [2] https://svn.boost.org/svn/boost/sandbox/persistent/libs/persistent/doc/html…

2 1

Is there interest in a collection of call stack utilities?
by Aurelian Melinte 04 Mar '13

04 Mar '13

Hello, I have a collection of debugging/diagnostic utilities to inspect the run-time call stack and to resolve symbol information. The tools are currently C++11 code and support GNU-Linux and Windows. An overview is available at https://freeshell.de//~amelinte/call_stack_usage.html Is there interest for potential inclusion in boost? Thanks, Aurelian

9 15

[persistent] Library preview: Persistent
by Stefan Strasser 04 Mar '13

04 Mar '13

Hi everyone, I'm thinking about finishing a library that was proposed a couple of years ago. It was pretty far along, and there is documentation available in the sandbox (somewhat outdated): https://svn.boost.org/svn/boost/sandbox/persistent/libs/persistent/doc/html… It is a library with the goal of storing C++ objects on disk, with an interface that is as close as possible to accessing regular C++ objects in memory. A very simple example could look like this: shared_loc<person> p=...; { transaction tx; p->name="..."; p->address="..."; tx.commit(); } It is based on Boost.Serialization, but automatically maintains a consistent state on disk (ACID transactions), which can be updated incrementally. Part of its code was moved to a library named Transact to work alongside other transactional resources (like memory) and is available in the sandbox: https://svn.boost.org/svn/boost/sandbox/transaction/boost/transact/ I'd like to know whether the boost community is still interested in such a library, and I suppose there are quite a few new people here so your comments are welcome as well. Thank You!

6 9

[thread] why is 'thread_group' in 'boost/thread/detail'?
by pavel 03 Mar '13

03 Mar '13

as of 1.53 the docs say the 'thread_group' class is included by this instruction: #include <boost/thread/thread_group.hpp> http://www.boost.org/doc/libs/1_53_0/doc/html/thread/thread_management.html… whereas the actual file is not in the 'boost/thread', but accidentally is in 'boost/thread/detail' is that intentional? -- Pavel P.S. if you notice a grammar mistake or weird phrasing in my message please point it out

3 3