March 2018 - Boost-users - lists.preview.boost.org

[interprocess] Determine size of managed_shared_memory
by Kai Benndorf 12 Oct '19

12 Oct '19

Hi all, I want to create a managed_shared_memory in exactly the size I needed. Therefore I do something like this: size = sizeof( common_managed_shared_memory ); size += sizeof( MyClassInSharedMem ); managed_shared_memory segment(create_only, "name", size ); MyClassInSharedMem allocates itself some memory by segment->allocate(). I added this also to the size, but get a boost::interprocess::bad_alloc exception on allocating this additional memory. Are there some magic bytes I forgot to add? Many thanks in advance Kai

3 2

boost::filtered_graph filtering on vertex color... if I only had a colormap
by Brian Davis 19 Jul '19

19 Jul '19

Lets say I have a graph g (of type graph_t) and a color map (boy I wish I had a colormap): typedef boost::property_map<graph_t, boost::vertex_color_t>::type color_map_t; or is it? auto indexmap = boost::get(boost::vertex_index, g); auto colors = boost::make_vector_property_map<boost::default_color_type>(indexmap); or maybe? auto indexmap = boost::get(boost::vertex_index, g); auto colors = boost::make_vector_property_map<boost::vertex_color_t>(indexmap); or possibly some goop found on the internet? boost::make_iterator_property_map(color_map.begin(), boost::get(boost::vertex_index, data_->g), color_map[0]) or other internet goop? typedef boost::property_map<GraphType, boost::vertex_color_t>::type color_map_t; color_map_t colorMap; boost::color_map(colorMap)) or other internet goop?? std::vector<int> colorMap(num_vertices(g), boost::white_color); so confused... (certainly not surprised why bgl is not a part of stl) Can someone help explain the various types and ways of specifying colormaps and the logic for each way and means? and a function (if I could get that far without VS syntax highlighter going bonkers and gobs of compiler errors.. you know the type): make_pretty(g, colormap ) which colors the graph colormap and a filter struct for boost::filtered_graph<Graph, EdgePredicate, VertexPredicate> (where I wonder why if I only want to filter vertices I have to set boost::keep_all for EdgePredicate... sigh... I know the answer... and also know how long it found me to find/figure out boost::keep_all - and if you are looking for boost::keep_all and found it here... your welcome ;-) ) and modifying (probably incorrectly) boost::filtered_graph example to: template <typename ColorMap> struct vertex_color_filter_eq { vertex_color_filter_eq() { } vertex_color_filter_eq(ColorMap colormap/*, boost::default_color_type c*/) : m_colormap(colormap)/*, m_c(c)*/ { } template <typename Vertex> bool operator()(const Vertex& v) const { return 0 < get(m_colormap, v); //return c < get(m_colormap, v); } ColorMap m_colormap; //boost::default_color_type m_c; }; auto indexmap = boost::get(boost::vertex_index, g); auto colors = boost::make_vector_property_map<boost::default_color_type>(indexmap); // some where here I would call make_pretty(g, colors) typedef property_map<graph_t, boost::vertex_color_t>::type ColorMap_t; vertex_color_filter<ColorMap_t> filter(colors); // boost::filtered_graph<graph_t, boost::keep_all, VertexPredicate> boost::filtered_graph<graph_t, boost::keep_all, vertex_color_filter> fg(g, filter); // Later say if I could get it compile and better if it compiled and worked I could move on and auto color = boost::red_color; typedef property_map<graph_t, boost::vertex_color_t>::type ColorMap_t; vertex_color_filter<ColorMap_t> filter(colors, color); boost::filtered_graph<graph_t, boost::keep_all, vertex_color_filter> fg(g, filter); Maybe if I color them yellow, I can then reach the wizard pull back the curtain and ask how to create a color map... If I only had a color map.

4 6

[Test] Test executable crashes always
by Nate Widmyer 26 Jun '18

26 Jun '18

Hello, I've made some unit tests with boost test before without issue, but on my latest rather ordinary test, I've been able to get Boost test to crash the executable in debug and release mode when boost test is making a report before terminating. test_exe.exe!boost::unit_test::framework::get(unsigned long id, boost::unit_test::test_unit_type t) Line 1388 C++ test_exe.exe!boost::unit_test::framework::get<boost::unit_test::test_unit>(unsigned long id) Line 208 C++ test_exe.exe!boost::unit_test::results_reporter::make_report(boost::unit_test::report_level l, unsigned long id) Line 175 C++ test_exe.exe!boost::unit_test::unit_test_main(boost::unit_test::test_suite *(*)(int, char * *) init_func, int argc, char * * argv) Line 235 C++ test_exe.exe!main(int argc, char * * argv) Line 287 C++ That's the default report_level of 'confirm' If I use report_level=short or detailed, I get a similar crash: test_exe.exe!boost::unit_test::framework::get(unsigned long id, boost::unit_test::test_unit_type t) Line 1388 C++ test_exe.exe!boost::unit_test::framework::get<boost::unit_test::test_suite>(unsigned long id) Line 207 C++ test_exe.exe!boost::unit_test::traverse_test_tree(unsigned long id, boost::unit_test::test_tree_visitor & V, bool ignore_status) Line 365 C++ test_exe.exe!boost::unit_test::results_reporter::make_report(boost::unit_test::report_level l, unsigned long id) Line 185 C++ test_exe.exe!boost::unit_test::unit_test_main(boost::unit_test::test_suite *(*)(int, char * *) init_func, int argc, char * * argv) Line 235 C++ test_exe.exe!main(int argc, char * * argv) Line 287 C++ Here's the get() method: test_unit& get( test_unit_id id, test_unit_type t ) { test_unit* res = impl::s_frk_state().m_test_units[id]; BOOST_TEST_I_ASSRT( (res->p_type & t) != 0, internal_error( "Invalid test unit type" ) ); return *res; } Crash occurs on line 2 of the function. I logged 'res' each time the function is called and many times its valid, but when it runs this one test (by itself or with others), 'res' always ends up being NULL. id seems to always be '1', and t is TUT_ANY (17) if generating a confirmation report or TUT_SUITE (16) if generating a short or detailed report. If I use the option '--report_level=no', then execution does complete fine. I followed through on some process of elimination and it seems to be related to using a fixture? Having no test body still causes the crash. It wasn't until I removed the fixture (and its usage in the body of the test) did the executable not crash. I ensured that I was using the standard fixture model found here: http://www.boost.org/doc/libs/1_64_0/libs/test/doc/html/boost_test/tests_or… OS is Win 7 w/ VS2015 boost is 1.64.0 and was built with: b2 toolset=msvc-14.0 link=static runtime-link=static variant=debug address-model=64 --without-atomic --without-container --without-context --without-coroutine --without-coroutine2 --without-graph --without-graph_parallel --without-iostreams --without-locale --without-math --without-mpi --without-serialization --without-signals --without-type_erasure --without-wave -j4 --abbreviate-paths --without-python -d2 Any help would of something to look at or change would be appreciated. Thanks for your time, Nathan

2 4

[release] Boost 1.67.0 Beta 1
by Daniel James 07 Apr '18

07 Apr '18

Boost release 1.67.0 beta 1 is now available at: <https://dl.bintray.com/boostorg/beta/1.67.0.beta.1/source/> The SHA256 checksums are as follows: 154cf490da858fd9c2307bb904b07a42cbe8355ecf99d5477f0d843c6d03cdda boost_1_67_0_b1.7z 0d854b208fefaeb5837d6c417f505b189275e32d017f6226001fb165a5ac51ed boost_1_67_0_b1.tar.bz2 6eb3f9ca8db355765f41361e1e26976228f0c2dff400aade8a5e97aec6aa59f4 boost_1_67_0_b1.tar.gz 678a6459f2517932536ec97297be1de46ea073f2e2ee17ec8397b80aa0953f49 boost_1_67_0_b1.zip For details of what's in the release, see <http://www.boost.org/users/history/version_1_67_0.html>. Please download the beta, give it a try, and report any problems you encounter. Thanks, -- The Boost Release Team

9 14

Pointer Container Library changes in 1.66.0
by Kevin Hardman 06 Apr '18

06 Apr '18

I am seeing changes in the Pointer Container Library that are preventing my existing application from compile. I see no notice of changes in the 1.66.0 release notes <http://www.boost.org/users/history/version_1_66_0.html <http://www.boost.org/users/history/version_1_66_0.html>>. Is there documentation on the changes and what is required to migrate existing users to the new library? —kevin

5 10

[ptr_map] Warning about returning address of local variable
by Bill Buklis 05 Apr '18

05 Apr '18

I'm not sure if this a potential bug/problem or just a benign warning, but when using the map_values range adaptor with a ptr_map container I get a warning about returning an address of a local variable. It seems benign as the expected processing happens, but this type of warning generally doesn't sound like a good thing. The following useless code will trigger it. #include <boost/ptr_container/ptr_map.hpp> #include <boost/range/algorithm.hpp> #include <boost/range/adaptors.hpp> struct sample { int value; }; typedef boost::ptr_map<int, sample> themap; int main() { themap data; int key = 5; data.insert(key, new sample); boost::for_each(data | boost::adaptors::map_values, [](sample* s) { s->value = 10; }); return 0; } I'm using Visual Studio 2017. I also have conformance mode (/permissive-) turned on for stricter language compliance in case it makes a difference. As an aside, I was a little surprised when trying out this little sample that the inclusion of the above headers is enough to require linking with the boost regex library. I figure it's probably a reference in the adaptors somewhere. It's not a big deal. These lib files are normally available anyway. -- Bill

2 1

Crossbuilding for ARM
by Mats Webjörn/WIKAB 30 Mar '18

30 Mar '18

I'm trying to build for ARM, and have some problems in making b2 find user-config.jam when it's located outside boost root dir. First I go to boost/tools/build and run ./b2 install -prefix=/home/administrator/project/myproj/build/boost Then I run ./b2 toolset=gcc-arm --build-dir=/home/administrator/project/myproj/build/boost stage According to http://www.boost.org/build/doc/html/bbv2/overview/configuration.html Boost.Build<http://www.boost.org/build/doc/html/bbv2/overview/configuration.html%20Boos…> will search $HOME and $BOOST_BUILD_PATH, but if I add --debug-configuration to b2 command then I can see that it searches '/home/administrator' = $HOME '/home/administrator/project/myproj/externals/boost/tools/build/src/kernel' '/usr/share/boost-build' '/home/administrator/project/myproj/externals/boost/tools/build/src/kernel' '/home/administrator/project/myproj/externals/boost/tools/build/src/util' '/home/administrator/project/myproj/externals/boost/tools/build/src/build' '/home/administrator/project/myproj/externals/boost/tools/build/src/tools' '/home/administrator/project/myproj/externals/boost/tools/build/src/contrib' '/home/administrator/project/myproj/externals/boost/tools/build/src/.'. Where none of the directories searched is the one I've provided as buid directory. It seems odd that $BOOST_BUILD_PATH should be "the one in the top-level directory of your Boost.Build installation" since http://www.boost.org/build/doc/html/bbv2/overview/invocation.html describes --build-dir as "the build directories for all project roots being built". It seems like the documentation isn't correct. I'm just not sure which one is right and which is wrong. Has anyone crossbuilt for ARM on Linux? Regards Mats Webjörn E-Mail: konsult(a)webjorn.com Webjörn IngenjörsKonsult AB Tel +46 8 584 238 80 Solhemsbackarna 75A Fax +46 8 445 69 21 SE-163 56 SPÅNGA Mobil +46 70 639 16 99 Sweden

1 0

[Boost::Test] short form of catch_system_errors not working
by Konstantin Kivi 30 Mar '18

30 Mar '18

Occasionally I need a core dump if testing goes wrong. Boost test have the following option ------------ Parameter: catch_system_errors Allows to switch between catching and ignoring system errors (signals). Command line formats: --[no_]catch_system_errors[=<boolean value>] -s[ <boolean value>] ------------------- I never managed to get short options to work and has to search for a long option exact name. Neither '-s no', '-s false' , -sno with or without quotes are not accepted. examples ----- $ test_app -s no Boost.Test WARNING: token "no" does not correspond to the Boost.Test argument and should be placed after all Boost.Test arguments and the -- separator. For example: test_app --random -- no ------ $ test_app "-s no" Invalid separator for the parameter catch_system_errors in the argument -s no ----- Is it a known bug? Best regards, Konstantin

2 1

[boost][interprocess] Need clarification on file_lock documentation
by Rob Conde 29 Mar '18

29 Mar '18

The documentation of boost::interprocess::file_lock has some cautions on synchronization limitations: * It's unspecified if a file_lock synchronizes two threads from the same process. * It's unspecified if a process can use two file_lock objects pointing to the same file. But then gives the guidance: * For each file, use a single file_lock object per process. * Use the same thread to lock and unlock a file. I then created the following example: <https://wandbox.org/permlink/dO2rRDCHVWBE3pGr>https://wandbox.org/permlink/3CNfkA3RcMkwbd2v #include <fstream> #include <iostream> #include <cstdlib> #include <boost/interprocess/sync/file_lock.hpp> #include <boost/interprocess/sync/scoped_lock.hpp> #include <boost/filesystem.hpp> #include <mutex> #include <thread> #include <chrono> int main() { std::ofstream("f.txt"); boost::interprocess::file_lock lock("f.txt"); std::mutex mtx; const size_t max = 100; size_t t1Count = 0; std::thread t1 ( [&lock,&t1Count,&mtx,max]() { while(t1Count < max) { //std::lock_guard<std::mutex> mtxLock(mtx); boost::interprocess::scoped_lock<boost::interprocess::file_lock> guard(lock); std::cout << "Number 1" << std::endl; t1Count++; std::this_thread::sleep_for(std::chrono::milliseconds(1)); } } ); size_t t2Count = 0; std::thread t2 ( [&lock,&t2Count,&mtx,max]() { while(t2Count < max) { //std::lock_guard<std::mutex> mtxLock(mtx); boost::interprocess::scoped_lock<boost::interprocess::file_lock> guard(lock); std::cout << "Number 2" << std::endl; t2Count++; std::this_thread::sleep_for(std::chrono::milliseconds(1)); } } ); t1.join(); t2.join(); return 0; } It only works properly if the std::mutex is used in addition to the file_lock. That was originally my thought when I read "It's unspecified if a file_lock synchronizes two threads from the same process.", but it seemed like I was following the guidance "Use the same thread to lock and unlock a file.". If I haven't messed anything up, I would probably update the documentation to say something like: "If utilitizing the file_lock from multiple threads within the same process, synchronize access to the file_lock with an intraprocess synchronization mechanism such as a mutex." Otherwise, is it a bug? Thanks, Rob

1 0

[beast] Custom, application specific header
by DePizzottri 28 Mar '18

28 Mar '18

Hi, I need to send custom application specific header in the response, but http::response operates only with set of predefined http::field values. Does anyone know how can I set custom field without implementing own `fields` class? Or is there any tips or example how can it be implemented (I know about Fields/FieldsWriter concepts)? -- Sent from: http://boost.2283326.n4.nabble.com/Boost-Users-f2553780.html

2 3

boost::dll in cygwin
by Matthew von Arx 27 Mar '18

27 Mar '18

Has anyone tried using the boost::dll library in cygwin? Boost attempts to load <link.h> which is not applicable to a Cygwin system. Is there any way to #define an option so that the boost::dll library will operate in this mixed windows/linux-like environment? Thanks, -- Matthew von Arx Electromechanical Engineer (C) 678-953-1752

2 1

Boost managed memory files
by Assaf Ben-amitai 26 Mar '18

26 Mar '18

Hi, I'm a user of boost interprocess managed memory file. I'm facing the follwing issue - it seems that if a process fails while allocating memory from a managed file, the internal data-structures may corrupt , making the managed file becomes unuseable. Does anyone have any info on efforts / projects to improve on this situation? Thx, Assaf

1 0

boost::asio blocking socket read with timeout with multiple threads
by tom＠quarendon.net 24 Mar '18

24 Mar '18

I've got a boost::asio based server, and generally it's working well. The server runs multiple threads, each simply running the io_service::run method on the same io_service object. It accepts multiple connections and processes multiple concurrent sockets. It uses a strand per connection to ensure that the data for each connection is processed strictly sequentially. For various reasons it uses a mixture of async and sync reads. The trouble I'm having is implementing a timeout on the synchronous (blocking) reads. I want to protect the server in the case of a client sending an erroneous or malicious packet for example, and make sure a read doesn't block forever. There was a post back in 2007 that gave a technique (https://lists.boost.org/Archives/boost/2007/04/120339.php) There's a stack overflow question that references that (https://stackoverflow.com/questions/13126776/asioread-with-timeout) There are some examples in the docs that perform a similar kind of technique. In the examples, the server is all asynchronous. The client is synchronous, but only uses one thread. The example from 2007 also only uses one thread. The examples all revolve around the technique of starting an *async* read, then performing a nested loop of io_service::run_one. However, so far I've been unable to find a form of code that works reliably in a multithreaded environment. The basis for my experimentation is here: https://gist.github.com/anonymous/1160c11f8ed9c29b9184325191a3a63b It starts a server thread, then starts a client that makes a connection and then writes nothing, to simulate a "bad" client and to provoke a "timeout" condition. What I'm finding is this: With one server thread I can make it work OK. The nested loop of "run_one()" operates correctly. With multiple server threads though, I can't make it work reliably. The basis of the loop is: bool timedOut = false; bool readComplete = false; timer.async_wait(strand_.wrap(boost::bind(&handleReadTimeout, &timedOut, &socket_, _1))); async_read(socket_, buffer(b), strand_.wrap(boost::bind(handleReadComplete, &ec, &bytesRead, &readComplete, &timer, _1, _2))); while (socket_.get_io_service().run_one()) { if (timedOut && readComplete) { break; } } handleReadTimeout sets the timedOut flag to true and calls "cancel" on the socket. The handleReadComplete callback sets readComplete to true and calls cancel on the timer. With multiple threads, the handleReadTimeout/handleReadComplete callbacks are run on other threads. So the while loop here just blocks, as there is never anything to run. That's my surmise of what's going on anyway. I've experimented with strands to try and force it all onto the same thread, but so far failed (if the above code is called in the context of the same strand, it just seems to block the handleReadTimeout and handleReadComplete callbacks from being called). Note that if I expend my example to include other clients talking to a simple "echo" service to simulate other traffic, then the while loop above *does* wake, as that other traffic gives it something to do. But that's fragile. The alternative formulation, the one I started with actually, is to do an async wait on the timer, and a normal synchronous read on the socket. The timer callback performs a cancel (or close -- I tried both) on the socket hoping to cause the socket read to error. This is the kind of thing you'd do if you were programming raw sockets. That works fine on Windows, but won't work on Linux. The documentation for cancel does say it cancels any outstanding *async* calls, but I'm surprised calling close doesn't work and cause the read to wake. So I'm stuck. I was hoping someone here could point me in the right direction, as it seems an obvious thing (to me) to want try and do. Is there a form of code that allows me to perform a synchronous read from a socket and time it out, which will work in a multi threaded/single io service environment? This is all with boost 1.64 by the way. Thanks for any help in advance.

6 27

Re: [Boost-users] boost::asio blocking socket read with timeout with multiple threads
by tom＠quarendon.net 23 Mar '18

23 Mar '18

> You're right. That poll_read loop consumes the alarm :/ > > So then i think the fallback has to be a raw Berkley sockets read against > the native_handle(), with a signal to cause the EINTR. Yes, and I've tried basically that method earlier. It works fine, as long as you don't want to use the SSL wrapper, which is what I ultimately want to do. Of course there, you don't have the control to do that. Well, I could write my own socket class variant and wrap that in the SSL wrapper, but that's daft. You can't "test" the socket by using a poll with a timeout, because there may be unprocessed data that the SSL code has read off the socket that it hasn't returned to you yet, so you'd block when actually there was data to return (been there). There is, as far as I can see, no sensible solution to this. The best I've seen involves mutexes and condition variables, but that's just horrible for what should just consist of passing a timeout value to the poll call. It's just that from the socket class you don't have that control. You DO have that control if you use the basic_socket_streambuf class and wrap the socket in an iostream. That's the odd thing. The functionality IS available in some form, so it's clearly recognised as useful at some level, it's just never been pushed down into the socket itself.

1 0

[boost.test] floating point comparison with user defined type
by Georgios Sermaidis 22 Mar '18

22 Mar '18

Hello, I have created a class to represent the euro currency and I am trying to use boost.test to check if two euro amounts are sufficiently close. I was expecting the following to pass the test given the tolerance level I have set, but instead it fails. What is the proper way to compare two user-defined decimals? Thank you for your time. #define BOOST_TEST_MODULE My Test #include <boost/test/included/unit_test.hpp> class eur { long double m_amount; public: eur(long double amount) : m_amount(amount){} bool operator ==(const eur& rhs) const { return m_amount == rhs.m_amount; } bool operator !=(const eur& rhs) const { return m_amount != rhs.m_amount; } friend std::ostream& operator <<(std::ostream& os, const eur& rhs); }; std::ostream& operator <<(std::ostream& os, const eur& rhs) { os << "EUR " << rhs.m_amount; return os; } BOOST_TEST_DECORATOR(* boost::unit_test::tolerance(eur(0.1))) BOOST_AUTO_TEST_CASE(first_test) { eur x(1.1); eur y(1.2); BOOST_TEST(x == y); }

2 1

boost::units::information::byte_base_unit off by a factor of 8
by Simon Doppler 21 Mar '18

21 Mar '18

I am trying to build a program that will display file sizes in human readable form. The file size is in bytes and I am using boost::units to convert the bytes to a binary prefixed unit. Using the example code found here[1], I build a small program to test the library and the output is off by a factor of 8: boost::units::quantity<boost::units::information::byte_base_unit::unit_type> b = 2048. * boost::units::information::byte_base_unit::unit_type(); std::cout << boost::units::engineering_prefix << b << std::endl; // expected 2.048 kb std::cout << boost::units::symbol_format << boost::units::binary_prefix << b << std::endl; // "expected 2 Kib" but the output on stdout is: 16.384 kb 16 Kib which is 8 times the expected result. The whole example code can be found here[2]. I have tested this code both on Archlinux (boost 1.66.0) as well as Ubuntu Xenial Server (libboost-dev 1.58.0.1ubuntu1). Do you have any idea on how to get the correct output (other than divide the number of bytes by 8 on the input) ? Best regards Simon Doppler [1] http://www.boost.org/doc/libs/1_65_0/doc/html/boost_units/Examples.html#boo… [2] https://dopsi.ch/tmp/main.cpp

2 1

[boost.test] floating point comparison with user defined type
by Georgios Sermaidis 20 Mar '18

20 Mar '18

Apologies, I just found the relevant documentation: http://www.boost.org/doc/libs/1_66_0/libs/test/doc/html/boost_test/testing_… <http://www.boost.org/doc/libs/1_66_0/libs/test/doc/html/boost_test/testing_…>

1 0

[Asio] How to implement a server and client that replies to all clients but one
by Gonzalo Garramuño 20 Mar '18

20 Mar '18

Hi. I want to have a variation on the chat server/client model in that there's a language with instructions being sent. Both the server and the client need to parse this language. When the server changes something, it sends the change in the language to all clients. When the client changes something it sends the change to the server which in turn resends it to all clients but, here's the catch, not to the one that sent the change in the first place. I managed the removal of the client by doing: ParserList::const_iterator i = clients.begin(); ParserList::const_iterator e = clients.end(); for ( ; i != e; ++i ) { try { if ( !(*i)->socket_.is_open() ) continue; std::string p = boost::lexical_cast<std::string>( (*i)->socket_.remote_endpoint() ); if ( p == id ) continue; (*i)->deliver( cmd ); } catch( const std::exception& e ) { LOG_CONN( "Parser::write " << e.what() ); } catch( ... ) { LOG_CONN( "Parser::write unhandled exception" ); } } } I managed to create a working version of the above also by modifying the asio async example using multiple inheritance for the parser (which both the client and the tcp_session inherit). However I am unhappy with this. I ask here to see if someone can suggest a more simple approach to this. -- Gonzalo Garramuño

2 1

[asio] Boost-1.65.0 TlsSlot leak on win32
by Klebsch, Mario 20 Mar '18

20 Mar '18

Hi, I am using boost version 1.65.0 in a 32 bit DLL. I use VS2005 When using ApplicationVerifier, I got application verifier stops due to leaked TLS slots. The TLS slots are allocated in win_tss_ptr_create(). Each slot is wrapped into RAII class win_tss_ptr. The constructor allocates the TLS slot and the destructor de-allocates it. I put printf-Statements in both methods and I see, that the constructor is called twice, while the destructor is not called at all. If I put a breakpoint into the destructor, it never triggers. The printf() satemets show, that the following instances have been constructed: boost::asio::detail::win_tss_ptr<class boost::asio::detail::call_stack<class boost::asio::detail::win_iocp_io_service,struct boost::asio::detail::win_iocp_thread_info>::context>::win_tss_ptr boost::asio::detail::win_tss_ptr<class boost::asio::detail::call_stack<class boost::asio::detail::strand_service::strand_impl,unsigned char>::context>::win_tss_ptr When I put a breakpoint into the constructor, I see, that both instances seem to be global variables > xxx.dll!boost::asio::detail::win_tss_ptr_create() Line 40 C++ xxx.dll!boost::asio::detail::win_tss_ptr<boost::asio::detail::call_stack<boost::asio::detail::win_iocp_io_service,boost::asio::detail::win_iocp_thread_info>::context>::win_tss_ptr<boost::asio::detail::call_stack<boost::asio::detail::win_iocp_io_service,boost::asio::detail::win_iocp_thread_info>::context>() Line 42 + 0x3a bytes C++ xxx.dll!boost::asio::detail::tss_ptr<boost::asio::detail::call_stack<boost::asio::detail::win_iocp_io_service,boost::asio::detail::win_iocp_thread_info>::context>::tss_ptr<boost::asio::detail::call_stack<boost::asio::detail::win_iocp_io_service,boost::asio::detail::win_iocp_thread_info>::context>() + 0xf bytes C++ xxx.dll!`dynamic initializer for 'boost::asio::detail::call_stack<boost::asio::detail::win_iocp_io_service,boost::asio::detail::win_iocp_thread_info>::top_''() Line 165 + 0xd bytes C++ msvcr80d.dll!_initterm(void (void)* * pfbegin=0x101c43a0, void (void)* * pfend=0x101ce9c0) Line 855 C xxx.dll!_CRT_INIT(void * hDllHandle=0x10000000, unsigned long dwReason=0x00000001, void * lpreserved=0x00000000) Line 316 + 0xf bytes C xxx.dll!__DllMainCRTStartup(void * hDllHandle=0x10000000, unsigned long dwReason=0x00000001, void * lpreserved=0x00000000) Line 492 + 0x11 bytes C xxx.dll!_DllMainCRTStartup(void * hDllHandle=0x10000000, unsigned long dwReason=0x00000001, void * lpreserved=0x00000000) Line 462 + 0x11 bytes C Does anyone on this list has an idea, why the destructors aren't called? Thanks in advance, Mario Klebsch -- Mario Klebsch Actia I+ME GmbH Mario.klebsch(a)ime-actia.de<mailto:Mario.klebsch@ime-actia.de> Dresdenstrasse 17/18 Fon: +49 531 38 701 716 38124 Braunschweig Fax: +49 531 38 701 88 Germany

2 2

C++Now 2018 Program Published
by Jon Kalb 19 Mar '18

19 Mar '18

Boosters, The program has (mostly) been published for C++Now 2018: http://cppnow.org/announcements/2018/03/2018-program-announced/ It promises to be an exciting event. It isn’t too late to decide to join us in Aspen this may: http://cppnow.org/registration/ Jon

1 0

singleton.hpp, leak
by Matt Vinson 19 Mar '18

19 Mar '18

Hello,I am using 64-bit, Windows 7, Visual Studio 2017, 15.5.7 on a MFC project. Since updating to 1.66, I think I have leaks traced to singleton.hpp. I put a _crtBreakAlloc = Allocation number and it stops near singleton.hpp.Is it possible this class now has leaks?It true, is there a work around? Any help is appreciated,

2 1

[Asio] How to assign raw sockets (descriptors) to boost::asio::ssl::stream ?
by Dmitriy V 17 Mar '18

17 Mar '18

Hi guys ! I have client server app written on boost::asio. I want to implement updating the server through `execve`. But I don't know how to assign integer socket descriptor (given by streamssl_.lowest_layer().native_handle()) to newly initialized server object after the updating (descriptors strored/restored in shared memory ...) Any help, please ! -- the best regards

2 2

Building Boost 1.66.0 - probable user error
by Larry 16 Mar '18

16 Mar '18

I must be getting old. Building Boost used to be so much easier. I suspect I have missed something in the doc. I downloaded 1.66.0. This is for Win8.1 and MSVC 2017. From a command line bootstrap finally worked to get b2 although there were complaints about some of the options. Running b2 fails. I used to do .\b2 --prefix=xxx toolset=msvc --build-type=complete stage Almost verbatim from the Getting Started doc. stage is not a target is the error. As far as I know the only way to find targets is to wander through .jam files (finding targets was always difficult as far back as 1.27 as I recollect). Any idea what I missed and where? Larry

2 1

[Optional][Variant] Different behavior vs std c++17
by dariomt＠gmail.com 14 Mar '18

14 Mar '18

Hi list, I'm observing different behavior in boost::optional and boost::variant compared to their std c++17 versions. Using Boost 1.64 The following example fails to compile with -DUSE_BOOST using either gcc 7.3 or clang 6.0 #include <boost/optional.hpp> #include <boost/variant/variant.hpp> #include <optional> #include <variant> struct A {}; struct B {}; struct C {}; #ifdef USE_BOOST using V = boost::variant<A,B,C>; using OV = boost::optional<V>; #else using V = std::variant<A,B,C>; using OV = std::optional<V>; #endif OV f(B b) { return b; } Is this difference in behavior expected for such a simple example? Is it possible to improve Boost to make this example compile? Thanks in advance! PS: the Boost only version works in VS2015, not sure why... PPS: Try it in godbolt! https://godbolt.org/g/n4Vbr9 gcc 7.3 says <source>: In function 'OV f(B)': <source>:20:12: error: could not convert 'b' from 'B' to 'OV {aka boost::optional<boost::variant<A, B, C> >}' clang 6.0.0 says <source>:20:12: error: no viable conversion from returned value of type 'B' to function return type 'OV' (aka 'optional<variant<A, B, C> >') return b; ^ /opt/compiler-explorer/libs/boost_1_64_0/boost/optional/optional.hpp:796:5: note: candidate constructor not viable: no known conversion from 'B' to 'boost::none_t' for 1st argument optional( none_t none_ ) BOOST_NOEXCEPT : base(none_) {} ^ /opt/compiler-explorer/libs/boost_1_64_0/boost/optional/optional.hpp:800:5: note: candidate constructor not viable: no known conversion from 'B' to 'boost::optional<boost::variant<A, B, C> >::argument_type' (aka 'const boost::variant<A, B, C> &') for 1st argument optional ( argument_type val ) : base(val) {} ^ /opt/compiler-explorer/libs/boost_1_64_0/boost/optional/optional.hpp:805:5: note: candidate constructor not viable: no known conversion from 'B' to 'boost::optional<boost::variant<A, B, C> >::rval_reference_type' (aka 'boost::variant<A, B, C> &&') for 1st argument optional ( rval_reference_type val ) : base( boost::forward<T>(val) ) ^ /opt/compiler-explorer/libs/boost_1_64_0/boost/optional/optional.hpp:877:5: note: candidate constructor not viable: no known conversion from 'B' to 'const boost::optional<boost::variant<A, B, C> > &' for 1st argument optional ( optional const& rhs ) : base( static_cast<base const&>(rhs) ) {} ^ /opt/compiler-explorer/libs/boost_1_64_0/boost/optional/optional.hpp:882:2: note: candidate constructor not viable: no known conversion from 'B' to 'boost::optional<boost::variant<A, B, C> > &&' for 1st argument optional ( optional && rhs )

1 0

missing libboost_zlib-vc140-mt-x64-1_66.lib
by Sebastian Pfützner 12 Mar '18

12 Mar '18

Hello, I tried to build boost iostreams with zlib support with the following command on Windows: b2 -j 10 --build-dir=build\x64 --stagedir=stage\x64 --toolset=msvc -sZLIB_SOURCE=L:\vc14\zlib\zlib-1.2.8 runtime-link=shared link=static threading=multi address-model=64 debug release stage But if I try to link my program using iostreams with zlib filter it complains about the missing file libboost_zlib-vc140-mt-x64-1_66.lib, and I see it was not built. I also tried editing the project-config.jam as described in the docs: http://www.boost.org/doc/libs/1_66_0/doc/html/bbv2/reference.html#bbv2.refe… Same result. I also tried to use a pre-built zlib binary. Same result. What should I do? here is the output of b2: - 32-bit : yes (cached) - arm : no (cached) - mips1 : no (cached) - power : no (cached) - sparc : no (cached) - x86 : yes (cached) - symlinks supported : no (cached) - junctions supported : yes (cached) - hardlinks supported : yes (cached) - C++11 mutex : yes (cached) - Boost.Config Feature Check: cxx11_auto_declarations : yes (cached) - Boost.Config Feature Check: cxx11_constexpr : yes (cached) - Boost.Config Feature Check: cxx11_defaulted_functions : yes (cached) - Boost.Config Feature Check: cxx11_final : yes (cached) - Boost.Config Feature Check: cxx11_hdr_mutex : yes (cached) - Boost.Config Feature Check: cxx11_hdr_regex : yes (cached) - Boost.Config Feature Check: cxx11_hdr_tuple : yes (cached) - Boost.Config Feature Check: cxx11_lambdas : yes (cached) - Boost.Config Feature Check: cxx11_noexcept : yes (cached) - Boost.Config Feature Check: cxx11_nullptr : yes (cached) - Boost.Config Feature Check: cxx11_rvalue_references : yes (cached) - Boost.Config Feature Check: cxx11_template_aliases : yes (cached) - Boost.Config Feature Check: cxx11_thread_local : yes (cached) - Boost.Config Feature Check: cxx11_variadic_templates : yes (cached) - has_icu builds : no (cached) warning: Graph library does not contain MPI-based parallel components. note: to enable them, add "using mpi ;" to your user-config.jam - zlib : yes (cached) - bzip2 : no (cached) - lzma : no (cached) - iconv (libc) : no (cached) - iconv (separate) : no (cached) - icu : no (cached) - icu (lib64) : no (cached) - native-atomic-int32-supported : yes (cached) - message-compiler : yes (cached) - native-syslog-supported : no (cached) - pthread-supports-robust-mutexes : no (cached) - compiler-supports-visibility : no (cached) - compiler-supports-ssse3 : yes (cached) - compiler-supports-avx2 : yes (cached) - gcc visibility : no (cached) - long double support : yes (cached) warning: skipping optional Message Passing Interface (MPI) library. note: to enable MPI support, add "using mpi ;" to user-config.jam. note: to suppress this message, pass "--without-mpi" to bjam. note: otherwise, you can safely ignore this message. - libbacktrace builds : no (cached) - addr2line builds : no (cached) - WinDbg builds : yes (cached) - WinDbgCached builds : yes (cached) - zlib : yes (cached) - bzip2 : no (cached) - lzma : no (cached) Component configuration: - atomic : building - chrono : building - container : building - context : building - coroutine : building - date_time : building - exception : building - fiber : building - filesystem : building - graph : building - graph_parallel : building - iostreams : building - locale : building - log : building - math : building - mpi : building - program_options : building - python : building - random : building - regex : building - serialization : building - signals : building - stacktrace : building - system : building - test : building - thread : building - timer : building - type_erasure : building - wave : building

3 8

[Interval] Help debugging compiler optimization
by Tim van Erven 12 Mar '18

12 Mar '18

Dear all, I am trying to understand why I am getting different numerical results with the interval library depending on the optimization level of the compiler. I am attaching the smallest example I have been able to create: # On my Mac laptop Apple LLVM version 9.0.0 (clang-900.0.39.2) boost 1.66 (installed via homebrew) $ g++ foo.cpp -o foo $ ./foo third1 = 0.3333333333333333148296162562473909929394721984863281250000000000 third2 = 0.3333333333333333148296162562473909929394721984863281250000000000 v1 = (0.9999999999999998889776975374843459576368331909179687500000000000,1.0000000000000000000000000000000000000000000000000000000000000000) v2 = (0.9999999999999998889776975374843459576368331909179687500000000000,1.0000000000000000000000000000000000000000000000000000000000000000) $ g++ -O2 foo.cpp -o foo $ ./foo third1 = 0.3333333333333333148296162562473909929394721984863281250000000000 third2 = 0.3333333333333333148296162562473909929394721984863281250000000000 v1 = (1.0000000000000000000000000000000000000000000000000000000000000000,1.0000000000000000000000000000000000000000000000000000000000000000) v2 = (1.0000000000000000000000000000000000000000000000000000000000000000,1.0000000000000000000000000000000000000000000000000000000000000000) I would expect to get the same output in both cases, but the lower end-points are different in the second case, and seem wrong to me since third2 * 3.0 < 1.0. # On my Linux machine the effect is different: gcc version 5.4.0 20160609 boost 1.58 on Ubuntu 16.04.9 $ g++ foo.cpp -o foo $ ./foo third1 = 0.3333333333333333148296162562473909929394721984863281250000000000 third2 = 0.3333333333333333148296162562473909929394721984863281250000000000 v1 = (0.9999999999999998889776975374843459576368331909179687500000000000,1.0000000000000000000000000000000000000000000000000000000000000000) v2 = (0.9999999999999998889776975374843459576368331909179687500000000000,1.0000000000000000000000000000000000000000000000000000000000000000) $ g++ -O2 foo.cpp -o foo $ ./foo third1 = 0.3333333333333333148296162562473909929394721984863281250000000000 third2 = 0.3333333333333333148296162562473909929394721984863281250000000000 v1 = (0.9999999999999998889776975374843459576368331909179687500000000000,1.0000000000000000000000000000000000000000000000000000000000000000) v2 = (1.0000000000000000000000000000000000000000000000000000000000000000,1.0000000000000000000000000000000000000000000000000000000000000000) Can anyone explain what is going on? Thanks in advance, Tim -- Tim van Erven<tim(a)timvanerven.nl> www.timvanerven.nl

7 14

[Boost.Serialization] (De-)serialization with class versioning
by Lars Ruoff 11 Mar '18

11 Mar '18

Hi, i use the class versioning feature of Boost.Serialization, with an external (non-intrusive) serialization function like this: BOOST_CLASS_VERSION(GAMEINFO, 1) template <typename Archive> void serialize(Archive &ar, GAMEINFO& gameSettings, const unsigned int version) { ar & gameSettings.NPODS; // ... if (version > 0) ar & gameSettings.ARENA_GOAL_EXCLUSION_RADIUS; } Now as soon, as i set BOOST_CLASS_VERSION(GAMEINFO, 1), i get version==1 in this serialize function, even when i *deserialize* (load from archive). I would have expected to get the version of the data in the saved archive in this case. Say i saved with an old version=0. Then my class evolved and i set BOOST_CLASS_VERSION(GAMEINFO, 1). But when reading the old archive, i expect version==0 in the function so i can react on it. Instead, i get always version==1, as soon as i compile with BOOST_CLASS_VERSION(GAMEINFO, 1), even when i'm reading old files! What am i missing? regards, Lars R.

3 7

boost::serialization - Non intrusive serialization of user-defined members?
by Lars Ruoff 05 Mar '18

05 Mar '18

Hi, I have a class structure like class MemberClass; class ContainerClass { MemberClass special_member; int other_members; }; Following the example in http://www.boost.org/doc/libs/1_66_0/libs/serialization/doc/ i want to write a non-intrusive serialization: template<class Archive> void serialize(Archive & ar, ContainerClass & c, const unsigned int version) { ar & c.other_members; // easy - built-in type serialize(ar, c.special_member, version); //use same version??? } Assuming there's is also a non-intrusive void serialize(Archive & ar, MemberClass & m, const unsigned int version); this compiles and works but i feel this is not the way to do it because it reuses the version number of the container class for the member class? So how to handle that? Must the Container class manage version of its members individually? I suggest to add a section "Non-intrusively Serializable Members" to documentation with an example. Cheers, Lars R.

3 7

[fiber] Fiber context switching during stack unwinding...
by Oliver Seiler 01 Mar '18

01 Mar '18

(Hopefully I'm not writing an essay for something that is a gcc/libstdc++/Linux bug) I've been using Boost.Context for a number of years now, to do something similar to what Boost.Fiber does. We recently upgraded our development target environment to Debian 9 (gcc 6.3), and moved up to Boost 1.62.0, so I've been looking at Boost.Fiber to replace how we're using Boost.Context (because it looks like it could greatly simplify our code, among other things). One thing I ran into with Boost.Context was that it interacted in some interesting ways with exception handling, and I haven't really seen any discussion about it. Specifically, switching contexts with an active exception (so during stack unwinding, or in a catch block) would result in weird behaviour in the other context (std::uncaught_exception() returning true, std::current_exception() returning the exception from the other context, try/catches in the new context causing new problems when switching back to the original context which is in the middle of stack unwinding, etc). I chalked that up to limitations of the context switching, though I haven't seen any mention of avoiding context switches with active exceptions; presumably this is some interaction with gcc's exception implementation, and would maybe need support from libunwind to save/restore the exception state (I don't recall if I checked if clang produced similar results, though I'll probably give it a go when I have the chance). So I wasn't surprised when I ran into similar problems with Boost.Fiber. I am wondering why this aspect of usage isn't discussed in any of the documentation; it would be nice if these libraries could work well with language features like exceptions, but I understand that the language spec doesn't really speak to the stack switching happening under-the-hood. It actually wouldn't surprise me that this wasn't even a problem in all environments, and just happens to be an artifact of the Linux implementation, but then we're either talking about unspecified or undefined behaviour, but would be nice to know. Even in the documents going through the C++ standards committee I don't see much mention of how things like coroutines should interact with something like std::current_exception() (perhaps because it is assumed to "just work" and doesn't need additional comment?) Anyone else ever run into issues related to this? Seems like any use of RAII for exception handling would easily run into problems. Mostly I've just found ways to work around it (e.g., not allowing the context switch if std::uncaught_exception() or std::current_exception() indicate it would be unsafe to do so, typically by throwing another exception) but this tends to make libraries harder to use correctly (e.g., can't really allow context switching in a destructor, or in a function called from a destructor, etc). Cheers Oliver

3 4

why boost does not have skip list implementation?
by David Frank 01 Mar '18

01 Mar '18

like java concurrentSkipListSet for example. Thanks, David

1 0