September 2016 - Boost-users - lists.preview.boost.org

[serialization] Runtime overhead of serialization archives
by georg＠schorsch-tech.de 25 Sep '16

25 Sep '16

Hi all, currently i try to measure the runtime overhead of serialization vs. plain c-style serialization. The goal is to send it from one process to an other process on the same machine. As my statemachines are written with boost::msm, i want to deliver types. For the IPC i used interprocess::message_queue. I wrote a template function for the test and added a trait to plug in the test functions. I tested on the same machine, once with Linux Debian stretch x64 and Win 10 x64 MSVC 2015. What really astonish me is the fact, that the measured times using boost::serilization is so high compared to "c-style: id + data" method. In the c-style method i used a FNV hash of the type name as the ID. All tests were done on a Intel Core i7 2670QM CPU. All results in sec. I sent/received 100000 objects over a message_queue. Boost 1.61.0 Linux x86_64 / gcc 6.1.1 Win 10 x64/ MSVC 2015 Boost XML Send 2.220753 8.255834 Boost XML Receive 3.208353 10.14462 Boost Text Send 2.024946 8.578654 Boost Text Receive 3.207359 10.704126 Boost BinarySend 2.018026 8.363865 Boost Binary Receive 3.17984 11.201501 Cstyle Send 0.13566 0.056814 Cstyle Receive 0.087906 0.058706 Char Send 0.071683 0.013965 Char Receive 0.062119 0.012631 To measure the real overhead of the message passing, i made a test and just sent 100000 plain chars over the "wire". There are two strange things: a) The serilization with boost seems to be about 16 times slower than the plain c-style method, the receive seems to be about 30 times slower. I think i do something wrong..... he tests were compiled on release mode. b) On the same hardware, the Windows implementation is so much slower than the Linux one... about factor 3. But at the c-style method, it turns around.... Linux is slower than Windows. Has anyone an idea whats the issue here? I added the code at the end of this text Best regards Georg // ----------------------------------------------------- // Code // ----------------------------------------------------- #define BOOST_TEST_MODULE first_tests #include <boost/test/unit_test.hpp> #include <boost/interprocess/ipc/message_queue.hpp> // send all data through this #include <boost/timer/timer.hpp> // measure the used time #include <iostream> // for output // STL Archive + Stuff #include <boost/serialization/base_object.hpp> #include <boost/serialization/export.hpp> #include <boost/serialization/shared_ptr.hpp> #include <boost/serialization/unique_ptr.hpp> // include headers that implement a archive in xml format #include <boost/archive/archive_exception.hpp> #include <boost/archive/xml_iarchive.hpp> #include <boost/archive/xml_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <boost/archive/text_oarchive.hpp> #include <boost/archive/binary_iarchive.hpp> #include <boost/archive/binary_oarchive.hpp> #include <boost/iostreams/device/array.hpp> #include <boost/iostreams/device/back_inserter.hpp> #include <boost/iostreams/stream.hpp> #include <memory> #include <stdint.h> #include <typeinfo> #include <vector> using namespace boost::interprocess; static const int test_count = 100000; // send this many structs // the test structure struct ev_test { long a = 1; unsigned long b = 2; }; // ---------------------------------------------------------------------------- // a packet on the wire // ---------------------------------------------------------------------------- using packet = std::vector<char>; //----------------------------------------------------------------------------- // Type carrier and its support // ---------------------------------------------------------------------------- namespace { class carrier_visitor_base; class carrier_base // the base in the queue { public: using ptr = std::unique_ptr<carrier_base>; virtual ~carrier_base() {} virtual void accept(carrier_visitor_base *p_visitor) = 0; template <class Archive> void serialize(Archive &ar, const unsigned int version) { } }; template <typename T> class carrier; class carrier_visitor_base { public: virtual ~carrier_visitor_base() {} virtual void handle(carrier<ev_test> *p_evt) = 0; virtual void handle(carrier<char> *p_evt) = 0; }; template <typename T> class carrier : public carrier_base // the specific carrier { public: explicit carrier() : m_data() {} explicit carrier(const T &data) : m_data(data) {} virtual void accept(carrier_visitor_base *p_visitor) override { p_visitor->handle(this); } T &data() { return m_data; } private: T m_data; }; } // ns anon // ---------------------------------------------------------------------------- // the traits for the chartest // ---------------------------------------------------------------------------- struct char_test { static const char *name() { return "char_test 'c': "; } static size_t msg_size() { return sizeof(char); } static char get_data() { return 'c'; } template <typename T> static packet to_wire(T data) { packet ret; ret.push_back(get_data()); return ret; } static carrier_base::ptr from_wire(const packet &data) { auto p_data = new carrier<char>(); p_data->data() = data[0]; return std::unique_ptr<carrier<char>>(p_data); } }; // ---------------------------------------------------------------------------- // the traits for the boost xml serialization test // ---------------------------------------------------------------------------- // ---------------------------------------------------------------------------- // external serialization function // ---------------------------------------------------------------------------- namespace boost { namespace serialization { // serialization function for ev_test template <class Archive> inline void serialize(Archive &ar, ev_test &t, const unsigned int version) { ar &BOOST_SERIALIZATION_NVP(t.a); ar &BOOST_SERIALIZATION_NVP(t.b); } // serialization function for carrier<T> template <class Archive, typename T> void serialize(Archive &ar, carrier<T> &t, const unsigned int version) { ar &boost::serialization::make_nvp( "carrier_base", boost::serialization::base_object<carrier_base>(t)); // BOOST_SERIALIZATION_BASE_OBJECT_NVP(a); auto &data = t.data(); ar &BOOST_SERIALIZATION_NVP(data); } } } // we must export all carrier BOOST_SERIALIZATION_SHARED_PTR(carrier<ev_test>) BOOST_CLASS_EXPORT(carrier<ev_test>) struct boost_xml_trait { static const char *name() { return "boost_xml_test: ev_test: "; } typedef boost::archive::xml_oarchive oarchive; typedef boost::archive::xml_iarchive iarchive; }; struct boost_text_trait { static const char *name() { return "boost_text_test: ev_test: "; } typedef boost::archive::xml_oarchive oarchive; typedef boost::archive::xml_iarchive iarchive; }; struct boost_binary_trait { static const char *name() { return "boost_binary_test: ev_test: "; } typedef boost::archive::xml_oarchive oarchive; typedef boost::archive::xml_iarchive iarchive; }; template <typename archive_trait> struct boost_test { static const char *name() { return archive_trait::name(); } static size_t msg_size() { return 600; } // throws boost::archive::archive_exception template <typename T> static packet to_wire(T data) { using namespace boost::iostreams; using T1 = typename std::remove_cv<T>::type; using BT = typename std::remove_reference<T1>::type; carrier_base::ptr p_carrier = std::make_unique<carrier<BT>>(data); packet p; { back_insert_device<packet> sink{ p }; stream<back_insert_device<packet>> os{ sink }; typename archive_trait::oarchive oa(os); oa << BOOST_SERIALIZATION_NVP(p_carrier); } return p; } // throws boost::archive::archive_exception static carrier_base::ptr from_wire(const packet &data) { using namespace boost::iostreams; carrier_base::ptr p_carrier; boost::iostreams::array_source source{ data.data(), data.size() }; stream<array_source> is{ source }; typename archive_trait::iarchive ia(is); // this takes the most time ia >> BOOST_SERIALIZATION_NVP(p_carrier); return p_carrier; } }; // ---------------------------------------------------------------------------- // the traits for the cstyle serialization test // ---------------------------------------------------------------------------- // ---------------------------------------------------------------------------- // cstyle serialization with fnv type identifier // ---------------------------------------------------------------------------- struct cstyle_test { static const char *name() { return "cstyle_test: "; } static size_t msg_size() { return 1000; } // FowlerNollVo hash function // https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function struct fnv { const static uint64_t base = 0xcbf29ce484222325; const static uint64_t prime = 0x00000100000001b3; const static uint64_t next(uint64_t current, size_t char_code) { return (current ^ char_code) * prime; } const static uint64_t value(const char *cptr, uint64_t interim = base) { return (*cptr == '\0') ? interim : value(cptr + 1, next(interim, static_cast<size_t>(*cptr))); } }; template <typename T> static packet to_wire(T data) { packet buffer(msg_size()); // to be fair, send the same amount of bytes const uint64_t id = fnv::value(typeid(T).name()); size_t pos = 0; assert(msg_size() >= sizeof(uint64_t) + sizeof(T)); // buffer.resize(buffer.size() + sizeof(uint64_t) + sizeof(T)); std::memcpy(buffer.data() + pos, &id, sizeof(uint64_t)); pos += sizeof(uint64_t); std::memcpy(buffer.data() + pos, &data, sizeof(T)); pos += sizeof(T); return buffer; } static carrier_base::ptr from_wire(const packet &data) { // get the id size_t pos = 0; uint64_t id; std::memcpy(&id, data.data() + pos, sizeof(uint64_t)); pos += sizeof(uint64_t); // create the specific pointer if (id == fnv::value(typeid(ev_test).name())) { assert(data.size() >= sizeof(uint64_t) + sizeof(ev_test)); auto p_evt = new carrier<ev_test>(); std::memcpy(&p_evt->data(), data.data() + pos, sizeof(ev_test)); return carrier_base::ptr(p_evt); } throw std::runtime_error("deserialize error"); } }; template <typename trait> void do_test() { class runtime : public carrier_visitor_base { public: virtual void handle(carrier<ev_test> *p_evt) override { i += p_evt->data().a; } virtual void handle(carrier<char> *p_evt) override { i += p_evt->data(); } int i = 0; }; try { std::cout << "Sending " << trait::name() << test_count << std::endl; // Erase previous message queue message_queue::remove("message_queue"); // Create a message_queue. message_queue mq(create_only // only create , "message_queue" // name , test_count // max message number , trait::msg_size() // max message size ); // send ev_tests boost::timer::auto_cpu_timer t; for (int i = 0; i < test_count; ++i) { auto buffer = trait::to_wire(ev_test()); mq.send(buffer.data(), buffer.size(), 0); } } catch (const interprocess_exception &ex) { message_queue::remove("message_queue"); std::cout << ex.what() << std::endl; BOOST_CHECK(true == false); } runtime rt; try { std::cout << "Receiving " << trait::name() << test_count << std::endl; // Open a message queue. message_queue mq(open_only // only create , "message_queue" // name ); message_queue::size_type recvd_size; packet buffer(trait::msg_size()); unsigned int priority; boost::timer::auto_cpu_timer t; for (int i = 0; i < test_count; ++i) { // receive the raw data mq.receive(buffer.data(), buffer.size(), recvd_size, priority); // deserialize auto p_carrier = trait::from_wire(buffer); // handle it to the protocol p_carrier->accept(&rt); } } catch (const interprocess_exception &ex) { message_queue::remove("message_queue"); std::cout << ex.what() << std::endl; BOOST_CHECK(true == false); } message_queue::remove("message_queue"); std::cout << "RT Counter: " << rt.i << std::endl << std::endl; } BOOST_AUTO_TEST_CASE(carrier_boost_xml_ev_test) { do_test<boost_test<boost_xml_trait>>(); } BOOST_AUTO_TEST_CASE(carrier_boost_text_ev_test) { do_test<boost_test<boost_text_trait>>(); } BOOST_AUTO_TEST_CASE(carrier_boost_binary_ev_test) { do_test<boost_test<boost_binary_trait>>(); } BOOST_AUTO_TEST_CASE(carrier_cstyle_ev_test) { do_test<cstyle_test>(); } BOOST_AUTO_TEST_CASE(carrier_char_test) { do_test<char_test>(); }

6 20

[boost][multiprecision] compile error with gcc 4.8.4
by Rob Conde 24 Sep '16

24 Sep '16

Please see the scenario below...am I doing something wrong or is this a gcc or multiprecision bug? Thanks, Rob Conde given the following code (multiPrecisionTest.cpp): #include <boost/multiprecision/cpp_int.hpp> #include <boost/multiprecision/cpp_bin_float.hpp> typedef boost::multiprecision::int128_t int128_t; typedef boost::multiprecision::cpp_bin_float_quad float128_t; int main() { int128_t intVal; float128_t floatVal(intVal.convert_to<float128_t>()); return 0; } -------------------------------------------------------------------------- g++ -std=c++0x -c multiPrecisionTest.cpp I get the following error: In file included from ./boost/multiprecision/cpp_int.hpp:1936:0, from multiPrecisionTest.cpp:1: ./boost/multiprecision/cpp_int/misc.hpp: In instantiation of ‘typename boost::enable_if_c<(boost::multiprecision::backends::is_trivial_cpp_int<boost::multiprecision::backends::cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && boost::multiprecision::is_signed_number<boost::multiprecision::backends::cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value)>::type boost::multiprecision::backends::eval_convert_to(R*, const boost::multiprecision::backends::cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&) [with R = boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<113u, (boost::multiprecision::backends::digit_base_type)2u, void, short int, -16382, 16383>, (boost::multiprecision::expression_template_option)0u>; unsigned int MinBits1 = 128u; unsigned int MaxBits1 = 128u; boost::multiprecision::cpp_integer_type SignType1 = (boost::multiprecision::cpp_integer_type)1u; boost::multiprecision::cpp_int_check_type Checked1 = (boost::multiprecision::cpp_int_check_type)0u; Allocator1 = void; typename boost::enable_if_c<(boost::multiprecision::backends::is_trivial_cpp_int<boost::multiprecision::backends::cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && boost::multiprecision::is_signed_number<boost::multiprecision::backends::cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value)>::type = void]’: ./boost/multiprecision/number.hpp:585:40: required from ‘void boost::multiprecision::number<Backend, ExpressionTemplates>::convert_to_imp(T*) const [with T = boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<113u, (boost::multiprecision::backends::digit_base_type)2u, void, short int, -16382, 16383>, (boost::multiprecision::expression_template_option)0u>; Backend = boost::multiprecision::backends::cpp_int_backend<128u, 128u, (boost::multiprecision::cpp_integer_type)1u, (boost::multiprecision::cpp_int_check_type)0u, void>; boost::multiprecision::expression_template_option ExpressionTemplates = (boost::multiprecision::expression_template_option)0u]’ ./boost/multiprecision/number.hpp:601:29: required from ‘T boost::multiprecision::number<Backend, ExpressionTemplates>::convert_to() const [with T = boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<113u, (boost::multiprecision::backends::digit_base_type)2u, void, short int, -16382, 16383>, (boost::multiprecision::expression_template_option)0u>; Backend = boost::multiprecision::backends::cpp_int_backend<128u, 128u, (boost::multiprecision::cpp_integer_type)1u, (boost::multiprecision::cpp_int_check_type)0u, void>; boost::multiprecision::expression_template_option ExpressionTemplates = (boost::multiprecision::expression_template_option)0u]’ multiPrecisionTest.cpp:10:54: required from here ./boost/multiprecision/cpp_int/misc.hpp:533:138: error: no type named ‘type’ in ‘struct boost::common_type<boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<113u, (boost::multiprecision::backends::digit_base_type)2u, void, short int, -16382, 16383>, (boost::multiprecision::expression_template_option)0u>, __int128 unsigned>’ typedef typename common_type<R, typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::local_limb_type>::type common_type; ^

2 17

[Ranges] Range adaptors and range lifetimes
by Álex Puchades 23 Sep '16

23 Sep '16

Hi boost users! I'm having some lifetime issues with range adaptors. It seems boost adaptors (at least, transformed_range) only store iterators from the original range, letting it go out of scope [1]. Unfortunately, this makes boost adaptors not compatible with ranges that return iterators that are only valid while the original range is in scope (ie: any iterator that references the original range). This type of ranges are useful to avoid the fat-iterator problem, as seen here [2]. Is there any reason for the current behaviour? Should I file a bug or has it been discussed before? Thanks for your help [1] https://github.com/boostorg/range/blob/develop/include/boost/range/adaptor/… [2] http://ericniebler.com/2013/11/07/input-iterators-vs-input-ranges/ -- Álex Puchades

1 0

boost coroutine 1.62 b2 deprecation typo
by Jason Mancini 23 Sep '16

23 Sep '16

Just noticing that there's probably a typo in one of the deprecation warnings, as it wants both defined: BOOST_COROUTINE_NO_DEPRECATION_WARNING BOOST_COROUTINES_NO_DEPRECATION_WARNING Jason

1 0

[Parallel BGL] Poor scalability of dijkstra and delta stepping parallel graph algorithms
by Alexander Frolov 21 Sep '16

21 Sep '16

Hi! I am evaluating scalability on various graph algorithms and found that base parallel SSSP algorithms in PBGL does not scale well in my cases. The plots for rmat (scale=20 and 22) are attached. The source code for the benchmark are attached as well. The main issue that makes me think that I'm doing smth wrong is that execution time of delta stepping algorithm is _increasing_ with node number. I tried to check the code but has not found anything suspicious. Can anybody help me with this issue? Best, Alexander

1 0

[Interprocess]: using condition variables with readers-writer lock (named_sharable_mutex)
by Chris Evans 21 Sep '16

21 Sep '16

Hi, I am trying to use condition variables to signify updated data in a managed_shared_memory segment. I have one "writer" and multiple "readers" of the shared state, so I am using a readers-writer lock as follows: using SharedMutex = bi::named_sharable_mutex; using ReadLock = bi::sharable_lock<SharedMutex>; using WriteLock = bi::scoped_lock<SharedMutex>; using NewEntryCondition = bi::named_condition_any; // With a "writer" block as follows: { WriteLock w_lock( sh_mut_ ); // Update the shared memory object sh_cond_.notify_all(); } // And a "reader" block as follows (many processes call the following simultaneously): { ReadLock r_lock( sh_mut_ ); sh_cond_.wait( r_lock, []() { std::cout << "checking predicate..." << std::endl; // predicate logic goes here... }); // Access object in shared memory here } Unfortunately, although the code compiles, the reader processes are never awakened from wait() and block forever. According to the following thread from 2011: http://lists.boost.org/boost-users/2011/02/66053.php "POSIX does not support condition variables with read-write locks (although I think Windows Vista does) so Interprocess does not offer any support for this." At the time, it appears named_condition_any didn't yet exist. Has the status of this changed in the last 5 years? Is there a suggested way of implementing readers-writer locks with condition variables using boost::interprocess? Thanks! -- Chris Evans Systems Engineer Azure Summit Technology, Inc. 3050 Chain Bridge Road, Suite 600 Fairfax, VA 22030

2 2

[compute] extending meta_kernel functionality
by Oswin Krause 20 Sep '16

20 Sep '16

Hi, I am trying to use boost.compute to extend my linear algebra library to GPUs. so far it helped me a lot with vectors as i can directly use the iterator interface. Matrices are harder. for matrices i need to overload the operator matrix(i,j)-> return the element (i,j). For this i have to return an expression which then offers operator<< with meta_kernel, for example template<class T, class IndexExpr1, class IndexExpr2> inline meta_kernel& operator<<(boost::compute::detail::meta_kernel &kernel, const matrix_element_expr<T, IndexExpr1, IndexExpr2> &expr) { return kernel << kernel.get_buffer_identifier<T>(expr.m_buffer, expr.m_address_space) << '[' << expr.m_expr1 <<"*" <<expr.m_stride1<<"+"<<expr.m_expr2<< "*"<<expr.m_stride2 << ']'; } Unfortunately all of this is in namespace boost::compute::detail, making it a no-go area. Therefore two questions: 1. How stable is i?/can meta_kernel be moved into a normal namespace? 2. Is there a different way to achieve this? (Note that the code above is only an example. I could hack it in this case using the return type of buffer_iterator but not in all cases unfortunately...)

1 0

boost::context "main" stack
by Michael Steinberg 20 Sep '16

20 Sep '16

Hello, is there some way to temporarily run a function on the main stack? I played around a bit, but failed ultimately since the first stub function to be called is getting a "null" context which I assume to be only a valid "return-context". We're facing a problem where a dialog run modally inside a context runs webkit, which triggers garbage collection, which fails miserably since it assumes we're on the "native" stack. If it were possible to run something "on-top" of the main stack, this could maybe be circumvented. Thank you, Michael

2 2

Insertion/Use of boost::multi_index
by Ram 19 Sep '16

19 Sep '16

Hi All , I have created a boost::multi_index container for my use and it compiles successfully. I would like to add my pointer objects to it. boost::multi_index does not seem to have an insert method defined which just takes one arguement which is what I would like the container to store. Maybe I didnt understand how boost::multi_index is meant to be used. Can you please explain to me how to insert an object which I wish the store in the container defined? How is it intended to be used? The container I defined is , typedef boost::multi_index_ClassX< ClassX*, boost::multi_index::indexed_by< boost::multi_index::hashed_unique< boost::multi_index::const_mem_fun<ParentOfClassX, Int64, &ParentOfClassX::getKey1>, boost::multi_index::const_mem_fun<ParentOfClassX, Int64, &ParentOfClassX::getKey2>, > > > MultiIndexedClassX; I would like to do an equivalent of, MultiIndexedClassX sample; ClassX a; sample.insert(&a); <- Since I am interested in storing a *X and I would like it to be indexed by various parameters of X. Also please let me know how to, 1. Insert *X into the container 2. Look up by a) Value of ParentOfClassX::Key1 b) Value of ParentOfClassX::Key2 Please also let me know if I have some basic understanding wrong since I am getting confused a lot in trying to use boost::multi_index. Thanks in advance, Ram

2 10

Help Required, trouble while using boost::multi_index
by Ram 19 Sep '16

19 Sep '16

Hi, I am trying to create a ClassX using "boost::multi_index" and I was successfully able to create a ClassX like, typedef boost::multi_index_ClassX< ClassX*, boost::multi_index::indexed_by< boost::multi_index::hashed_unique< boost::multi_index::const_mem_fun<ParentOfClassX, Int64, &ParentOfClassX::getKey1>, boost::multi_index::const_mem_fun<ParentOfClassX, Int64, &ParentOfClassX::getKey2>, > > > MultiIndexedClassX; This compiles perfectly with no problems. I am writing the code and compiling with Visual Studio 2005 and have included, #include <boost/multi_index_container.hpp> #include "boost/multi_index/hashed_index_fwd.hpp" #include <boost/multi_index/mem_fun.hpp> and have defined namespaces, using namespace boost::multi_index; using boost::multi_index::multi_index_container; using boost::multi_index::hashed_unique; using boost::multi_index::indexed_by; But when I create an object of that type like, MultiIndexedClassX sample; I get a big list compilation errors like, *c:\code\common\lib\boost\boost\multi_index\detail\node_type.hpp(44) : error C2903: 'node_class' : symbol is neither a class template nor a function template* * c:\code\common\lib\boost\boost\mpl\aux_\preprocessed\plain\apply_wrap.hpp(49) : see reference to class template instantiation 'boost::multi_index::detail::index_node_applier::apply<IndexSpecifierIterator,Super>' being compiled* * with* * [* * IndexSpecifierIterator=boost::mpl::v_iter<boost::mpl::vector1<boost::multi_index::hashed_unique<boost::multi_index::const_mem_fun<ParentOfClassX,GKey,ParentOfClassX::getKey1>,boost::multi_index::const_mem_fun<ParentOfClassX,Vs64,ParentOfClassX::getKey2>>>,0>,* * Super=boost::multi_index::detail::index_node_base<ClassX *,std::allocator<ClassX *>>* * ]* * c:\code\common\lib\boost\boost\mpl\aux_\preprocessed\plain\bind.hpp(207) : see reference to class template instantiation 'boost::mpl::apply_wrap2<F,T1,T2>' being compiled* * with* * [* * F=boost::multi_index::detail::index_node_applier,* * T1=boost::mpl::v_iter<boost::mpl::vector1<boost::multi_index::hashed_unique<boost::multi_index::const_mem_fun<ParentOfClassX,GKey,ParentOfClassX::getKey1>,boost::multi_index::const_mem_fun<ParentOfClassX,Vs64,ParentOfClassX::getKey2>>>,0>,* * T2=boost::multi_index::detail::index_node_base<ClassX *,std::allocator<ClassX *>>* * ]* * c:\code\common\lib\boost\boost\mpl\aux_\preprocessed\plain\apply_wrap.hpp(49) : see reference to class template instantiation 'boost::mpl::bind2<F,T1,T2>::apply<U1,U2>' being compiled* * with* * [* * F=boost::multi_index::detail::index_node_applier,* * T1=boost::mpl::_2,* * T2=boost::mpl::_1,* * U1=boost::multi_index::detail::index_node_base<ClassX *,std::allocator<ClassX *>>,* * U2=boost::mpl::v_iter<boost::mpl::vector1<boost::multi_index::hashed_unique<boost::multi_index::const_mem_fun<ParentOfClassX,GKey,ParentOfClassX::getKey1>,boost::multi_index::const_mem_fun<ParentOfClassX,Vs64,ParentOfClassX::getKey2>>>,0>* * ]* * c:\code\common\lib\boost\boost\mpl\aux_\preprocessed\plain\apply.hpp(63) : see reference to class template instantiation 'boost::mpl::apply_wrap2<F,T1,T2>' being compiled* * with* * [* * F=boost::mpl::bind2<boost::multi_index::detail::index_node_applier,boost::mpl::_2,boost::mpl::_1>,* * T1=boost::multi_index::detail::index_node_base<ClassX *,std::allocator<ClassX *>>,* * T2=boost::mpl::v_iter<boost::mpl::vector1<boost::multi_index::hashed_unique<boost::multi_index::const_mem_fun<ParentOfClassX,GKey,ParentOfClassX::getKey1>,boost::multi_index::const_mem_fun<ParentOfClassX,Vs64,ParentOfClassX::getKey2>>>,0>* * ]* * c:\code\common\lib\boost\boost\mpl\aux_\preprocessed\plain\reverse_iter_fold_impl.hpp(58) : see reference to class template instantiation 'boost::mpl::apply2<F,T1,T2>' being compiled* * with* * [* * F=boost::mpl::bind2<boost::multi_index::detail::index_node_applier,boost::mpl::_2,boost::mpl::_1>,* * T1=boost::multi_index::detail::index_node_base<ClassX *,std::allocator<ClassX *>>,* * T2=boost::mpl::v_iter<boost::mpl::vector1<boost::multi_index::hashed_unique<boost::multi_index::const_mem_fun<ParentOfClassX,GKey,ParentOfClassX::getKey1>,boost::multi_index::const_mem_fun<ParentOfClassX,Vs64,ParentOfClassX::getKey2>>>,0>* * ]* Thanks, Ram

2 5