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

[multi-array] Is default initialization guaranteed?
by Eugenio Bargiacchi 15 Mar '14

15 Mar '14

Hello, I'm trying to figure out whether boost::multi_array does guarantee any initialization on its elements, since I can't find an explicit mention of this in the docs. I've noticed that all constructors of boost_multi array call the function allocate_space(), which is defined as follows: void allocate_space() { typename Allocator::const_pointer no_hint=0; base_ = allocator_.allocate(this->num_elements(),no_hint); this->set_base_ptr(base_); allocated_elements_ = this->num_elements(); std::uninitialized_fill_n(base_,allocated_elements_,T()); } Thus, std::uninitialized_fill_n should set all values to their default ones, right? For example, a boost::multi_array containing doubles is guaranteed to be zeroed at constructions, am I correct? Or are there cases where there's no guarantee of initialization, and that is why the documentation does not mention it? Thanks in advance. Best regards, Eugenio Bargiacchi

1 0

Boost Log
by Manuel Torres 14 Mar '14

14 Mar '14

Hello, I am using Boost Log 1.55 with MinGW 32-bits (GCC v.4.8.1) under Windows 7 64-bits and it seems that the "AutoFlush" parameter is not working when a settings file is used. I thought it might have to do with the "Asynchronous" parameter but, after setting four sinks with the combinations of "AutoFlush" and "Asynchronous", I got the same result: the log files are only created after the application is closed. I would appreciate if someone could help. This is the settings file I am testing with: [Core] DisableLogging=false Filter="%Severity% < 6" [Sinks.ConsoleSink] Destination=Console Format="[%TimeStamp%] <%Severity%> %Channel%: %Message%" Asynchronous=true AutoFlush=true [Sinks.TextFileSink0] Destination=TextFile FileName="0_%Y%m%d%H%M%S_Node_%N.log" Format="[%TimeStamp%] <%Severity%> %Channel%: %Message%" Asynchronous=true AutoFlush=true Target="../log" RotationSize=1000000 RotationTimePoint="00:00:00" MaxSize=10000000 [Sinks.TextFileSink1] Destination=TextFile FileName="1_%Y%m%d%H%M%S_Node_%N.log" Format="[%TimeStamp%] <%Severity%> %Channel%: %Message%" Asynchronous=true AutoFlush=false Target="../log" RotationSize=1000000 RotationTimePoint="00:00:00" MaxSize=10000000 [Sinks.TextFileSink2] Destination=TextFile FileName="2_%Y%m%d%H%M%S_Node_%N.log" Format="[%TimeStamp%] <%Severity%> %Channel%: %Message%" Asynchronous=false AutoFlush=true Target="../log" RotationSize=1000000 RotationTimePoint="00:00:00" MaxSize=10000000 [Sinks.TextFileSink3] Destination=TextFile FileName="3_%Y%m%d%H%M%S_Node_%N.log" Format="[%TimeStamp%] <%Severity%> %Channel%: %Message%" Asynchronous=false AutoFlush=false Target="../log" RotationSize=1000000 RotationTimePoint="00:00:00" MaxSize=10000000

2 2

[asio] resolver::cancel() problem
by Matthew Edwards 14 Mar '14

14 Mar '14

In my application (and a separate test program) it seems as though the cancel() function on the resolver does not work as intended. For async resolves, the cancel functionality should abort them immediately and pass an 'operation aborted' error code to the callback handler. In my tests, I will resolve an invalid domain (this causes the resolve to take a few seconds, to demonstrate the problem), sleep for 100ms, then call cancel on the resolver object. No cancelling actually occurs, and the callback is simply triggered after a few seconds with a "No host found" error code, not the expected operation aborted. Has anyone experienced this before, or know how I might be using the resolver incorrectly?

3 2

[Graph] Guarantee on bidirectional graphs
by Sensei 14 Mar '14

14 Mar '14

Dear all, I am implementing my custom algorithm for path discovery (as in a recent post), and I'd like to know one simple thing. My graph is a bidirectional sparse compressed row graph, and I need to represent a *directed* graph with that (I need in and out edges). So, is the order of nodes in an edge guaranteed to generate the correct in/out adjacent nodes? I do not care about ordering of nodes, just distinguishing nodes that belong to in and out edges. For instance, given a directed graph that has node 4 with two out edges to 5 and 6, and 4 in edges from 1, 2, and 3, am I guaranteed that, even if the graph is bidirectional, the in and out edges will be unaffected and won't be swapped? Moreover, when I dump the indices of out edges, the results seem to be right, but when I dump the in edges, results are erroneous. I must be doing something really wrong... And one more thing: I have tried my code with just using the stream output as in http://programmingexamples.net/wiki/CPP/Boost/BGL/DirectedGraph, just using std::cout << neighbors_out.first << std::endl; clang complains: main.cpp:165:19: error: invalid operands to binary expression ('ostream' (aka 'basic_ostream<char>') and 'boost::detail::csr_out_edge_iterator<boost::compressed_sparse_row_graph<boost::bidirectionalS, boost::no_property, boost::no_property, boost::no_property, unsigned long, unsigned long> >') std::cout << neighbors_out.first << std::endl; ~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~~~ while if I use the following, it compiles just fine (but as I said, the output is wrong): std::cout << neighbors_out.first->idx << std::endl; See the snippet for an example. Thanks & Cheers! typedef boost::compressed_sparse_row_graph<boost::bidirectionalS> boost_graph; typedef boost::graph_traits<boost_graph>::vertex_iterator vertex_iterator; typedef boost::graph_traits<boost_graph>::adjacency_iterator adjacency_iterator; typedef boost::graph_traits<boost_graph>::out_edge_iterator outward_iterator; typedef boost::graph_traits<boost_graph>::in_edge_iterator inward_iterator; // ... std::vector<std::pair<std::size_t, std::size_t>> results; results.push_back(std::make_pair( 0, 1)); results.push_back(std::make_pair( 0, 3)); results.push_back(std::make_pair( 1, 4)); results.push_back(std::make_pair( 2, 4)); results.push_back(std::make_pair( 3, 4)); results.push_back(std::make_pair( 4, 5)); results.push_back(std::make_pair( 4, 6)); results.push_back(std::make_pair( 5, 7)); results.push_back(std::make_pair( 7, 8)); results.push_back(std::make_pair( 8, 9)); results.push_back(std::make_pair( 8, 11)); results.push_back(std::make_pair( 8, 12)); results.push_back(std::make_pair( 9, 10)); results.push_back(std::make_pair(12, 10)); // Create the graph boost_graph graph(boost::edges_are_unsorted_multi_pass, results.begin(), results.end(), 13); std::cout << "Outward adjacents" << std::endl; std::pair<outward_iterator, outward_iterator> neighbors_out; neighbors_out = boost::out_edges(boost::vertex(4, graph), graph); for(; neighbors_out.first != neighbors_out.second; ++neighbors_out.first) { std::cout << neighbors_out.first->idx << std::endl; } std::cout << "Inward adjacents" << std::endl; std::pair<inward_iterator, inward_iterator> neighbors_in; neighbors_in = boost::in_edges(boost::vertex(4, graph), graph); for(; neighbors_in.first != neighbors_in.second; ++neighbors_in.first) { std::cout << neighbors_in.first->idx << std::endl; } == OUTPUT == Outward adjacents 5 6 Inward adjacents 2 3 4

2 4

cpp_rational memory bloat with repeated construction and destruction
by W Randolph Franklin 14 Mar '14

14 Mar '14

Hi, My application, overlay, constructs and destroys millions of cpp_rational variables. As overlay executes, its memory continually grows. My variables don't have that many digits, but each time that they are constructed or destroyed, they are slightly wider or narrower. W/o studying the cpp_rational source, I surmise that it uses a heap that gets badly fragmented. Apart from the space, each single allocation is probably taking ever more time. That's annoying because overlay otherwise would take linear time. What should I do? Are there easy ways to control this problem? Are other rational implementations better? Boost gives me a choice of several. Are there better implementations outside boost? ----- Not that it's relevant, but FYI, my application is to overlay two planar graphs, intersecting all the edges to find the output faces. There might be 100,000 edges. Roundoff error is a serious problem that causes topological impossibilities. The idea is to use rationals to prevent roundoff. Upon reading each input float, I use a continued fraction approximation to convert it to the closest rational justified by the number of significant digits. That entails constructing and destroying variables of varying widths as the approximation converges. This is probably what is thrashing the memory. However if I don't do that, the values start by having perhaps 20 digits, which doubles each time as line equations are computed and lines intersected. Perhaps I could restructure my code to avoid that. However IMHO, it is quite well structured now, and making it ugly to be fast would be a pity. Help? Thanks.

2 1

Indirectly 'recursive' type erasure
by Samuel Christie 13 Mar '14

13 Mar '14

I'm trying to create a type erasure concept for a type that has a member function which can return a custom collection of itself. Having had little luck with the general formulation, I tried simplifying it to: BOOST_TYPE_ERASURE_MEMBER((has_collection), collection, 0); typedef any< mpl::vector< copy_constructible<>, typeid_<>, relaxed, has_collection<vector<_self>()> > > test; class Test { public: vector<test> collection(); }; However, I get conversion errors if the Test::collection method returns either vector<Test> or vector<test>; it only seems to match if I have it literally return vector<_self>, which implies to me that I'm not understanding what I'm doing, and that _self isn't getting substituted in this case. What do I need to do in order to be able to return types that are dependent on the erasure type? My actual code uses a more indirect relationship, with the collection method returning a custom erased collection type that has an erased iterator that can dereference to the equivalent of Test. However, since there is still a form of cyclic dependency, I'm not really sure what I can do about it. I've tried using a custom struct based concept that had direct template arguments in the place of 'boost type erasure member', but I think I understand that technique even less, and it didn't seem to help much. It looked like there might be something useful under the Associated Types section of the type erasure documentation, but I couldn't quite figure it out. Any assistance would be most helpful. Thanks, -sc

2 5

[Coroutine] Assertion when coroutine is not run
by Brian Ravnsgaard Riis 13 Mar '14

13 Mar '14

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 Hi, I've been toying with Boost.Coroutine lately. For starters I have tried to implement a message parser using the library. For this purpose I have two coroutine<char>::push_type in a containing class. These are initialized at class construction with a lambda. One coroutine parses the message header, the other the body. This all worked fine. Until I had a test case where I was only interested in the message header, so I never called the message-body-coroutine. At object destruction I get a this assertion: replyparser: /usr/local/include/boost/coroutine/detail/push_coroutine_object.hpp:167: void boost::coroutines::detail::push_coroutine_object<char, <lambda at src/replyparser.cpp:303:22>, boost::coroutines::detail::standard_stack_allocator, std::allocator<boost::coroutines::push_coroutine<char> >, boost::coroutines::pull_coroutine<char> >::run() [X = char, Y = <lambda at src/replyparser.cpp:303:22>, Z = boost::coroutines::detail::standard_stack_allocator, V = std::allocator<boost::coroutines::push_coroutine<char> >, W = boost::coroutines::pull_coroutine<char>]: Assertion `hldr_from->data' failed. The message-body coroutine is really simple; it just takes the characters and stuffs them into a std::string until the string size is equal to the expected length of the body (parsed from the header): [&](coroutine<char>::pull_type& c) { content.push_back(c.get()); while(content.size() != contentLength) { c(); content.push_back(c.get()); } validResult = true; } This works just fine when I parse the message body, but when I (choose to) ignore the message body, so the coroutine is never called, I get the above assertion. I have a feeling I'm missing some obvious detail about this. Of course I would normally not skip the message body, but there is a chance the length is 0, i.e. there *is* no message body. I'd prefer to have no assertions in that case. What am I doing wrong? /Brian Riis -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.12 (GNU/Linux) Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/ iQEcBAEBAgAGBQJTHQlPAAoJEFES4N8QrEodJ+MH/1z+N+YnXrCm3xPnp7wAlM+w 3RZkeNOOJ0h67nmBHRJXj3A3+t/Hy+FZV/SUBDMtCwx/zIH5fZZtsBaw89frAsdI SPmLiwG6NgBoBSV8Pih4gD+k4LvTbYh5AQLF2ssB/WAVZODk92iz4sNrNFVwThFn S68NStkEyyXElrCzkd3w0QQD8sD2OGWAW0YlHLGhUXlsouWRyd9VKAbEXdrTKLVQ I0ciL87AzOKsfrfV89U1eQh5uHEgg8ZcDa459ieqeOISXhNJI/ba8rv6mkXGEseB U7wRr7M1XMdHolPiFlUEKrUocdAPLS/AjeVfcGkJSzc2bhka08qu4EMTgqkOhtY= =G1Y2 -----END PGP SIGNATURE-----

2 10

managed shared memory with basic_string
by Sean K 12 Mar '14

12 Mar '14

I am new to boost so please pardon if this question has already been asked. I was able to build a shared memory IPC client and server using "int" primitive type successfully. I need to send a fixed number of "char" (primitive type). At first I tried to define a struct of a fixed char struct { char data[1024]; } dataset; typedef dataset mychararray; and use this like how this example shows for 'int" http://en.highscore.de/cpp/boost/interprocesscommunication.html#interproces… But for some reason it did not compile due to the boost::interprocess::managed_shared_memory.construct () not accepting that kind of datatype. So, I looked at the basic_string implementation based on these two web sites. http://prakharprakhar.blogspot.com/2009/12/boost-shared-memory-vector.html http://en.highscore.de/cpp/boost/interprocesscommunication.html#interproces… (basic_string variant) I am built a reader and writer separate app. The reader will look for content. If it does not find it, it will wait or sleep and try again, etc. If it finds something it will try to print the basic_string content that I sent over. I thought I had it correctly built but obviously it is not since the reader server crashes or cores when it tries to access the p.first content. Below are the two programs (along with the build.sh which compiles each). I am testing this as a 32 bit app on a 64 bit redhat5 and 32 bit centos6. You will notice in the strreader.cc that when I try to access the basic_string, that it crashes. I ran the reader (server) within the 32 bit eclipse debugger, and the memory addresses and content of the p BStringPair looks fine. Anybody have some ideas or can anybody try this and see what you can tell what is wrong. strreader.cc #include <iostream> #include <boost/interprocess/managed_shared_memory.hpp> #include <boost/thread/thread.hpp> #include <boost/interprocess/containers/vector.hpp> #include <boost/interprocess/allocators/allocator.hpp> #include <iostream> #include <string> #include <cstdlib> using namespace std; using namespace boost::interprocess; int main() { typedef boost::interprocess::allocator<char, boost::interprocess::managed_shared_memory::segment_manager> ShmemAllocator; typedef basic_string<char, std::char_traits<char>, ShmemAllocator> BString; typedef std::pair<BString *, std::size_t> BStringPair; int count = 0; shared_memory_object::remove("Highscore"); while (true) { managed_shared_memory segment(open_or_create, "Highscore", 65536); if (segment.get_num_named_objects() > 0){ BStringPair p = segment.find<BString> ("str"); printf("stuff in memory\n"); if (p.first ){ // THIS IS WHERE IT CRASHES!!! //printf("%s \n",(p.first->c_str()) ); //int strlen = p.first->size(); } printf("p.second: %d \n", p.second); } shared_memory_object::remove("Highscore"); //printf("one: %s", one.first); //printf("two: %s", two.first); int msecs = 2000; boost::this_thread::sleep(boost::posix_time::milliseconds(msecs)); printf("sleeping...\n"); } return 0; } build.sh for the reader g++ -m32 -fPIC -Xlinker -zmuldefs strreader.cc -o strreader -I/common/COTS/boost_1_42_0/include -L/common/COTS/boost_1_42_0/lib -lboost_thread -lboost_system -pthread strwriter.cpp #include <iostream> #include <boost/interprocess/managed_shared_memory.hpp> #include <boost/thread/thread.hpp> #include <boost/interprocess/containers/vector.hpp> #include <boost/interprocess/containers/string.hpp> #include <boost/interprocess/allocators/allocator.hpp> #include <iostream> #include <string> #include <cstdlib> using namespace std; using namespace boost::interprocess; int main() { typedef boost::interprocess::allocator<char, boost::interprocess::managed_shared_memory::segment_manager> ShmemAllocator; typedef boost::interprocess::basic_string<char, std::char_traits<char>, ShmemAllocator> BString; try { shared_memory_object::remove("Highscore"); printf("cleared out memory\n"); managed_shared_memory segment(open_or_create, "Highscore", 65536); printf("initialized managed shared memory \n"); ShmemAllocator allocInst (segment.get_segment_manager()); BString bstrData(segment.get_segment_manager()); bstrData = "hello"; std::string data = "Hello"; //BString bstrToSend(data.begin(), data.end()); //BString bstrToSend(data.c_str()); BString *mystring = segment.construct<BString> ("str")(bstrData); //mystring="Hello"; printf("inserted mystring into shmvector \n"); } catch (boost::interprocess::bad_alloc e) { printf("we caught bad alloc\n"); printf("explanation: %s", e.what()); throw; } catch (...) { printf("caught unknown exception\n"); throw; } printf("wrote number"); return 0; } build.sh for the writer: g++ -m32 -fPIC -Xlinker -zmuldefs strwriter.cpp -o strwriter -I/common/COTS/boost_1_42_0/include -L/common/COTS/boost_1_42_0/lib -lboost_thread -lboost_system -pthread -- Sean

2 3

[Boost.Preprocessor] Why BOOST_PP_SEQ_CAT with a sequence of comma separated pair is a missuse ?
by Albert 11 Mar '14

11 Mar '14

Hello, I tried to use the BOOST_PP_SEQ_CAT with a sequence of parenthesized comma-separated pair of token. It works fine with visual 2010 but fails with gcc. I first think that there were a problem in the specific gcc implementation part. That's why I opened the issue 9633 : https://svn.boost.org/trac/boost/ticket/9633 But, it has recently been closed for invalidity, the corrector telling that it is not a valid use. I have not read the entire help of the PP library but as far as I understand the sequence definition given in A.4.5.1. (http://www.boostpro.com/mplbook/preprocessor.html) as "any string of nonempty parenthesized /macro arguments/." and the definition of macro arguments in A.2.3, I fail to see why the sequence could be incorrect. Specially when I read the end of the paragraph : " It /is/ possible to pass either string of tokens above as part of a single macro argument, provided it is parenthesized: FOO(*(*std::pair<int,int>*)*) // one argument FOO(*(*{ int x = 1, y = 2; return x+y; }*)*) // one argument " I fail to see where in the dedicated entry for BOOST_PP_SEQ_CAT (http://www.boost.org/doc/libs/1_55_0/libs/preprocessor/doc/ref/seq_cat.html) there is a rule I violated. So my questions are : => why the code I proposed is invalid ? => Is the workaround proposed with BOOST_PP_SEQ_FOR_EACH is also a missused and may fail according to evolutions of the library ? Thanks in advance for your answers. The code : #include <boost\preprocessor\seq\cat.hpp> #define SOME_SEQUENCE (('a',1)) (('b',2)) (('c',3)) (('d',4)) (('e',5)) struct dummy { dummy& operator()(char,int) {return *this;} }; int main() { dummy() BOOST_PP_SEQ_CAT(SOME_SEQUENCE); // Visual 2010 generates dummy() ('a',1)('b',2)('c',3)('d',4)('e',5); // gcc fails with compiler errors due to the comma I suppose return 0; }

2 1

boost::serialization - Serialization (non intrusive) of a map containing in and structure.
by Brian Davis 11 Mar '14

11 Mar '14

I am using boost 1.41.0 and MS VS 2008. I have been having trouble serializing a map which contains a int (key) and structure value. I create a simple test app to aid in the discussion. I am attempting to perform a non intrusive serialization of the structure. I had in the past been able to serialize a map of <int,string> successfully, but now that the map is <int, non_intrusive> where non_intrusive is the name of my strut, I get an error: 2>Windows-6.1\install\include\boost-1_41\boost/serialization/access.hpp(109) : error C2039: 'serialize' : is not a member of 'non_intrusive' and the line in boost is: template<class Archive, class T> static void serialize( Archive & ar, T & t, const unsigned int file_version ){ t.serialize(ar, file_version); // serialize( ar, t, file_version ); } Where if I change the line t.serialize(ar, file_version); to serialize( ar, t, file_version ); and then it compiles. Which of course I know I should not do, but only did so to see if I could get it to call my template specialization for my serialize code of my strut with out having to perform in intrusive serialization and agian was just a test to see if boost would call my serialize function. I have revered this so fear not... this is not the problem. namespace boost { namespace serialization { template<class Archive> void serialize( Archive& ar, non_intrusive& ni ){ ar & ni.a; } which is of course wrapped in the boost::serialization namespace... full example below I am guessing I have not done something correctly and I have been successful in the past as I said serializing structures, vectors, and maps. This is the first time I tried to serialize a map with a struct. I also converted my code (not the example) to use a vector of std::pair<int, non_intrusive> and got the same error. Here is the full program listing any help would be appreciated: //------------------------------------------------------------------------------------------- #include <string> #include <fstream> #include <algorithm> #include <boost/filesystem.hpp> #include <boost/filesystem/fstream.hpp> #include <boost/serialization/utility.hpp> #include <boost/archive/xml_oarchive.hpp> #include <boost/archive/xml_iarchive.hpp> #include <boost/serialization/string.hpp> #include <boost/serialization/map.hpp> struct non_intrusive{ int id; std::string name; }; typedef std::map<int, non_intrusive> a_map_t; namespace boost { namespace serialization { // Not sure if I need to do this bit, but I have seen references to this // syntax on the web. template<class Archive> void serialize( Archive& ar, std::pair<int, non_intrusive> & ni_pair ){ ar & std::pair<int, non_intrusive>( ni_pair ); } template<class Archive> void serialize( Archive& ar, non_intrusive& ni ){ ar & ni.a; } }} void save ( const a_map_t& map_var, const std::string& file_name ) { boost::filesystem::path file_path = file_name; boost::filesystem::path pathstr = file_path.remove_leaf(); if( pathstr != "" ) boost::filesystem::create_directory( pathstr ); std::ofstream ofs( file_name.c_str(), std::ios_base::out | std::ios_base::trunc); boost::archive::xml_oarchive xml(ofs); xml << BOOST_SERIALIZATION_NVP( map_var ); } // +---------------------------------------------------------------------- a_map_t load(const std::string& file_name) { a_map_t map_var; // std::ifstream ifs(file_name.c_str(), std::fstream::binary | std::fstream::in); std::ifstream ifs(file_name.c_str() ); if( !ifs ) { non_intrusive od; od.id = -1; od.name = "unknown device"; map_var.insert( a_map_t::value_type( 0, od ) ); save( map_var, file_name ); }else { boost::archive::xml_iarchive xml(ifs); xml >> BOOST_SERIALIZATION_NVP( map_var ); } return map_var; } // +---------------------------------------------------------------------- int main( void ){ a_map_t map; map = load("map.xml"); save(map, "map.xm" ); }

2 2