- Boost - lists.boost.org

[interprocess] [bimap] Using raw pointers
by Matias Capeletto 27 Jan '13

27 Jan '13

Hello, Currently Boost.Bimap does not work with interprocess allocators because it uses references to connect the views and the core. I want to change this but avoid any performance hit and I am wondering what is the best way to do it. It will be easy if Bimap interface will use .left() and .right() functions to access the map views (then I could just init the views at each call like Boost.MultiIndex get() index function does) but I am stuck with the left and right members (and I actually like them). So, what I want to be able to do is the following: template<class Bimap> class left_type { Bimap* core; public: left_type(Bimap* c) : core(c) {}; ... }; template<class Bimap> class right_type {...}; template<class LeftKey,class RightKey> class bimap { public: left_type<bimap> left; right_type<bimap> right; bimap() : left(this), right(this) {} }; This will not work because I am not using the proper offset_pointer abstraction, but I would love to be able to avoid it. In the case of Bimap, these pointers are very easy to maintain. Will it be possible to add an extension point to Boost.Interprocess to allow this idiom? Something like adding a call to the end of priv_find_impl of segment_manager so user classes can rewire themselves when they are loaded from shared memory. For example: template<class T> void rewire_after_loading_from_shared_memory(T* t) { } ... template <class T> std::pair<T*, size_type> priv_find_impl (const CharType* name, bool lock) { // find ret pointer T* t_ret = static_cast<T*>(ret) ; if( t_ret ) rewire_after_loading_from_shared_memory( t_ret ); return std::pair<T*, size_type>(t_ret ,sz); } ... Or maybe a better place. Then I will be able to rewire the map views pointers to the core if they are different from it: template<class L, class R> void rewire_after_loading_from_shared_memory(bimap<L,R>* t) { t->rewire(); } If this is not possible because inherent limitations of the interprocess mechanisms, do you know a good way to make Boost.Bimap compatible with its allocators? Thanks, Best regards Matias

3 12

program_options: Support for open-end options
by ST 27 Jan '13

27 Jan '13

Hi, It would be great to implement support for open-end options, something like that: item_1 = 23 item_2 = 45 ... item_N = 465 The idea is to to be able to provide following input: configOptions.add_options() ("item_", value<int>(), "items"); now if add_options() sees a key that ends with a "_" it accepts all options with keys that start with item_, no matter what comes after it, and treat all of them as int . Nesting should also be possible - like this: "item_.subitem_.subsubitem_" (item_3.subitem_FOO.subsubitem_34 should be a valid option key). I can try to implement it, however only if it will have a chance to be merged into the boost library. Whom should I contact regarding this? Thank you, Simone

5 13

New algorithm in Boost.Algorithm: "gather" -- looking for comments
by Marshall Clow 27 Jan '13

27 Jan '13

I have committed a new algorithm named "gather" into Boost.Algorithm. Actually, it's one I wrote for Sean Parent as part of ASL about five years ago, and it's the first (of hopefully many) of the bits oF ASL to be moved into boost. Here's a summary: gather() takes a collection of elements defined by a pair of iterators and moves the ones satisfying a predicate to them to a position (called the pivot) within the sequence. The algorithm is stable. The result is a pair of iterators that contains the items that satisfy the predicate. template <typename ForwardIterator, typename Pred> std::pair<ForwardIterator,ForwardIterator> gather ( ForwardIterator first, ForwardIterator last, ForwardIterator pivot, Pred pred ); Given an sequence containing: int [] arr = { 0 1 2 3 4 5 6 7 8 9 }; A call to gather ( arr, arr + 10, arr + 4, IsEven) will result in: 1 3 0 2 4 6 8 5 7 9 |---|-----| first | second pivot where first and second are the fields of the pair returned by the call. -- Marshall Marshall Clow Idio Software <mailto:mclow.lists@gmail.com> A.D. 1517: Martin Luther nails his 95 Theses to the church door and is promptly moderated down to (-1, Flamebait). -- Yu Suzuki

8 12

[context] permission to merge to release
by Oliver Kowalke 26 Jan '13

26 Jan '13

I'd like to ask to merge boost.context to boost.release - adding support for SPARC. Unfortunately we have no regression tests on trunk/release but I got the info that the code in trunk works for 32bit/64bit SPARC. regards, Oliver

2 1

[1.53.0] Release Notes
by Daniel James 26 Jan '13

26 Jan '13

Hello everyone, Please can you send me your library's release notes for 1.53. Or if you prefer you can add them yourself to: http://svn.boost.org/svn/boost/website/public_html/live/feed/history/boost_… thanks, Daniel

9 13

[utility] base_from_member variadic template error on gcc-4.6.0 c++0x
by Vicente Botet 26 Jan '13

26 Jan '13

Hi, I'm getting the following compiler error. gcc.compile.c++ ..\..\..\bin.v2\libs\chrono\test\stopwatch_reporter_example_h.test\gcc-mingw-4.6.0x\debug\stopwatch_reporter_example.o In file included from ..\..\../boost/format/alt_sstream.hpp:20:0, from ..\..\../boost/format/internals.hpp:23, from ..\..\../boost/format.hpp:38, from ..\..\../boost/chrono/stopwatches/formatters/elapsed_formatter.hpp:13, from ..\..\../boost/chrono/stopwatches/reporters/clock_default_formatter.hpp:11, from ..\..\../boost/chrono/stopwatches/reporters/stopwatch_reporter_default_formatter.hpp:11, from ..\..\../boost/chrono/stopwatches/reporters/stopwatch_reporter.hpp:23, from ..\example\stopwatch_reporter_example.cpp:10: ..\..\../boost/utility/base_from_member.hpp: In constructor 'boost::io::basic_oaltstringstream<Ch, Tr, Alloc>::basic_oaltstringstream(boost::io::basic_oaltstringstream<Ch, Tr, Alloc>::stringbuf_t*) [with Ch = char, Tr = std::char_traits<char>, Alloc = std::allocator<char>, boost::io::basic_oaltstringstream<Ch, Tr, Alloc>::stringbuf_t = boost::io::basic_altstringbuf<char, std::char_traits<char>, std::allocator<char> >]': ..\..\../boost/format/feed_args.hpp:175:57: instantiated from 'void boost::io::detail::put(T, const boost::io::detail::format_item<Ch, Tr, Alloc>&, typename boost::basic_format<Ch, Tr, Alloc>::string_type&, typename boost::basic_format<Ch, Tr, Alloc>::internal_streambuf_t&, boost::io::detail::locale_t*) [with Ch = char, Tr = std::char_traits<char>, Alloc = std::allocator<char>, T = const boost::io::detail::put_holder<char, std::char_traits<char> >&, typename boost::basic_format<Ch, Tr, Alloc>::string_type = std::basic_string<char>, typename boost::basic_format<Ch, Tr, Alloc>::internal_streambuf_t = boost::io::basic_altstringbuf<char, std::char_traits<char>, std::allocator<char> >, boost::io::detail::locale_t = std::locale]' ..\..\../boost/format/feed_args.hpp:286:17: instantiated from 'void boost::io::detail::distribute(boost::basic_format<Ch, Tr, Alloc>&, T) [with Ch = char, Tr = std::char_traits<char>, Alloc = std::allocator<char>, T = const boost::io::detail::put_holder<char, std::char_traits<char> >&]' ..\..\../boost/format/feed_args.hpp:296:9: instantiated from 'boost::basic_format<Ch, Tr, Alloc>& boost::io::detail::feed_impl(boost::basic_format<Ch, Tr, Alloc>&, T) [with Ch = char, Tr = std::char_traits<char>, Alloc = std::allocator<char>, T = const boost::io::detail::put_holder<char, std::char_traits<char> >&]' ..\..\../boost/format/feed_args.hpp:308:95: instantiated from 'boost::basic_format<Ch, Tr, Alloc>& boost::io::detail::feed(boost::basic_format<Ch, Tr, Alloc>&, T) [with Ch = char, Tr = std::char_traits<char>, Alloc = std::allocator<char>, T = const boost::io::detail::group1<boost::io::detail::group4<std::ios_base& (*)(std::ios_base&), std::_Setprecision, boost::chrono::duration_fmt, const boost::chrono::duration<double, boost::ratio<1ll, 1000ll> >&> >&]' ..\..\../boost/format/format_class.hpp:64:74: instantiated from 'boost::basic_format<Ch, Tr, Alloc>& boost::basic_format<Ch, Tr, Alloc>::operator%(const T&) [with T = boost::io::detail::group1<boost::io::detail::group4<std::ios_base& (*)(std::ios_base&), std::_Setprecision, boost::chrono::duration_fmt, const boost::chrono::duration<double, boost::ratio<1ll, 1000ll> >&> >, Ch = char, Tr = std::char_traits<char>, Alloc = std::allocator<char>, boost::basic_format<Ch, Tr, Alloc> = boost::basic_format<char>]' ..\..\../boost/chrono/stopwatches/formatters/elapsed_formatter.hpp:83:9: instantiated from 'void boost::chrono::basic_elapsed_formatter<Ratio, CharT, Traits, Alloc>::operator()(Stopwatch&) [with Stopwatch = boost::chrono::basic_stopwatch_reporter<char, boost::chrono::strict_stopwatch<boost::chrono::steady_clock>, boost::chrono::basic_elapsed_formatter<boost::ratio<1ll, 1000ll>, char> >, Ratio = boost::ratio<1ll, 1000ll>, CharT = char, Traits = std::char_traits<char>, Alloc = std::allocator<char>]' ..\..\../boost/chrono/stopwatches/reporters/stopwatch_reporter.hpp:88:9: instantiated from 'void boost::chrono::basic_stopwatch_reporter<CharT, Stopwatch, Formatter>::report() [with CharT = char, Stopwatch = boost::chrono::strict_stopwatch<boost::chrono::steady_clock>, Formatter = boost::chrono::basic_elapsed_formatter<boost::ratio<1ll, 1000ll>, char>]' ..\..\../boost/chrono/stopwatches/reporters/stopwatch_reporter.hpp:82:11: instantiated from 'boost::chrono::basic_stopwatch_reporter<CharT, Stopwatch, Formatter>::~basic_stopwatch_reporter() [with CharT = char, Stopwatch = boost::chrono::strict_stopwatch<boost::chrono::steady_clock>, Formatter = boost::chrono::basic_elapsed_formatter<boost::ratio<1ll, 1000ll>, char>]' ..\..\../boost/chrono/stopwatches/reporters/stopwatch_reporter.hpp:127:11: instantiated from here ..\..\../boost/utility/base_from_member.hpp:135:55: sorry, unimplemented: use of 'type_pack_expansion' in template "c:/MINGW/gcc-4.6.0S/bin/g++" -ftemplate-depth-128 -std=c++0x -O0 -fno-inline -Wall -pedantic -g -Wextra -Wno-long-long -pedantic -DBOOST_ALL_NO_LIB=1 -DBOOST_CHRONO_HEADER_ONLY -DBOOST_CHRONO_USES_MPL_ASSERT -DBOOST_CHRONO_VERSION=2 -DBOOST_ERROR_CODE_HEADER_ONLY -DBOOST_SYSTEM_NO_DEPRECATED -I"..\..\.." -c -o "..\..\..\bin.v2\libs\chrono\test\stopwatch_reporter_example_h.test\gcc-mingw-4.6.0x\debug\stopwatch_reporter_example.o" "..\example\stopwatch_reporter_example.cpp" Is this a know issue? Best, Vicente -- View this message in context: http://boost.2283326.n4.nabble.com/utility-base-from-member-variadic-templa… Sent from the Boost - Dev mailing list archive at Nabble.com.

3 2

boost::bimap and boost::interprocess
by Joel Young 25 Jan '13

25 Jan '13

I've been trying to get boost::bimap to work in a boost::interprocess::managed_mapped_file. I've attached two small programs. Both compile with g++ 4.7. One (multiindex.c++) puts a multi_index into the managed_mapped_file. On the first run, it creates the data structure puts some stuff in it, then reopens the data structure and outputs the stuff. On the second run, it does the same thing, but it uses the data stored in the mapped file. The other program (bimap.c++) does exactly the same thing, but when run the second time it crashes. My guess is because bimap isn't quite interprocess compatible---that is, it isn't using the provided allocator for EVERYTHING. Compiled with: g++ -o multiindex multiindex.c++ -lpthread and g++ -g -o bimap bimap.c++ -lpthread Any suggestions? Any chance of bimap being made interprocess compatible? Thanks! Joel

3 5

Proposal: boost::make_array()
by Kyle Lutz 25 Jan '13

25 Jan '13

I'd like to propose a new function for the Boost Array library named make_array(). The function constructs a fixed size array given N arguments and is similar to the make_pair() and make_tuple() functions. Interface: The make_array() function provides the following interface: template<class T> boost::array<T, N> make_array(...) where the '...' indicates N arguments. If no type T is passed explicitly it is deduced from the type of the first argument. The function requires that all of the arguments must be convertible (via static_cast<>) to type T. Example: // create 2-component array of type int boost::array<int, 2> a = boost::make_array(4, 2); // create 3-component array of type float given int arguments boost::array<float, 3> b = boost::make_array<float>(1, 2, 3); // create 4-component array of doubles using C++11 auto auto c = boost::make_array(2.0, 4.0, 6.0); Implementation: make_array() has two separate implementations: one for compilers with support for C++11 variadic templates and a fallback implementation for those which do not. The C++11 variadic template implementation supports any arbitrary number of arguments to create arrays of any size. The fallback implementation makes use of Boost.Preprocessor to define N overloads taking 0...N arguments where N is set at compile time using the BOOST_MAKE_ARRAY_MAX_ARITY macro (with a default value of 10). The implementation has been compiled and tested with both g++-4.8 and clang++-3.0 in C++03 and C++11 modes. The code is available on github at https://github.com/kylelutz/make_array Any feedback is greatly appreciated. Thanks, Kyle

11 21

Boost Support for Android and iOS
by rohit dhamija 25 Jan '13

25 Jan '13

Hi, Boost libraries are intended to be widely useful, and usable across a broad range of applications, but yet there is no official support available for Android and iOS 1. Is there any specific reason behind the same (like not optimized for embedded devices)? Or any other reason? 2. Are there (at all) any known issues if we use boost libraries for networking and thread synchronization for Smartphone application development ? Will it be a good idea to use BOOST ASIO for the same? I found some articles to compile boost but it would be great if we have some official links. FYI are the links found https://github.com/MysticTreeGames/Boost-for-Android http://www.codexperiments.com/android/2011/05/tips-tricks-building-boost-wi… RDX

10 10

[lockfree] crash in queue
by Christophe Henry 25 Jan '13

25 Jan '13

Hi Tim, I tried using lockfree::queue but I keep getting a crash. My configuration: boost 1.53 beta1, g++ 4.5 / clang (from trunk, a few weeks old), both in c+11, i7 6 cores / 12 threads. My test program is pretty much your example, except that my data is not an int but a boost::function. As a note, the crash seems to happen only when I have many consumers. Many producers and one consumer seem to be ok. Am I doing something wrong? Thanks, Christophe #include <boost/thread/thread.hpp> #include <boost/lockfree/queue.hpp> #include <boost/function.hpp> #include <boost/atomic.hpp> boost::lockfree::queue<boost::function<void()> > lfqueue(10000); boost::atomic<bool> done (false); struct empty_task { void operator()()const { } }; void producer(void) { for (int i = 0; i != 10000000; ++i) { boost::function<void()> task = empty_task(); while (!lfqueue.push(task)) { boost::this_thread::yield(); } } } void consumer() { while (!done) { boost::function<void()> res; if (!lfqueue.pop(res)) { boost::this_thread::yield(); } else { res(); } } } void test_lockfree_queue() { boost::thread_group producer_threads, consumer_threads; for (int i = 0; i != 1; ++i) producer_threads.create_thread(producer); for (int i = 0; i != 12; ++i) consumer_threads.create_thread(consumer); producer_threads.join_all(); done = true; consumer_threads.join_all(); } int main() { test_lockfree_queue(); return 0; }

3 6