July 2014 - Boost-users - lists.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

[Range, Phoenix] What am I missing...
by Robert Jones 25 Apr '17

25 Apr '17

Hi Folks Can anyone explain the output of this program... #include <iostream> #include <boost/range/algorithm/copy.hpp> #include <boost/range/counting_range.hpp> #include <boost/range/adaptor/reversed.hpp> #include <boost/range/adaptor/transformed.hpp> #include <boost/phoenix/bind/bind_function.hpp> #include <boost/phoenix/core/argument.hpp> int f( int i ) { return i * 2; } int main( ) { using boost::adaptors::reversed; using boost::adaptors::transformed; using boost::counting_range; using boost::copy; using boost::phoenix::arg_names::_1; copy( counting_range( 1, 5 ) | reversed | transformed( f ), std::ostream_iterator<int>( std::cout, " " ) ); std::cout << std::endl; copy( counting_range( 1, 5 ) | reversed | transformed( bind( f, _1 ) ), std::ostream_iterator<int>( std::cout, " " ) ); std::cout << std::endl; } Which is... 8 6 4 2 1768406272 1768406272 1768406272 1768406272 I'm using Gcc 4.6.2 & Boost 1.53 Thx All.

3 4

[statechart] Passing parameters from event to State Local Storage
by Christophe Bourez 16 Nov '16

16 Nov '16

I need to maintain a parameter into the state local storage. This parameter is initially contained in the event that causes the transition to the target state. I give hereafter a small illustrative example. typename sc = boost::statechart; class EvTest : public sc::event<EvTest> { public: EvTest(std::size_t val) : value(val) {} std::size_t getValue() const { return this->value; } private: std::size_t value; }; class MyStateMachine; class StSource; class StTarget; class StSource : public sc::simple_state<StSource, MyStateMachine> { public: typedef sc::custom_reaction<EvTest> reactions; sc::result react(const EvTest &event) { // How to pass event.getValue() to the target state ? transit<StTarget>(); } }; class StTarget : public sc::simple_state<StTarget, MyStateMachine> { public: StTarget(std::size_t val) : val(value) {} private: std::size_t value; }; Thanks, Christophe

5 6

Re: [Boost-users] lexical_cast between double and string slow in Visual Studio 2013
by David Roberts 07 May '15

07 May '15

> That issue is unknown. I'd really appreciate the investigation. I have done some more investigation, and there are two factors that only cause the slowness when they both occur together. > Try excluding the lexical_cast from test, I have a feeling that this is only MSVC related issue: > > #include <sstream> > #include <string> > > int main (int, char **) > { > for (double count = 0.0; count < 1000000.0; count += 1.41) > { > std::stringstream ss; > ss << count; > std::string result = std::move(ss.str()); > ss.str(std::string()); > > ss << result; > ss >> count; > } > > return 0; > } > Running your test program does not exhibit the problem. It runs in around 3 seconds on my machine when built with either Visual Studio 2010 or Visual Studio 2013. However, changing it very slightly to match more closely what lexical_cast does internally does recreate the problem: #include <sstream> #include <string> int main (int, char **) { for (double count = 0.0; count < 1000000.0; count += 1.41) { std::stringstream ss; ss.unsetf(std::ios::skipws); ss.precision(17); ss << count; std::string result = std::move(ss.str()); ss.str(std::string()); ss << result; ss >> count; } return 0; } The effect of setting the precision to 17 is that lots of 9s appear in the string representations. (The number 17 is what boost::detail::lcast_get_precision(double*) chooses.) Without the precision call the contents of the string called result start off like this: 0 1.41 2.82 4.23 5.64 7.05 8.46 9.87 11.28 12.69 With precision set to 17 they start off like this: 0 1.4099999999999999 2.8199999999999998 4.2299999999999995 5.6399999999999997 7.0499999999999998 8.4599999999999991 9.8699999999999992 11.279999999999999 12.69 This happens for both Visual Studio 2010 and Visual Studio 2013. Then the next difference is that Visual Studio 2013 spends a lot longer handling all the extra 9s. Changing the program so that the double is converted to a string using std::stringstream without a precision call and then back to double using lexical_cast takes about 3 seconds for both Visual Studio 2010 and Visual Studio 2013. It is the combination of having all the extra 9s to parse and using Visual Studio 2013 that makes the test using lexical_cast to go both ways slow. Both Visual Studio 2010 and Visual Studio 2013 do the conversion by calling std::num_get<char,std::istreambuf_iterator<char,std::char_traits<char> > >::do_get() which then calls a function called _Stodx() which is implemented in xstod.c. This function is very different for the two versions. In Visual Studio 2010 it's a relatively thin wrapper around the C function strtod(). In Visual Studio 2013 _Stodx() has got a completely new implementation that's generated by #including xxstod.h with some macros defined. The original C function strtod() is much faster than the new _Stodx() when there are lots of 9s at the end of the strings being parsed. This modification to the program: #include <sstream> #include <string> #include <stdlib.h> int main (int, char **) { for (double count = 0.0; count < 1000000.0; count += 1.41) { std::stringstream ss; ss.unsetf(std::ios::skipws); ss.precision(17); ss << count; std::string result = std::move(ss.str()); ss.str(std::string()); ss << result; char *endptr; count = strtod(ss.str().c_str(), &endptr); } return 0; } has a runtime of about 3 seconds even though it's got to cope with all the 9s. I guess only someone from Microsoft or Dinkumware could comment on why _Stodx() was reimplemented. But the other thing is that by setting precision to 17 lexical_cast is bloating the string representations of the doubles with lots of 9s in both Visual Studio 2010 and Visual Studio 2013. Setting precision to 15 instead prevents this, and makes the original test run faster even with Visual Studio 2013 (about 4 seconds rather than 10). Regards, David

5 4

Statechart serialization
by mbrodeur65 04 Mar '15

04 Mar '15

Hi, I'm looking for a solution to serialize boost::statechart objects. I'm aware that this feature is on the statechart library todo list but was wondering if there are any workaround to achieve this with the latest boost release (1.34) ? thanks for your help ! mbrodeur65 -- View this message in context: http://www.nabble.com/Statechart-serialization-tf4131326.html#a11749139 Sent from the Boost - Users mailing list archive at Nabble.com.

4 4

NT² 3.0 and Boost.SIMD - Stable release
by Joel Falcou 21 Nov '14

21 Nov '14

The first stable release of the 3.x series of MetaScale’s open-source software is available: NT² 3.0. It also includes its spin-off project, Boost.SIMD (not yet a Boost library). Many Issues have been closed since last beta. The main focus of this release cycle was to fix performances issues and to stabilize some parts of the API. Next step will be to separate NT2 and Boost.SIMD into separate repositories, thus making one more step toward Boost.SIMD submission into review. [ http://www.metascale.org/nt%C2%B2-3-0-and-boost-simd ] *Changes & Bug Fixes:* - Major performance improvements in both libraries - Added experimental support for the HPX runtime for parallelization on shared memory systems - Optimizations of many elemental functions, in particuler log/ex, frexp/ldexp and cbrt - More advanced shuffle pattern recognition for SIMD - Fixed issues with Visual Studio 2013 - More functions are force-inlined to ensure good performance - New functions for conversion between types and mixing of vectors of different sizes - Demo applications usable as benchmarks - Better handling of errors when an unsupported function is called - New API for custom memory allocators Full changelog is available at https://github.com/MetaScale/nt2/releases/tag/3.0.0. *How to get it ?* - Source and binary packages can be downloaded here: http://nt2.metascale.org/downloads - The release is also available on Github : https://github.com/MetaScale/nt2/releases - The main master branch is still under development : https://github.com/MetaScale/nt2

4 4

[Thread] Read-write locks
by lfrfly＠icqmail.com 18 Sep '14

18 Sep '14

I'm trying to create a standard read/write lock using Boost Threads, and I'm having a bit of difficulty mapping the Boost concepts onto the usual ones. A read/write lock should have several states: Locked for reading (multiple threads may lock at once), locked for writing (only one thread may lock, and no threads may be locked for reading at the same time), and unlocked. Ideally it would be nice if an RWL which is locked for reading may temporarily upgrade to locked for writing, then return to the locked for reading state. Boost supports several relevant notions of locking: shared locking, upgrade locking, and exclusive locking. This to me is a confusing distinction. In particular, a shared_mutex seems appropriate as the basis for a RWL, but is lock_upgrade() the equivalent of a write lock and lock_shared the equivalent of a read lock? This is unclear. If "upgrade locking" is not the same as "exclusive locking", then is an upgrade lock actually exclusive? Could someone please clarify this.

4 3

[1.56.0] Release candidates available
by Marshall Clow 04 Aug '14

04 Aug '14

Release candidate files for 1.65.0 are available at http://boost.cowic.de/rc/ As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy. This helps ensure the candidates build OK before we push them out to SourceForge. The files (and associated md5s) are: MD5 (boost_1_56_0_rc1.7z) = 0ac22b92b24209286d48e4c41925cd9f MD5 (boost_1_56_0_rc1.tar.bz2) = 5b5bfa99244b1ac5737323decceb19c2 MD5 (boost_1_56_0_rc1.tar.gz) = 2047cdd4e09cda34e7f10fec0f821175 MD5 (boost_1_56_0_rc1.zip) = 0c544f6acc85550b15cdc9221f2ac0c9 Thanks! -- The release managers

7 11

[serialization] Please help me solve this compile error.
by Paul Blampspied 04 Aug '14

04 Aug '14

I am tearing my hair out over this, partly because I believe the code used to compile. I just can't see what the problem is. I enclose all the pertinent code as I cannot say which bits are irrelevant. There are two classes: ManagedArray which is an array of data without size or capacity data (this is stored elsewhere). PersistentManagedArray which I wrote to enable ManagedArrays to be serialized. The error message is produced in 'main': error: no match for 'operator<<' in 'oa << PersistentManagedArray<int>((* & size), (* & capacity), (* & ints))' It seems to me that I have defined the necessary serialize member function with the right signature. Commented out is code I wrote some time ago which used separate load and save functions. This, I believe, used to work. #include <fstream> #include <boost/archive/binary_oarchive.hpp> #include <boost/archive/binary_iarchive.hpp> #include <string> using namespace std; //**************************************************************************************************************************** template<class T> class ManagedArray { public: T *values; ManagedArray() { values = NULL; } ~ManagedArray() { if (values) { delete [] values; } } //Changes array size. If array grows, the new values are unintialized. void resize(unsigned oldSize, unsigned newSize) { if (oldSize==newSize) return; T *newValues = (newSize==0) ? NULL : new T[newSize]; if (oldSize!=0) { T *oldValue, *newValue; T *end = values + (oldSize<newSize ? oldSize : newSize); for(oldValue=values, newValue=newValues; oldValue<end; oldValue++, newValue++) { *newValue = *oldValue; } } if (values) { delete [] values; } values = newValues; } //Changes array size. If array grows, the new values are initialised to copies of a prototype, initValue. void resize(unsigned oldSize, unsigned newSize, T &initValue) { if (oldSize==newSize) return; T *newValues = (newSize==0) ? NULL : new T[newSize]; T *oldValue = values; T *newValue = newValues; if (oldSize!=0) { T *oldEnd = values + (oldSize<newSize ? oldSize : newSize); for(; oldValue<oldEnd; oldValue++, newValue++) { *newValue = *oldValue; } } T *newEnd = newValues + newSize; for(; newValue<newEnd; newValue++) { *newValue = initValue; } delete [] values; values = newValues; } inline T &operator[](unsigned index) { return values[index]; } inline const T &operator[](unsigned index) const { return values[index]; } }; //**************************************************************************************************************************** //This class helps to save a ManagedArray in a Boost archive // Usage: // ar & PersistentManagedArray(size, capacity, array); template<class T> class PersistentManagedArray { public: PersistentManagedArray(unsigned &size, unsigned &capacity, ManagedArray<T> &managedArray) : _size(size), _capacity(capacity), _managedArray(managedArray) {valueArrayExists = (_managedArray.values!=NULL);} private: unsigned &_size; unsigned &_capacity; ManagedArray<T> &_managedArray; bool valueArrayExists; friend class boost::serialization::access; // template<class Archive> // void save(Archive & ar, const unsigned int version) const { // ar & valueArrayExists; // if (valueArrayExists) { // for(unsigned i=0; i<_size; i++) { // ar & _managedArray.values[i]; // } // } // } // template<class Archive> // void load(Archive & ar, const unsigned int version) { // _managedArray.values = NULL; // ar & valueArrayExists; // if (valueArrayExists) { // _managedArray.resize(0, _capacity); // for(unsigned i=0; i<_size; i++) { // ar & _managedArray.values[i]; // } // } // } // BOOST_SERIALIZATION_SPLIT_MEMBER() template<class Archive> void serialize(Archive & ar, const unsigned int version) { ar & valueArrayExists; ar & _size; ar & _capacity; if (Archive::is_loading::value) { delete _managedArray.values; _managedArray.values = new T[_capacity]; } for(unsigned i=0; i<_size; i++) { ar & _managedArray.values[i]; } } }; int main(int argc, char *argv[]) { ManagedArray<int> ints; unsigned size; unsigned capacity; string fileName = "data.xxx"; ofstream file(fileName.c_str(), ios::out|ios::binary); if (file.good()) { boost::archive::binary_oarchive oa(file); oa << PersistentManagedArray<int>(size, capacity, ints); //This line does not compile ! } }

4 4

[MultiIndex] Indexing integers
by Sensei 31 Jul '14

31 Jul '14

Dear all, I am experimenting with MultiIndex, and I am happy with my custom classes. Now I am wondering, can I index integers without a custom class? For instance, say we have a 32 bit unsigned integer, how can I index these with respect to the MSB or LSB? My first guess is using a union, something like union uint32_u { uint32_t data; uint16_t bits[2]; }; // define a multiply indexed set with indices by id and name typedef boost::multi_index::multi_index_container< uint32_u, boost::multi_index::indexed_by< // sort by MSB boost::multi_index::ordered_non_unique<boost::multi_index::member<employee, uint16_t, uint32_u.bits[0]>>, // sort by LSB boost::multi_index::ordered_non_unique<boost::multi_index::member<employee, uint16_t, uint32_u.bits[1]>>, > > integer_set; But I cannot obviously compile it. Is there a way I can do this? Thanks!

2 12

[boost][sync?] "Distributed" value (or something...)
by Klaim - Joël Lamotte 31 Jul '14

31 Jul '14

I would like to ask Boost developers and users: 1. Am I the only one seeing the following pattern in my concurrent systems code? 2. Is there already some tools available in Boost that does what I describe here and that I am not aware of? 3. If not, would there be any interest in the tool I'm describing here or not? Is it a dumb idea? (I keep getting back to this idea but I'm surprised not finding anything similar online) The pattern that I am seeing occurs when: 1. I have a value or a set of values in an object or several objects which value(s) describe some kind of configuration that several other systems will read and use. 2. The object(s) will be updated only by one thread (at a time). 3. When the object's value is modified, all the systems that rely on the object's value have to be notified so that they update themselves using that value. 4. The systems I am refering to can use different threads for updating and we can assume that they are running concurrently. 5. It is not important that the source object's value is synched with the reader's values at all time, however it is important that the sequence of changes to the source object's value is signaled to the readers exactly in the same order and "as fast as possible", but delay is ok. The simplest solution to solve this is to have a mutex locking the value and the systems checking the value regularly. (that is, using syncrhonized_value for example) However the locking and looping reads might not be necessary if it is done in another way (if I am correct, I still lack experience in the domain). The solution that I am thinking about would look like this. ///////// // The object containing the value used by the other systems. class System_A { distributed_source<int> m_foo_count; // changes to this object will be sent to "readers"... public: System_A() : m_foo_count(42) ... {} //... // thread-safe read-only access distributed_value<int> make_foo_count_reader() const { return distributed_value<int>{ m_foo_count }; } }; ///////// // The different systems acquire a read access to the value. class System_B { distributed_value<int> foo_count; // read-only value reflecting System_A::m_foo_count's value since last update. public: SystemB( const System_A& system_a, ... ) : m_foo_count( system_a.make_foo_count_reader() ) { // setup the initial config... on_foo_count_changed( *m_foo_count ); // trigger some processing when SystemA::foo_count's value have been changed: m_foo_count.on_changed( [this]( int new_value ){ // called after the value have been changed m_work_queue.push( [=]{ // will be executed on the next update cycle for this system... on_foo_count_changed( new_value ); / }); }); } //... private: void update_cycle( const UpdateInfo& info ) { // ... // the following is just to clarify: const int foo_before = *m_foo_count; // the value is not updated yet, but we can still use it m_work_queue.execute(); const int foo_after = *m_foo_count; // the value might have been udpated if( foo_before != foo_after ) { // the value have been updated (though you don't need to do this if you used the callback instead). } //... }; }; //////// // At some point the value is changed by the system owning the source object... System_A::change_foo( int new_value ) { m_work_queue.push( [=]{ // will be executed on the next update cycle of this system... // ... *m_foo_count = new_value; // assign the new value then send the new value to the readers... }); } System_A::something_complex( std::function<void(int&)> some_work ) { m_work_queue.push( [=]{ // ... m_foo_count.update( some_work ); // execute on the current value then send the resulting value to the readers }); } Some notes: a. The names are just invented while I write this email. b. I suppose that the distributed_source might have an interface similar to synchronized_value, anyway I didn't get farther than this idea. c. I see several different ways to implement this idea, some might be more efficient than others but I didn't do any tests yet (by lack of time). Thoughts?

2 4

Re: [Boost-users] [MSM] how to use a compilation firewall around inner state machines
by Mark.Bartosik＠thomsonreuters.com 31 Jul '14

31 Jul '14

Repost from different email client (prior ate linefeeds, sorry again). I have a state machine implemented with MSM (eUML) that currently has 80 transitions, there are two inner state machines. Compilation time is not great, but I have been dealing with it by BOOST_MSM_FAVOR_COMPILE_TIME and using parallel compilation where possible. Slow compilation time is an irritation and productivity killer, but my larger worry is that eventually the compiler will run out of memory. Especially as I will likely have to add another inner state machine with about 40 more transitions. Current we are using VS2008 but planning on moving everyone in the team to the VS2012 toolset but running under the VS2013 environment. I don't know if this will help, I doubt it. Currently compilation memory usage is up to 2.5GB per translation unit. So I would like to use a compilation firewall around the inner state machines. My plan is to implement concrete types for the inner state machines, with a process_event function: boost::msm::back::HandledEnum process_event( const boost::any & event ); Then within this function test for each event type to be handled by the inner state machine, and forward to a regular MSM state machine contained within the inner concrete type. I am hoping that this, plus on_entry and on_exit functions is about all I need to do. I expect that I will be able to get this to work, although an example on how to put a concrete wrapper around an inner state machine would be great, and importantly a list of limitations and work arounds for this technique would be helpful. My problem is that the outer state machine transition table has rows like this: exit_pt_( inner_state, inner_state_some_pseudo_exit_state ) / do_some_stuff() == outer_s2, exit_pt_( inner_state, inner_state_other_pseudo_exit_state ) / do_other_stuff() == outer_s3, If inner_state becomes a concrete type, then I don't know if this can be handled, and if so how? My best idea so far is for the inner_state to call process_event on the outer state machine and rewrite the outer machine's state transition table thus: inner_state + some_synthetic_event / do_some_stuff() == outer_s2, inner_state + other_synthetic_event / do_other_stuff() == outer_s3 The xxxx_synthetic_event's would be generated from within the inner state machine when it reaches one of the pseudo exit states. So in summary I would like to know: 1) Is there a documented example of putting a concrete wrapper around a inner state machine. 2) What is the list of limitations of doing this. e.g. exit_pt_ not working. 3) How should I deal with transitions in the outer state machine that were making use of exit_pt_ P.S. I've got to say that I think MSM is great! thanks - - Mark

2 1

Re: [Boost-users] [serialization] Please help me solve this compile error.
by Brian Wood 30 Jul '14

30 Jul '14

Bjorn Reese writes: On 07/30/2014 04:01 AM, Paul Blampspied wrote: >> boost::archive::binary_ oarchive oa(file); >> oa << PersistentManagedArray<int>(size, capacity, ints); //This line does not compile ! > > The stream operator in Boost.Serialization does not take temporary > objects, so create the PersistentManagedArray<T> object on a separate > line, and then pass it to the stream. The C++ Middleware Writer <http://webEbenezer.net> supports temporary objects. Here's an example: front_messages_middle::Marshal(sendbuf, cmw::marshalling_integer(::strtol(argv[1],0,10))); It doesn't support PersistentManagedArray, but I'm willing to consider adding support for that. More info here - http://webEbenezer.net/about.html -- Brian Ebenezer Enterprises http://webEbenezer.net

1 0

[MSM] how to use a compilation firewall around inner state machines
by Mark Bartosik 30 Jul '14

30 Jul '14

I have a state machine implemented with MSM (eUML) that currently has 80 transitions, there are two inner state machines. Compilation time is not great, but I have been dealing with it by BOOST_MSM_FAVOR_COMPILE_TIME and using parallel compilation where possible. Slow compilation time is an irritation and productivity killer, but my larger worry is that eventually the compiler will run out of memory. Especially as I will likely have to add another inner state machine with about 40 more transitions. Current we are using VS2008 but planning on moving everyone in the team to the VS2012 toolset but running under the VS2013 environment. I don't know if this will help, I doubt it. Currently compilation memory usage is up to 2.5GB per translation unit. So I would like to use a compilation firewall around the inner state machines. My plan is to implement concrete types for the inner state machines, with a process_event function: boost::msm::back::HandledEnum process_event( const boost::any & event ); Then within this function test for each event type to be handled by the inner state machine, and forward to a regular MSM state machine contained within the inner concrete type. I am hoping that this, plus on_entry and on_exit functions is about all I need to do. I expect that I will be able to get this to work, although an example on how to put a concrete wrapper around an inner state machine would be great, and importantly a list of limitations and work arounds for this technique would be helpful. My problem is that the outer state machine transition table has rows like this: exit_pt_( inner_state, inner_state_some_pseudo_exit_state ) / do_some_stuff() == outer_s2, exit_pt_( inner_state, inner_state_other_pseudo_exit_state ) / do_other_stuff() == outer_s3, If inner_state becomes a concrete type, then I don't know if this can be handled, and if so how? My best idea so far is for the inner_state to call process_event on the outer state machine and rewrite the outer machine's state transition table thus: inner_state + some_synthetic_event / do_some_stuff() == outer_s2, inner_state + other_synthetic_event / do_other_stuff() == outer_s3 The xxxx_synthetic_event's would be generated from within the inner state machine when it reaches one of the pseudo exit states. So in summary I would like to know: 1) Is there a documented example of putting a concrete wrapper around a inner state machine. 2) What is the list of limitations of doing this. e.g. exit_pt_ not working. 3) How should I deal with transitions in the outer state machine that were making use of exit_pt_ P.S. I've got to say that I think MSM is great! thanks - - Mark

1 1

equivalent of java.util.properties
by David Frank 30 Jul '14

30 Jul '14

I'm wondering if there is a boost equivalent of the java.util.properties package which can read java properties file. Thanks, Dave.

1 0

revisiting casting a boost::shared_ptr to void*
by Chris Cleeland 30 Jul '14

30 Jul '14

I'm resurrecting this topic: https://groups.google.com/forum/#!searchin/boost-list/shared_ptr$20void*/bo… because there is an unaddressed issue in it that I'm about to run into: "... beware the pointee may be deleted if the last copy of the shared pointer goes out of scope, as the raw pointer won't have incremented the reference count." I cannot be the first person to run into this--a common issue when crossing an API boundary. Has anyone come up with a good, safe solution wherein the reference count gets properly incremented? -- Chris Cleeland

7 16

[Graph] Large Graphs: performace boost
by Sensei 30 Jul '14

30 Jul '14

Dear all, Facing an increasing size in my experiments, I am wondering now if my data structure is still valid. I need to traverse a graph (with my custom A*) that now can easily contain 10M-100M nodes and 100M-400M edges. The graph is (now) without weights, but this may change in the future. The only thing that is guaranteed not to change is that the graph is immutable. The graphs might even be larger, and at some point I will move to parallel BGL, but not now. To spare some memory, I am using a CSR graph: typedef boost::compressed_sparse_row_graph<boost::bidirectionalS> boost_graph; graph_ = new boost_graph(boost::edges_are_unsorted_multi_pass, results.begin(), results.end(), nodelist().size()); I am dubious if this the best solution. I have two objectives right now, optimize with respect to 1) memory consumption, and 2) graph traversal time. The main operation I need to do on graph is just "given a node, find the adjacent ones" (with my A*). Do you suggest to switch to another graph data structure? How do you think I will sacrifice time for memory, and vice versa, if I move for instance to an adjacency list? Thanks for any suggestion!

1 0

Boost Based Proxy
by asim 29 Jul '14

29 Jul '14

In SSl case proxy will become a tunnel so whatever encrypted data i will get from client i have to forward it to server.But i am unable to read content as connection is keep alive (means no end of file exception) and due to encryption no header based reading i can do then how to read it. -- View this message in context: http://boost.2283326.n4.nabble.com/Boost-Based-Proxy-tp4665704.html Sent from the Boost - Users mailing list archive at Nabble.com.

1 0

[Serialization] XML: Necessity of attribute class_id although class_name is given
by Frank Stähr 29 Jul '14

29 Jul '14

Hello everybody, I would like to know what the purpose of the xml attribute class_id is, how it works and in which cases it can be omitted. An example: “Base” is the (abstract) base class of _GMTF_ and _TTF_, and _Hist_ also has got a similar base class. If a pointer of Hist is a member of GMTF and you want to serialize a pointer of Base, you get something like: <filter class_id="0" class_name="GMTF"> <m_bufHalfMaxSize>4</m_bufHalfMaxSize> <m_cutDetector class_id="1" class_name="Hist"></m_cutDetector> </filter> Here, the macros • BOOST_CLASS_EXPORT_GUID(...), • BOOST_CLASS_IMPLEMENTATION(..., boost::serialization::object_serializable) and • BOOST_CLASS_TRACKING(..., boost::serialization::track_never) are used. The problem now is: Although the exact classes are given by human-readable class names (and used!), you cannot omit or change the class_id. If you edit the XML file by hand, it can become invalid (-> exception on reading). It seems that the class ids are just ascending non-negative numbers. What are the rules for choosing the class ids? Why are they necessary? Is there a trick to remove this attribute or at least to ignore it? Thanks, Frank -- Frank Stähr Technische Universität Berlin Communication Systems Group Sekr. EN1 Einsteinufer 17 10587 Berlin, Germany

2 2

Pipe and Filters pattern with boost?
by Journeyer J. Joh 29 Jul '14

29 Jul '14

Hello list! I'd like to find a good approach to implement the Pipe and Filters pattern with boost. Could someone recommend me some useful boost library for this purpose? I only know asio. Is there any known example source code for this - Pipe and Filters pattern with boost. Thank you very much in advance! ---------------------------------------- Journeyer J. Joh o o s a p r o g r a m m e r a t g m a i l d o t c o m ----------------------------------------

4 4

[Boost 1.56 Beta] [Serialization] Compilation problem with classes having special new operators
by Hijok Payne 28 Jul '14

28 Jul '14

I was trying out the new Boost 1.56 beta and some of my serialization code fails to compile (they work fine with previous versions of Boost e.g. Boost 1.55). I am trying to do serialization of Eigen (http://eigen.tuxfamily.org/) matrices with following code: #include <Eigen/Core> #include <fstream> #include <boost/serialization/vector.hpp> #include <boost/archive/binary_oarchive.hpp> #include <boost/archive/binary_iarchive.hpp> //Boost Serialization of Eigen Matrix namespace boost { template<class Archive, typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> inline void serialize(Archive & ar, Eigen::Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& t, const unsigned int file_version) { size_t rows = t.rows(), cols = t.cols(); ar & rows; ar & cols; if (rows * cols != t.size()) t.resize(rows, cols); ar & boost::serialization::make_array(t.data(), t.size()); } } //Simple helper for serialization to a file template <typename T> bool serialize(const T& data, const std::string& filename) { std::ofstream ofs(filename.c_str(), std::ios::out | std::ios::binary); if (!ofs.is_open()) return false; { // use scope to ensure archive goes out of scope before stream boost::archive::binary_oarchive oa(ofs); oa << data; } ofs.close(); return true; } //Simple helper for de-serialization from a file template <typename T> bool deSerialize(T& data, const std::string& filename) { std::ifstream ifs(filename.c_str(), std::ios::in | std::ios::binary); if (!ifs.is_open()) return false; { // use scope to ensure archive goes out of scope before stream boost::archive::binary_iarchive ia(ifs); ia >> data; } ifs.close(); return true; } int main(int argc, char *argv[]) { typedef Eigen::Vector3d VectorType; VectorType* vec = new VectorType(1, 2, 3); serialize(vec, "v4d.dat"); std::cout << "v4d =\n" << *vec << std::endl; VectorType* vec_in; deSerialize(vec_in, "v4d.dat"); std::cout << "v4d_in =\n" << *vec_in << std::endl; return 0; } The error in Visual studio 2013 says: boost/archive/detail/iserializer.hpp(237): error C2665: 'Eigen::PlainObjectBase<Eigen::Matrix<double,3,1,0,3,1>>::operator delete' : none of the 3 overloads could convert all the argument types 2> c:\users\abhijit\codes\installs\eigen\eigen-install\include\eigen3\eigen\src/Core/PlainObjectBase.h(132): could be 'void Eigen::PlainObjectBase<Eigen::Matrix<double,3,1,0,3,1>>::operator delete(void *,const std::nothrow_t &) throw()' 2> c:\users\abhijit\codes\installs\eigen\eigen-install\include\eigen3\eigen\src/Core/PlainObjectBase.h(132): or 'void Eigen::PlainObjectBase<Eigen::Matrix<double,3,1,0,3,1>>::operator delete(void *,void *) throw()' 2> while trying to match the argument list '(VectorType *, size_t)' 2> C:\Boost\boost-1_56_0_b1\boost/archive/detail/iserializer.hpp(224) : while compiling class template member function 'void boost::archive::detail::heap_allocation<T>::has_new_operator::invoke_delete(T *)' There is also the following note, but I cannot seem to understand this. // if compilation fails here, the likely cause that the class // T has a class specific new operator but no class specific // delete operator which matches the following signature. Fix // your program to have this. Note that adding operator delete // with only one parameter doesn't seem correct to me since // the standard(3.7.4.2) says " // "If a class T has a member deallocation function named // 'operator delete' with exactly one parameter, then that function // is a usual (non-placement) deallocation function" which I take // to mean that it will call the destructor of type T which we don't // want to do here. I want to understand this issue because this breaks a lot of existing code.

1 1

Geometry: modifiable?
by Jeremy Murphy 28 Jul '14

28 Jul '14

Is there a generic way to modify geometry structurally? Say if I have a ring and I want to insert a new point? Or would I need to reach into the underlying container to make that kind of change? Thanks, cheers. Jeremy

2 3

[SmartPtr] enable_shared_from_raw
by Gavin Lambert 27 Jul '14

27 Jul '14

Hi all, Firstly, any chance this could get some documentation? Is the author still around? I'm thinking about using this at the moment for two separate reasons (and ways in which enable_shared_from_this seems to fall short): 1. shared_from_this can't be used from the constructor (requiring factory-method-init shenanigans); reportedly (https://groups.google.com/forum/#!topic/boost-list/8JWFZ56ry6k) shared_from_raw can, although I can't find specific details on the caveats mentioned. 2. What I *really* want to be able to do is to create a child object (most commonly a callback functor) that contains a weak_ptr, and it seems silly (and badly performant) to use the usual factory-init pattern to call shared_from_this just to degrade it back to a weak_ptr. And it should be possible to obtain that weak_ptr before any shared_ptr exists, and "fix" it later to point at the real shared_ptr, especially if it is known that the weak_ptr will never actually be used until that real shared_ptr exists. enable_shared_from_raw almost seems to fit the bill (according to http://stackoverflow.com/questions/22184772/why-is-boostenable-shared-from-…) but I encountered the same problem as in this post (http://lists.boost.org/boost-users/2013/05/78833.php) it works with shared_from_raw but not weak_from_raw. However this change: https://github.com/boostorg/smart_ptr/pull/8 fixes that. It looks like the two calls went down different code paths for some reason I can't fathom. Making this change (or the similar-but-better-style one mentioned in the PR discussion) makes the above scenario work as expected. I'm not sure if there was some specific reason to not do this before or if it was just an oversight. Any chance this can make it into 1.56? Or is it too late for that? Regards, Gavin Lambert

3 4

[mpi] potentially blocking send - require blocking
by Dave Clarke 25 Jul '14

25 Jul '14

The boost::mpi documentation for send() is: "This routine executes a potentially blocking send" This differs from MPI_Send() "This routine will block until the message is sent to the destination." I am developing an application which requires the code not to progress until the communication is complete. In which situations does "potentially blocking" apply? And, is there a way of guaranteeing it is complete, the equivalent of MPI_Wait() for MPI_Isend()? Regards, Dave

3 2

Compiling boost on Windows
by Freddy Martinez Garcia 24 Jul '14

24 Jul '14

Hi guys… I need compile the boost for windows but I’m not a windows user… I had made some compilation but the files generated by gcc (from MinGW) has .a extension and not .lib or .dll extension… how can I change that ?? best regard Freddy Martinez Garcia Lic. Ciencia de la Computacion C++ and Qt Senior Developer freddy311082(a)gmail.com

2 1