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

Boost.Asio thread pool - add/remove threads at runtime
by Vance Grkov 15 Apr '10

15 Apr '10

I am creating a simple task and timer thread pool using Boost.Asio. I am searching for the recommended way to dynamically add and remove threads to the thread pool. I don’t want to have to queue up tasks most of the time, only when the thread count gets very high (100s) queuing is ok, also I want for the thread count to go down to example 5 threads when there is no more work presented to the thread pool. This is because some of the tasks can take some time to complete and I don't want to hold off other tasks when computer resource are still available. Basically this is the solution I have in mind now. Given the following configuration values: gInitialThreadPoolSize = 4; gMaximumThreadPoolSize = 1024; gNumberOfThreadsDoingWork = 0; And 2 events: HANDLE moreWorkAvailable; HANDLE exit; Create a thread pool using this worker function: void ThreadWorkerFunction(boost::asio::io_service *io, boost::thread &thread) { for (;;) { HANDLE objects[] = { moreWorkAvailable, exit }; errorCode = WaitForMultipleObjects(objects) if (errorCode == WAIT_OBJECT_0) { // More work is available, lets start processing... gNumberOfThreadsDoingWork++; io->run(); gNumberOfThreadsDoingWork--; // When all work has been processed, go back to the original thread pool size if (threads.size() < gInitialThreadPoolSize ) { threads.remove(thread); break; } } else if (errorCode == WAIT_OBJECT_1) { threads.remove(thread); break; } } } This is now the thread pool is created: std::vector<boost::shared_ptr<boost::thread> > threads; for (std::size_t i = 0; i < gInitialThreadPoolSize; ++i) { boost::shared_ptr<boost::thread> thread(new boost::thread( boost::bind(&ThreadWorkerFunction, &io, thread) )); threads.push_back(thread); } Next every time a task is inserted into the queue we check if all worker threads are busy, and in case they are busy, create a new thread if (threadsDoingWork == threads.size()) { boost::shared_ptr<boost::thread> thread(new boost::thread( boost::bind(&worker, &io) )); threads.push_back(thread); } SetEvent(moreWorkAvailable); Also in the ThreadWorkerFunction(...) function, after io->run() returns, we can check if more than N threads are idle and keep exiting until we get at minimum. I would appreciate if you can let me know if there is some better and more simpler way to achieve this than implementing this myself. I am new to Asio so I might have overlooked something. _________________________________________________________________ Hotmail: Trusted email with powerful SPAM protection. https://signup.live.com/signup.aspx?id=60969

2 2

[interprocess] ARM atomic operations problem.
by Ivan Dundek 15 Apr '10

15 Apr '10

Hi all. I've tried to test the boost IPC communication using: - boost::interprocess::shared_memory_object - boost::interprocess::mapped_region - boost::interprocess::interprocess_mutex - boost::interprocess::interprocess_condition So I created shared memory, and when the first process put the data into the shared memory, call the notify_one() method, to let the second process know, taht there are data in the shared memory. Everything is OK, when I'm using gcc 4.4.1 on linux. But when I tried to cross-compile the sources using arm-linux toolchain, which is based on gcc 3.3.2, I'm always geting error: "#error No atomic operations implemented for this platform, sorry!" I know, that if I will use gcc 4 and above, it will works. But is there any workaround or fix, how to compile boost::interprocess on gcc 3.3.2? Thank you for your advices. Dundee.

2 2

[Spirit] questions about on_error and expectation points
by philip tucker 15 Apr '10

15 Apr '10

I have attached a code fragment (no driver) and a gcc error message. Please refer to the attached code. There, I ask three questions: - Why won't > compile where I expect it to? - Why are parentheses necessary in an expectation operator expression? - How can I detect and report an error in a particular case?

1 0

[Chrono]
by Roland Bock 14 Apr '10

14 Apr '10

Hi, forgive me for asking the obvious, but I fail to see how to get timing information from the thread_clock? I can call thread_clock::now() to get time_point objects, e.g. boost::chrono::thread_clock threadClock; boost::chrono::thread_clock::time_point start = threadClock.now(); [...] boost::chrono::thread_clock::time_point end = threadClock.now(); But how do I get to the actual CPU milliseconds (or other units?) used by the current thread between end and start? Thanks and regards, Roland

2 2

Please help with enable_if problem
by John Dlugosz 14 Apr '10

14 Apr '10

I'm getting tons of this from Microsoft's compiler: error C2893: Failed to specialize function template 'enable_if<boo... Reading the compiler docs, C2893 gives an example occurs because f's template parameter T is deduced to be std::map<int,int>, but std::map<int,int> has no member data_type (T::data_type can not be instantiated with T = std::map<int,int>.) but isn't that the whole point of using enable_if? I'm using it already in my project and understand the idea behind it. Here is the function in question: template <typename T, typename D> typename enable_if< boost::mpl::and_< std::tr1::is_base_of<generic_linear_time_ntbase, T>, boost::mpl::or_< is_dimensional_time<D>, std::tr1::is_same<duration,D>, std::tr1::is_same<linear_duration,D> > >, T>::type& operator+= (T& left, const D& right) { left.addop_ (right); // real implementation is in the generic base class return *this; // but I need this template to return the correct derived (actual) class. } Basically, I want to implement operator+= in a base class, but actual use is through derived classes of the common base. Rather than repeating a half dozen forms in each class that calls the common base and downcasts the return value, I made the real implementation in a named function, and this stand-alone function that calls it. enable_if is used to make this += present only for left arguments that are derived from the class of interest, and a right argument that is two specific classes or otherwise noted with the predicate. I've successfully used the predicate (derives from true_type or false_type) in other uses of enable_if. I've even mixed boost::mpl::or_ and and_ with the compiler-supplied TR1 before, with something quite similar. Here's one that does work: template <typename T, typename D> typename enable_if< boost::mpl::and_<is_Universal_time_API<T>, boost::mpl::or_<is_Universal_duration_API<D>,is_dimensional_time<D> > >, T>::type operator+ (const T& t1, const D& d1) { T temp (t1); temp += d1; return temp; } My predicates are based on the native TR1's true_type/false_type. Thanks, --John TradeStation Group, Inc. is a publicly-traded holding company (NASDAQ GS: TRAD) of three operating subsidiaries, TradeStation Securities, Inc. (Member NYSE, FINRA, SIPC and NFA), TradeStation Technologies, Inc., a trading software and subscription company, and TradeStation Europe Limited, a United Kingdom, FSA-authorized introducing brokerage firm. None of these companies provides trading or investment advice, recommendations or endorsements of any kind. The information transmitted is intended only for the person or entity to which it is addressed and may contain confidential and/or privileged material. Any review, retransmission, dissemination or other use of, or taking of any action in reliance upon, this information by persons or entities other than the intended recipient is prohibited. If you received this in error, please contact the sender and delete the material from any computer.

2 2

Problem using boost::bind
by Iskandar Prins 14 Apr '10

14 Apr '10

Hi, Im trying to use boost::bind with 2 parameters on a member function, bind(&Foo::bar, this, _1, _1)); but somehow this fails compilation. Whats the proper syntaxis? Greets, Iskandar

3 3

Re: [Boost-users] [future] [Visual Studio 8.0] [1.42.0] Include File compiler failure
by Robert Douglas 14 Apr '10

14 Apr '10

Sorry to reply to my own post, but I found a solution, though it requires a code change to boost: struct all_futures_lock { unsigned count; boost::scoped_array<boost::unique_lock<boost::mutex> > locks; all_futures_lock(std::vector<registered_waiter>& futures): count(static_cast<unsigned>(futures.size())),locks(new boost::unique_lock<boost::mutex>[count]) { for(unsigned i=0;i<count;++i) { locks[static_cast<std::ptrdiff_t>(i)]=boost::unique_lock<boost::mutex>(futures[i].future->mutex); } } void lock() { boost::lock(locks.get(),locks.get()+count); } void unlock() { for(unsigned i=0;i<count;++i) { locks[static_cast<std::ptrdiff_t>(i)].unlock(); } } }; Note the 3 static casts, the first is to avoid a warning, and the second two are to explicitly convert the unsigned variable to std::ptrdiff_t. VS 8.0 file "Microsoft Visual Studio 8\VC\include\crtdefs.h" line 516 defines ptrdiff_t as being "_w64 int" type. Thus, the T& scoped_array<T>::operator[](std::ptrdiff_t i) const function has an argument mismatch with unsigned. I realize that unsigned should convert to int just fine, so I'm not sure if this is a compiler issue or not. First Question: Is there anyone with a bit more experience on implicit conversions who can shed some light on whether or not the unsigned should be implictly converted to int, or whether a default function should be matched? Other question, is where is this *other* function coming from? Looking through the preprocessed file, I cannot find any other places where there is a operator[] being used on a scoped_array of any type. Second Question: Is is safe for me to change this header file, and build against it, while linking against the libraries which were built without this change? If not, can anyone suggest a better way to achieve this without having to modify the boost header? Thanks! -RD

1 0

Re: [Boost-users] [Boost.mpi] Installation with Intel compilers (solved)
by Federico Golfrè Andreasi 14 Apr '10

14 Apr '10

The fix you suggested me worked well ! Thank you !!! Date: Mon, 12 Apr 2010 10:17:11 -0600 > From: "Belcourt, Kenneth" <kbelco(a)sandia.gov> > > You could try to edit mpi.jam around line 221 like this: > > if $(otherflags) { > for unknown in $(unknown-features) > { > result += "$(unknown)$(otherflags:J= )" ; > } > } > >

1 0

math round() functions: away from 0
by Hicham Mouline 14 Apr '10

14 Apr '10

Hello,boost/trunk/libs/math/doc/sf_and_dist/html/math_toolkit/utils/rounding/round.html says that: Halfway cases are rounded away from zero, regardless of the current rounding direction.This is compatible with C99 TC3 and therefore the latest C++1x draft.However, when I ran this program:#include <cmath>#include <iostream>#include <boost/math/special_functions/round.hpp>inline double round1(double x){ if (x >= 0.0) return std::floor(x + 0.5); else return std::ceil(x - 0.5);}inline double round2(double x){ return std::floor(x + 0.5);}int main(){ std::cout.setf(std::ios_base::fixed, std::ios_base::floatfield); std::cout.precision(1); std::cout<< "d floor/ceil.5 floor.5 boostmathround"<<std::endl; for (double d=-10.5; d<11; d+=0.5) std::cout<< d<<" "<< round1(d)<<" "<<round2(d)<<" "<< boost::math::iround<double>(d)<<std::endl; return 0;}under g++4.3.x and msvc2008 with trunk, the output for all the negative halves does not seem to be away from 0.The same for boost::math::round<double>(d)This stuff most likely depends on the bit pattern, so I investigated further. I raised the precision of std::cout to 18 decimals.I then rounded this:const double dd = -10.5;which yieldedd floor/ceil.5 floor.5 boostmathround-10.500000000000000000 -11.000000000000000000 -10.000000000000000000 -10and for (double d=-10.6; d<-10.4; d+=0.01) std::cout<< d<<" "<< round1(d)<<" "<<round2(d)<<" "<< boost::math::iround(d)<<std::endl;-10.600000000000000000 -11.000000000000000000 -11.000000000000000000 -11-10.590000000000000000 -11.000000000000000000 -11.000000000000000000 -11-10.580000000000000000 -11.000000000000000000 -11.000000000000000000 -11-10.570000000000000000 -11.000000000000000000 -11.000000000000000000 -11-10.560000000000000000 -11.000000000000000000 -11.000000000000000000 -11-10.550000000000001000 -11.000000000000000000 -11.000000000000000000 -11-10.540000000000001000 -11.000000000000000000 -11.000000000000000000 -11-10.530000000000001000 -11.000000000000000000 -11.000000000000000000 -11-10.520000000000001000 -11.000000000000000000 -11.000000000000000000 -11-10.510000000000002000 -11.000000000000000000 -11.000000000000000000 -11-10.500000000000002000 -11.000000000000000000 -11.000000000000000000 -11-10.490000000000002000 -10.000000000000000000 -10.000000000000000000 -10-10.480000000000002000 -10.000000000000000000 -10.000000000000000000 -10-10.470000000000002000 -10.000000000000000000 -10.000000000000000000 -10-10.460000000000003000 -10.000000000000000000 -10.000000000000000000 -10-10.450000000000003000 -10.000000000000000000 -10.000000000000000000 -10-10.440000000000003000 -10.000000000000000000 -10.000000000000000000 -10-10.430000000000003000 -10.000000000000000000 -10.000000000000000000 -10-10.420000000000003000 -10.000000000000000000 -10.000000000000000000 -10-10.410000000000004000 -10.000000000000000000 -10.000000000000000000 -10-10.400000000000004000 -10.000000000000000000 -10.000000000000000000 -10-10.5 has the exact representation in IEEE754 as the 64bit:0000000000000000000000000000000000000000000000001010010000000011with, accross all the bits (not bytes), the least significant first.It is an _exact_ representation as far as I can tell.therefore the round function should round _away_ from 0, to give -11, shouldn't it?round1() however seems to do the right thing....Regards,

2 1

[Filesystem] Locking files
by Adam Badura 14 Apr '10

14 Apr '10

Is it possible to lock a file with Boost.Filesystem to prevent its deletion, writing or reading? Adam Badura

4 6

enable_if help
by John Dlugosz 13 Apr '10

13 Apr '10

I need to amend my last post (which I can't reply to since it's not showing up on the list yet). The operator+ example doesn't work either. I just didn't notice since it uses +=. I realized that after I posted, and tried testing that separately. However, it gives a different error. It's a more ordinary "no operator found which takes..." which is typical of getting the enable_if wrong so it's not enabled or arguments can't be deduced. So now I'm wondering if the trouble is the and/or. I had assumed that the true_type/false_type were compatible between MPL and the native TR1, since it boils down to "type" and "value". But now I'm thinking that the templates work by mentioning those specific classes. The enable_if and disable_if have proven to work with the native TR1 tests and my own which use the native true/false_type. So I assumed that precautions were taken to interoperate. Maybe the same isn't true with and_ and or_ ? The underlying issue is that TR1 took much of type_traits, but not the composition of primitives. Plauger appears to have an "and" he uses internally, but no "or". If you think that's the trouble, is there something like the _c form that might work with the underlying types? Or maybe I'm barking up the wrong tree; after all, enable_if works fine. --John TradeStation Group, Inc. is a publicly-traded holding company (NASDAQ GS: TRAD) of three operating subsidiaries, TradeStation Securities, Inc. (Member NYSE, FINRA, SIPC and NFA), TradeStation Technologies, Inc., a trading software and subscription company, and TradeStation Europe Limited, a United Kingdom, FSA-authorized introducing brokerage firm. None of these companies provides trading or investment advice, recommendations or endorsements of any kind. The information transmitted is intended only for the person or entity to which it is addressed and may contain confidential and/or privileged material. Any review, retransmission, dissemination or other use of, or taking of any action in reliance upon, this information by persons or entities other than the intended recipient is prohibited. If you received this in error, please contact the sender and delete the material from any computer.

1 0

[function] Boost.Function won't compile under Borland DevStudio 2006
by Fábio 'Petrucio' Stange 13 Apr '10

13 Apr '10

I've just recently learned about boost::function when reading Effective C++, and I was thrilled about it. This is the simple code I'm trying to implement: typedef boost::function1<void, boost::shared_ptr<VarSpeedObject> > ObjectDoneCallback; void SomeFunction(ObjectDoneCallback callback, ...) { // Some code callback(...); } When trying to compile it under C++ Builder 2006 (I have no other choice but to use this in the current project), I get the following error: [C++ Error] function_template.hpp(904): E2131 Objects of type 'detail::function::basic_vtable1<void,shared_ptr<VarSpeedObject> >' cannot be initialized with { } On this line in function_template.hpp: static vtable_type stored_vtable = { { &manager_type::manage }, &invoker_type::invoke }; Can I circumvent this somehow to make it compile under my environment? Thanks, Petrucio

2 8

[future] [Visual Studio 8.0] [1.42.0] Include File compiler failure
by Robert Douglas 13 Apr '10

13 Apr '10

Using: Boost 1.42.0 Visual Studio 2.0.50727 SP2 I have a managed C++ project which exposes a set of C++ utilities as a dll. One particular file transitively includes future.hpp. Deep in future.hpp's detail namespace, it comes across: <code> struct all_futures_lock { unsigned count; boost::scoped_array<boost::unique_lock<boost::mutex> > locks; all_futures_lock(std::vector<registered_waiter>& futures): count(futures.size()),locks(new boost::unique_lock<boost::mutex>[count]) { for(unsigned i=0;i<count;++i) { locks[i]=boost::unique_lock<boost::mutex>(futures[i].future->mutex); } } ... void unlock() { for(unsigned i=0;i<count;++i) { locks[i].unlock(); } } }; </code> the line : locks[i].unlock(); fails with the following error: <a path>\v1_42_0\include\boost/thread/future.hpp(414) : error C2666: 'boost::scoped_array<T>::operator []' : 2 overloads have similar conversions 1> with 1> [ 1> T=boost::unique_lock<boost::mutex> 1> ] 1> <a path>\boost\v1_42_0\include\boost/smart_ptr/scoped_array.hpp(77): could be 'boost::unique_lock<Mutex> &boost::scoped_array<T>::operator [](ptrdiff_t) const' 1> with 1> [ 1> Mutex=boost::mutex, 1> T=boost::unique_lock<boost::mutex> 1> ] 1> or 'built-in C++ operator[(void (__cdecl *)(boost::scoped_array<T> ***), unsigned int)' 1> with 1> [ 1> T=boost::unique_lock<boost::mutex> 1> ] 1> while trying to match the argument list '(boost::scoped_array<T>, unsigned int)' 1> with 1> [ 1> T=boost::unique_lock<boost::mutex> 1> ] Does anyone have any idea what is causing this, and how I might go about resolving it? Sorry if this has ever been brought up, but I could not find anything about this issue in google searches or this mailing list. Thanks in Advance! -RD

1 0

deadline_timer and a crash at ~io_service -> timer_base::destroy()
by Vance Grkov 13 Apr '10

13 Apr '10

Hi, I am getting a crash at the scope end (before the "catch") below in the code. This is the stack trace and the source. Does anyone know what is the problem with this code? Appreciate your help! 000801c7() > BoostThreadPoolTest.exe!boost::asio::detail::timer_queue<boost::asio::time_traits<boost::posix_time::ptime> >::timer_base::destroy() Line 211 + 0xe bytes C++ BoostThreadPoolTest.exe!boost::asio::detail::timer_queue<boost::asio::time_traits<boost::posix_time::ptime> >::destroy_timer_list(boost::asio::detail::timer_queue<boost::asio::time_traits<boost::posix_time::ptime> >::timer_base * & t=0x00338da0) Line 415 C++ BoostThreadPoolTest.exe!boost::asio::detail::timer_queue<boost::asio::time_traits<boost::posix_time::ptime> >::destroy_timers() Line 189 C++ BoostThreadPoolTest.exe!boost::asio::detail::win_iocp_io_service::shutdown_service() Line 148 + 0x2c bytes C++ BoostThreadPoolTest.exe!boost::asio::detail::service_registry::~service_registry() Line 75 + 0xf bytes C++ BoostThreadPoolTest.exe!boost::asio::detail::service_registry::`scalar deleting destructor'() + 0x2b bytes C++ BoostThreadPoolTest.exe!boost::asio::io_service::~io_service() Line 52 + 0x2e bytes C++ BoostThreadPoolTest.exe!wmain(int argc=1, wchar_t * * argv=0x003371d8) Line 152 + 0x27 bytes C++ BoostThreadPoolTest.exe!__tmainCRTStartup() Line 583 + 0x19 bytes C BoostThreadPoolTest.exe!wmainCRTStartup() Line 403 C kernel32.dll!_BaseProcessStart@4() + 0x23 bytes #include "stdafx.h" #include <iostream> #include <boost/thread.hpp> #include <boost/bind.hpp> #include <boost/shared_ptr.hpp> #include <boost/asio.hpp> #define THREAD_POOL_SIZE 10 void TimerCallback(boost::system::error_code ec, std::size_t i, std::size_t retry) { std::stringstream tmp; tmp << "Timer(" << ec.value() << ":" << ec.message() << "-" << retry << "-" << i << ")\n"; } // // MAIN // int _tmain(int argc, _TCHAR* argv[]) { try { boost::asio::io_service io(THREAD_POOL_SIZE); boost::asio::io_service::work *moreWorkToCome = new boost::asio::io_service::work(io); // Create a pool of worker threads. std::vector<boost::shared_ptr<boost::thread> > threads; for (std::size_t i = 0; i < THREAD_POOL_SIZE; ++i) { boost::shared_ptr<boost::thread> thread(new boost::thread( boost::bind(&boost::asio::io_service::run, &io) )); threads.push_back(thread); } // Lets enqueue more tasks to run after a given time std::vector<boost::asio::deadline_timer *> timers; for (std::size_t i = 1; i<50; i++) { boost::asio::deadline_timer *timer = new boost::asio::deadline_timer(io); timer->expires_from_now(boost::posix_time::seconds(3)); timer->async_wait(boost::bind(&TimerCallback, boost::asio::placeholders::error, i, 0)); timers.push_back(timer); } std::cout << "\nALL TASKS QUEUED\n"; // Now that all tasks have been queued we don't want to hold on any of the worker threads delete moreWorkToCome; std::cout << "\nRELEASE THE THREAD POOL\n"; // Wait for all tasks to be processes which also means all threads in the pool will exit. for (std::size_t i = 0; i < threads.size(); ++i) threads[i]->join(); // Cancel all timers (just in case) for (std::size_t i = 0; i < timers.size(); ++i) timers[i]->cancel(); io.stop(); std::cout << "\nPOOL DOWN\n"; } <-------------------------------------------- CRASH catch(...) { std::cout << "ERROR"; } std::cout << "\nEXIT\n"; return 0; } Hotmail: Trusted email with powerful SPAM protection. Sign up now. _________________________________________________________________ Hotmail: Free, trusted and rich email service. https://signup.live.com/signup.aspx?id=60969

3 4

[MPI] MPI auto-detection failed: unknown wrapper compiler...
by Ilja Honkonen 13 Apr '10

13 Apr '10

Hello I'm trying to install boost and its MPI bindings on a Cray XT5 and this is what I get after adding using mpi ; to user-config.jam: MPI auto-detection failed: unknown wrapper compiler /opt/cray/xt-asyncpe/3.3/bin/CC or MPI auto-detection failed: unknown wrapper compiler mpic++ (mpic++ -bash: mpic++: command not found) If I understand correctly boost only checks for mpicc and related executables and also tries mpirun. None of these are supposed to be used on an XT5. The compiler commands to use are cc, CC and ftn. More information for I think the same machine: http://www.csc.fi/english/pages/louhi_guide/program_development/compilers/i… This is how I'd run the test program from boost homepage Compile: cat > mpitesti.cpp << EOF #include <mpi.h> #include <iostream> int main(int argc, char* argv[]) { MPI_Init(&argc, &argv); int rank; MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (rank == 0) { int value = 17; int result = MPI_Send(&value, 1, MPI_INT, 1, 0, MPI_COMM_WORLD); if (result == MPI_SUCCESS) std::cout << "Rank 0 OK!" << std::endl; } else if (rank == 1) { int value; int result = MPI_Recv(&value, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE); if (result == MPI_SUCCESS && value == 17) std::cout << "Rank 1 OK!" << std::endl; } MPI_Finalize(); return 0; } EOF CC mpitesti.cpp -o mpitesti /opt/cray/xt-asyncpe/3.3/bin/CC: INFO: linux target is being used Then submit a job: cat > mpitesti.job << EOF #!/bin/sh #PBS -N mpitesti #PBS -l mppwidth=2 #PBS -l mppnppn=1 #PBS -j oe #PBS -l walltime=00:00:10 cd \$PBS_O_WORKDIR aprun -n 2 -N 1 -cc cpu ./mpitesti EOF qsub mpitesti.job 58665.sdb And after a few seconds: cat mpitesti.o58661 Rank 0 OK! Rank 1 OK! Application 125625 resources: utime 0, stime 0 Actually CC can be one of four different compilers depending on which PrgEnv module I've chosen: CC -V /opt/cray/xt-asyncpe/3.3/bin/CC: INFO: native target is being used pgCC 9.0-4 64-bit target on x86-64 Linux -tp k8-64e Copyright 1989-2000, The Portland Group, Inc. All Rights Reserved. Copyright 2000-2009, STMicroelectronics, Inc. All Rights Reserved. module switch PrgEnv-pgi PrgEnv-gnu CC --version /opt/cray/xt-asyncpe/3.3/bin/CC: INFO: linux target is being used g++ (GCC) 4.3.3 20090124 (rpm:2) Copyright (C) 2008 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. etc. I'd also like to use CC (and not necessarily g++) for compiling boost and not just its mpi bindings, how can I make bjam do that? Any other information you might need? Thanks Ilja Honkonen

3 3

[serialization] linker errors then building minimal application on WinXP 64
by pheres 13 Apr '10

13 Apr '10

Hello, the following stripped down code builds fine under 32bit platform but fails with lot of linker errors on the 64bit platform. Compiler is VS2005. I diagnosed the link procedure and found that my 64bit version of libboost_serialization-vc80-mt-1_42.lib is found and tried to link Does anybody know what I am doing wrong? Thank you in advance! -------------------------------------------- #include <boost/archive/xml_oarchive.hpp> #include <fstream> #include "boost/serialization/vector.hpp" #include "boost/serialization/set.hpp" #include "boost/serialization/utility.hpp" struct A_STRUCT { double mBlub; int saveXMLConfig() const { std::ofstream ofs("file", std::ios::binary); boost::archive::xml_oarchive oa(ofs); oa << boost::serialization::make_nvp("A_STRUCT", *this); return 0; } void save(boost::archive::xml_oarchive& ar, const unsigned int) const { ar & boost::serialization::make_nvp("mBlub", mBlub); } BOOST_SERIALIZATION_SPLIT_MEMBER() }; int main(){} -------------------------------------------- The build output: -------------------------------------------- 1>------ Build started: Project: test, Configuration: Debug x64 ------ 1>Compiling... 1>main.cpp 1>Linking to lib file: libboost_serialization-vc80-mt-gd-1_42.lib 1>Linking to lib file: libboost_serialization-vc80-mt-gd-1_42.lib 1>Linking to lib file: libboost_serialization-vc80-mt-gd-1_42.lib 1>Linking... 1> Creating library D:\Simulation\test\test\x64\Debug\test.lib and object D:\Simulation\test\test\x64\Debug\test.exp 1>main.obj : error LNK2019: unresolved external symbol "protected: __cdecl boost::archive::detail::basic_oserializer::basic_oserializer(class boost::serialization::extended_type_info const &)" (??0basic_oserializer@detail@archive@boost@@IEAA@AEBVextended_type_info@serialization@3@@Z) referenced in function "public: __cdecl boost::archive::detail::oserializer<class boost::archive::xml_oarchive,struct A_STRUCT>::oserializer<class boost::archive::xml_oarchive,struct A_STRUCT>(void)" (??0?$oserializer@Vxml_oarchive@archive@boost@@UA_STRUCT@@@detail@archive@boost@@QEAA@XZ) 1>main.obj : error LNK2019: unresolved external symbol "protected: __cdecl boost::archive::detail::basic_oserializer::~basic_oserializer(void)" (??1basic_oserializer@detail@archive@boost@@IEAA@XZ) referenced in function "public: virtual __cdecl boost::archive::detail::oserializer<class boost::archive::xml_oarchive,struct A_STRUCT>::~oserializer<class boost::archive::xml_oarchive,struct A_STRUCT>(void)" (??1?$oserializer@Vxml_oarchive@archive@boost@@UA_STRUCT@@@detail@archive@boost@@UEAA@XZ) 1>main.obj : error LNK2001: unresolved external symbol "public: virtual bool __cdecl boost::serialization::typeid_system::extended_type_info_typeid_0::is_less_than(class boost::serialization::extended_type_info const &)const " (?is_less_than@extended_type_info_typeid_0@typeid_system@serialization@boost@@UEBA_NAEBVextended_type_info@34@@Z) 1>main.obj : error LNK2001: unresolved external symbol "public: virtual bool __cdecl boost::serialization::typeid_system::extended_type_info_typeid_0::is_equal(class boost::serialization::extended_type_info const &)const " (?is_equal@extended_type_info_typeid_0@typeid_system@serialization@boost@@UEBA_NAEBVextended_type_info@34@@Z) 1>main.obj : error LNK2019: unresolved external symbol "protected: __cdecl boost::serialization::typeid_system::extended_type_info_typeid_0::~extended_type_info_typeid_0(void)" (??1extended_type_info_typeid_0@typeid_system@serialization@boost@@IEAA@XZ) referenced in function "int `public: __cdecl boost::serialization::extended_type_info_typeid<struct A_STRUCT>::extended_type_info_typeid<struct A_STRUCT>(void)'::`1'::dtor$0" (?dtor$0@?0???0?$extended_type_info_typeid@UA_STRUCT@@@serialization@boost@@QEAA@XZ@4HA) 1>main.obj : error LNK2019: unresolved external symbol "protected: void __cdecl boost::serialization::extended_type_info::key_register(void)const " (?key_register@extended_type_info@serialization@boost@@IEBAXXZ) referenced in function "public: __cdecl boost::serialization::extended_type_info_typeid<struct A_STRUCT>::extended_type_info_typeid<struct A_STRUCT>(void)" (??0?$extended_type_info_typeid@UA_STRUCT@@@serialization@boost@@QEAA@XZ) 1>main.obj : error LNK2019: unresolved external symbol "protected: void __cdecl boost::serialization::typeid_system::extended_type_info_typeid_0::type_register(class type_info const &)" (?type_register@extended_type_info_typeid_0@typeid_system@serialization@boost@@IEAAXAEBVtype_info@@@Z) referenced in function "public: __cdecl boost::serialization::extended_type_info_typeid<struct A_STRUCT>::extended_type_info_typeid<struct A_STRUCT>(void)" (??0?$extended_type_info_typeid@UA_STRUCT@@@serialization@boost@@QEAA@XZ) 1>main.obj : error LNK2019: unresolved external symbol "protected: __cdecl boost::serialization::typeid_system::extended_type_info_typeid_0::extended_type_info_typeid_0(char const *)" (??0extended_type_info_typeid_0@typeid_system@serialization@boost@@IEAA@PEBD@Z) referenced in function "public: __cdecl boost::serialization::extended_type_info_typeid<struct A_STRUCT>::extended_type_info_typeid<struct A_STRUCT>(void)" (??0?$extended_type_info_typeid@UA_STRUCT@@@serialization@boost@@QEAA@XZ) 1>main.obj : error LNK2019: unresolved external symbol "protected: void __cdecl boost::archive::basic_xml_oarchive<class boost::archive::xml_oarchive>::save_end(char const *)" (?save_end@?$basic_xml_oarchive@Vxml_oarchive@archive@boost@@@archive@boost@@IEAAXPEBD@Z) referenced in function "protected: void __cdecl boost::archive::basic_xml_oarchive<class boost::archive::xml_oarchive>::save_override<double const >(struct boost::serialization::nvp<double const > const &,int)" (??$save_override@$$CBN@?$basic_xml_oarchive@Vxml_oarchive@archive@boost@@@archive@boost@@IEAAXAEBU?$nvp@$$CBN@serialization@2@H@Z) 1>main.obj : error LNK2019: unresolved external symbol "protected: void __cdecl boost::archive::basic_xml_oarchive<class boost::archive::xml_oarchive>::save_start(char const *)" (?save_start@?$basic_xml_oarchive@Vxml_oarchive@archive@boost@@@archive@boost@@IEAAXPEBD@Z) referenced in function "protected: void __cdecl boost::archive::basic_xml_oarchive<class boost::archive::xml_oarchive>::save_override<double const >(struct boost::serialization::nvp<double const > const &,int)" (??$save_override@$$CBN@?$basic_xml_oarchive@Vxml_oarchive@archive@boost@@@archive@boost@@IEAAXAEBU?$nvp@$$CBN@serialization@2@H@Z) 1>main.obj : error LNK2019: unresolved external symbol "protected: void __cdecl boost::archive::basic_xml_oarchive<class boost::archive::xml_oarchive>::end_preamble(void)" (?end_preamble@?$basic_xml_oarchive@Vxml_oarchive@archive@boost@@@archive@boost@@IEAAXXZ) referenced in function "public: static void __cdecl boost::archive::save_access::save_primitive<class boost::archive::xml_oarchive,double>(class boost::archive::xml_oarchive &,double const &)" (??$save_primitive@Vxml_oarchive@archive@boost@@N@save_access@archive@boost@@SAXAEAVxml_oarchive@12@AEBN@Z) 1>main.obj : error LNK2019: unresolved external symbol "public: __cdecl boost::archive::archive_exception::archive_exception(enum boost::archive::archive_exception::_exception_code,char const *,char const *)" (??0archive_exception@archive@boost@@QEAA@W4_exception_code@012@PEBD1@Z) referenced in function "public: void __cdecl boost::archive::basic_text_oprimitive<class std::basic_ostream<char,struct std::char_traits<char> > >::save(double)" (?save@?$basic_text_oprimitive@V?$basic_ostream@DU?$char_traits@D@std@@@std@@@archive@boost@@QEAAXN@Z) 1>main.obj : error LNK2019: unresolved external symbol "public: virtual __cdecl boost::archive::archive_exception::~archive_exception(void)" (??1archive_exception@archive@boost@@UEAA@XZ) referenced in function "public: void __cdecl boost::archive::archive_exception::`vbase destructor'(void)" (??_Darchive_exception@archive@boost@@QEAAXXZ) 1>main.obj : error LNK2019: unresolved external symbol "public: virtual char const * __cdecl boost::archive::archive_exception::what(void)const " (?what@archive_exception@archive@boost@@UEBAPEBDXZ) referenced in function "[thunk]:public: virtual char const * __cdecl boost::archive::archive_exception::what`vtordisp{4294967292,0}' (void)const " (?what@archive_exception@archive@boost@@$4PPPPPPPM@A@EBAPEBDXZ) 1>main.obj : error LNK2019: unresolved external symbol "protected: void __cdecl boost::serialization::typeid_system::extended_type_info_typeid_0::type_unregister(void)" (?type_unregister@extended_type_info_typeid_0@typeid_system@serialization@boost@@IEAAXXZ) referenced in function "public: __cdecl boost::serialization::extended_type_info_typeid<struct A_STRUCT>::~extended_type_info_typeid<struct A_STRUCT>(void)" (??1?$extended_type_info_typeid@UA_STRUCT@@@serialization@boost@@QEAA@XZ) 1>main.obj : error LNK2019: unresolved external symbol "protected: void __cdecl boost::serialization::extended_type_info::key_unregister(void)const " (?key_unregister@extended_type_info@serialization@boost@@IEBAXXZ) referenced in function "public: __cdecl boost::serialization::extended_type_info_typeid<struct A_STRUCT>::~extended_type_info_typeid<struct A_STRUCT>(void)" (??1?$extended_type_info_typeid@UA_STRUCT@@@serialization@boost@@QEAA@XZ) 1>D:\Simulation\test\test\x64\Debug\test.exe : fatal error LNK1120: 16 unresolved externals 1>Build log was saved at "file://d:\Simulation\test\test\test\x64\Debug\BuildLog.htm" 1>test - 17 error(s), 0 warning(s) ========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ========== --------------------------------------------

2 1

boost::thread 1.40 doesn't build on Sun
by Conoscenza Silente 13 Apr '10

13 Apr '10

Hi All I found in Sun Solaris machine I have the version 1.40 of boost and not the last one as I thought. and each time I try to use a thread with a shared pointer I receive this message. "/opt/boost/boost/thread/detail/thread.hpp", line 344: Error: boost::thread::thread(boost::thread&) is not accessible from boost::move(boost::detail::thread_move_t<boost::thread>). 1 Error(s) detected. I am trying to use thread using code like this below boost::shared_ptr< boost::thread > m_ThreadListener( new boost::thread( funct) ); Do you know a solution for this issue? Reading posts it seems that I should rebuild the library.. ..is this correct or there is some workaround? Thanks AFG

1 0

[string algorithms] trim, functors
by Gaydov Victor 13 Apr '10

13 Apr '10

Hello. Could you answer these two questions: 1. Are there trim range algorithms that work with iterators, instead of strings? (I didn't find such). If not, why not to add them? Something like this: http://pastebin.org/146696 2. How can I use, for example, boost::algorithm::is_space() with standard functors? This: boost::not1(boost::algorithm::is_space()) doesn't work. It's enough to specialize boost::unary_traits<boost::algorithm::detail::is_classifiedF>, but the fact that 'is_classifiedF' is in 'detail' namespace is a bit confusing. Is it ok to use it? Thanks.

3 5

Boost.Thread and debugging a memory error
by Braden McDaniel 13 Apr '10

13 Apr '10

I'm trying to debug a memory error and this is among the suspicious bits that valgrind is turning up: ==23982== Invalid read of size 1 ==23982== at 0x583DAFA: boost::detail::interruption_checker::interruption_checker(pthread_cond_t*) (thread_data.hpp:94) ==23982== by 0x583DC35: boost::condition_variable::wait(boost::unique_lock<boost::mutex>&) (condition_variable.hpp:19) ==23982== by 0x583DECE: boost::shared_mutex::lock_shared() (shared_mutex.hpp:64) ==23982== by 0x5849E63: boost::shared_lock<boost::shared_mutex>::lock() (locks.hpp:575) ==23982== by 0x583E988: boost::shared_lock<boost::shared_mutex>::shared_lock(boost::shared_mutex&) (locks.hpp:458) I am pretty confident that the shared_mutex is fully constructed when this happens. Also, this is coming from the main thread. I'm just not sure what's going on here. As I continue to explore this, I thought I'd try my luck here: perhaps someone's seen something like this before? -- Braden McDaniel <braden(a)endoframe.com>

1 0

Possible bug: regex, lexical_cast
by John.X.Foster＠nab.com.au 13 Apr '10

13 Apr '10

Hi all I have come across a bug associated with lexical_cast and regex (though the culprit may well be the Visual C++ compiler). I have stripped the code to the bare essentials. This worked OK under VC++ 8 (2005), but gives an access violation under VC++ 9 (2008). This occurs with both boost 1.39 and 1.42. Simplified code follows: #define _SECURE_SCL 0 #define _HAS_ITERATOR_DEBUGGING 0 #include <boost/lexical_cast.hpp> #include <boost/regex.hpp> #include <string> #include <iostream> void violate() { int i = 0; std::string x = "x" + boost::lexical_cast<std::string>(i); boost::regex regex("aaa"); boost::regex_replace(x, regex, "bbb", boost::match_default); } int main() { violate(); std::cout << "Enter to exit\n"; std::cin.get(); } In debug mode, the following exception message is generated: Unhandled exception at 0x10487b3f (msvcp90d.dll) in RegexBug.exe: 0xC0000005: Access violation writing location 0xcccccccc. Stack at time of exception is: msvcp90d.dll!std::_Container_base_secure::_Orphan_all() Line 223 + 0x5 bytes C++ msvcp90d.dll!std::_Container_base_secure::~_Container_base_secure() Line 115 C++ msvcp90d.dll!std::_String_base::~_String_base() + 0x11 bytes C++ msvcp90d.dll!std::_String_val<unsigned short,std::allocator<unsigned short> >::~_String_val<unsigned short,std::allocator<unsigned short> >() + 0x11 bytes C++ msvcp90d.dll!std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >() Line 917 + 0xf bytes C++ RegexBug.exe!violate() Line 16 + 0x1e bytes C++ RegexBug.exe!main() Line 21 C++ RegexBug.exe!__tmainCRTStartup() Line 586 + 0x19 bytes C RegexBug.exe!mainCRTStartup() Line 403 C kernel32.dll!7c817067() [Frames below may be incorrect and/or missing, no symbols loaded for kernel32.dll] While I have found several work-arounds, it would be useful to log this, if it is a bug, in the correct place - boost? MS? Appologies for the extended junk at the end of this email! John John Foster Senior Quantitative Credit Developer Model Development, Group Credit Portfolio & Models National Australia Bank Level 15, 500 Bourke St, Melbourne VIC 3000 Tel: +61 (0)3 8641 5228 Email: John.X.Foster(a)nab.com.au This e-mail is sent by or on behalf of the named sender identified above. If: (a) you do not wish to receive any e-mail marketing material from this person in the future, please forward the contents of this email to unsubscribe(a)nab.com.au with the word "unsubscribe" in the subject box. (b) you wish to unsubscribe from all central e-mail marketing lists used by our business, please forward the contents of this e-mail to unsubscribeall(a)nab.com.au with the message "unsubscribe from all central e-mail marketing lists" in the subject box. If you do not forward the contents of this e-mail with your unsubscription then it may not be able to be implemented. The information contained in this e-mail communication may be confidential. You should only read, disclose, re-transmit, copy, distribute, act in reliance on or commercialise the information if you are authorised to do so. If you are not the intended recipient of this e-mail communication, please immediately notify us by e-mail to postmaster(a)nab.com.au, or reply by e-mail direct to the sender and then destroy any electronic and paper copy of this message. Any views expressed in this e-mail communication are those of the individual sender, except where the sender specifically states them to be the views of a member of the National Australia Bank Group of companies. Any advice contained in this e-mail has been prepared without taking into account your objectives, financial situation or needs. Before acting on any advice in this e-mail, National Australia Bank Limited recommends that you consider whether it is appropriate for your circumstances. If this e-mail contains reference to any financial products, the National recommends you consider the Product Disclosure Statement (PDS) or other disclosure document before making any decisions regarding any products. The National Australia Bank Group of companies does not represent, warrant or guarantee that the integrity of this communication has been maintained nor that the communication is free of errors, virus or interference.

3 5

[serialization] Will a void_caster fix be available for 1.43?
by Bogdan 13 Apr '10

13 Apr '10

I try again: is there any chance for a fix to this problem to make it into 1.43.0? I get an access violation after explicitly unloading a DLL that contains serialization code for a series of classes. I believe there might be a bug in void_caster::recursive_unregister(): that function member is called in the destructors of the void caster template classes. It searches the set inside void_caster_registry singleton for all the entries that are descendants of the current one (i.e., the void_caster being destroyed) and performs the following operations: - delete the shortcuts. - remove the corresponding entries from the set. However, void_caster::recursive_unregister() doesn't remove from the registrar the entry corresponding to the current void_caster(). This creates the problem below: Consider a scenario where a dll containing some serialization functionality is loaded explicitly at runtime (i.e., using LoadLibrary() on Windows or dlopen on Unix). There are no parent-child relationships among the serialized classes registered by that DLL: all serialized classes are derived from one abstract base. While unloading the library, its void_caster singletons are destroyed but there are no shortcuts to remove from the global registrar since there are no parent-child relationships. All entries corresponding to those are still in the global registrar and point to the void_caster singletons ALREADY DESTROYED AND DISCARDED. When the main process exits, the registrar repeats the traversal for whatever executable-bound void_caster singletons are about to be destroyed. During these subsequent traversals, void_caster::recursive_unregister() visits the entries left after the previous explicit dll download and tries to identify the parent-child relationship. In doing so, it accesses the dangling vc pointers generating access violations: void_cast.cpp(Line 286): const void_caster * vc = *it; void_cast.cpp(Line 287): if(vc->m_parent == this){ //<--------------------- here is the access violation I can reproduce the crash systematically, but I am not 100% sure about the reason or whether a simple unregistration is enough. Thank you, Bogdan

1 0

Re: [Boost-users] [serialization] Potential problems with void_caster
by Bogdan 12 Apr '10

12 Apr '10

I try again: is there any chance for a fix to this problem to make it into 1.43.0? I get an access violation after explicitly unloading a DLL that contains serialization code for a series of classes. I believe there might be a bug in void_caster::recursive_unregister(): that function member is called in the destructors of the void caster template classes. It searches the set inside void_caster_registry singleton for all the entries that are descendants of the current one (i.e., the void_caster being destroyed) and performs the following operations: - delete the shortcuts. - remove the corresponding entries from the set. However, void_caster::recursive_unregister() doesn't remove from the registrar the entry corresponding to the current void_caster(). This creates the problem below: Consider a scenario where a dll containing some serialization functionality is loaded explicitly at runtime (i.e., using LoadLibrary() on Windows or dlopen on Unix). There are no parent-child relationships among the serialized classes registered by that DLL: all serialized classes are derived from one abstract base. While unloading the library, its void_caster singletons are destroyed but there are no shortcuts to remove from the global registrar since there are no parent-child relationships. All entries corresponding to those are still in the global registrar and point to the void_caster singletons ALREADY DESTROYED AND DISCARDED. When the main process exits, the registrar repeats the traversal for whatever executable-bound void_caster singletons are about to be destroyed. During these subsequent traversals, void_caster::recursive_unregister() visits the entries left after the previous explicit dll download and tries to identify the parent-child relationship. In doing so, it accesses the dangling vc pointers generating access violations: void_cast.cpp(Line 286): const void_caster * vc = *it; void_cast.cpp(Line 287): if(vc->m_parent == this){ //<--------------------- here is the access violation I can reproduce the crash systematically, but I am not 100% sure about the reason or whether a simple unregistration is enough. Thank you, Bogdan

1 0

Re: [Boost-users] math round() functions: away from 0
by Hicham Mouline 12 Apr '10

12 Apr '10

Apologies for the non-text formatting. Here is the same message in pure text: Hello, boost/trunk/libs/math/doc/sf_and_dist/html/math_toolkit/utils/rounding/round.html says that: Halfway cases are rounded away from zero, regardless of the current rounding direction. This I believe is compatible with C99 TC3 and therefore the latest C++1x draft. However, when I ran this program: #include <cmath> #include <iostream> #include <boost/math/special_functions/round.hpp> inline double round1(double x) { if (x >= 0.0) return std::floor(x + 0.5); else return std::ceil(x - 0.5); } inline double round2(double x) { return std::floor(x + 0.5); } int main() { std::cout.setf(std::ios_base::fixed, std::ios_base::floatfield); std::cout.precision(1); std::cout<< "d floor/ceil.5 floor.5 boostmathround"<<std::endl; for (double d=-10.5; d<11; d+=0.5) std::cout<< d<<" "<< round1(d)<<" "<<round2(d)<<" "<< boost::math::iround<double>(d)<<std::endl; return 0; } under g++4.3.x and msvc2008 with trunk, the output for all the negative halves does not seem to be away from 0. The same for boost::math::round<double>(d) This stuff most likely depends on the bit pattern, so I investigated further. I raised the precision of std::cout to 18 decimals. I then rounded this: const double dd = -10.5; which yielded dd floor/ceil.5 floor.5 boostmathround -10.500000000000000000 -11.000000000000000000 -10.000000000000000000 -10 and for (double d=-10.6; d<-10.4; d+=0.01) std::cout<< d<<" "<< round1(d)<<" "<<round2(d)<<" "<< boost::math::iround(d)<<std::endl; -10.600000000000000000 -11.000000000000000000 -11.000000000000000000 -11 -10.590000000000000000 -11.000000000000000000 -11.000000000000000000 -11 -10.580000000000000000 -11.000000000000000000 -11.000000000000000000 -11 -10.570000000000000000 -11.000000000000000000 -11.000000000000000000 -11 -10.560000000000000000 -11.000000000000000000 -11.000000000000000000 -11 -10.550000000000001000 -11.000000000000000000 -11.000000000000000000 -11 -10.540000000000001000 -11.000000000000000000 -11.000000000000000000 -11 -10.530000000000001000 -11.000000000000000000 -11.000000000000000000 -11 -10.520000000000001000 -11.000000000000000000 -11.000000000000000000 -11 -10.510000000000002000 -11.000000000000000000 -11.000000000000000000 -11 -10.500000000000002000 -11.000000000000000000 -11.000000000000000000 -11 -10.490000000000002000 -10.000000000000000000 -10.000000000000000000 -10 -10.480000000000002000 -10.000000000000000000 -10.000000000000000000 -10 -10.470000000000002000 -10.000000000000000000 -10.000000000000000000 -10 -10.460000000000003000 -10.000000000000000000 -10.000000000000000000 -10 -10.450000000000003000 -10.000000000000000000 -10.000000000000000000 -10 -10.440000000000003000 -10.000000000000000000 -10.000000000000000000 -10 -10.430000000000003000 -10.000000000000000000 -10.000000000000000000 -10 -10.420000000000003000 -10.000000000000000000 -10.000000000000000000 -10 -10.410000000000004000 -10.000000000000000000 -10.000000000000000000 -10 -10.400000000000004000 -10.000000000000000000 -10.000000000000000000 -10 -10.5 has the exact representation in IEEE754 as the 64bit: 0000000000000000000000000000000000000000000000001010010000000011 with the bits listed from least significant to most, across all bytes. It is an _exact_ representation as far as I can tell. therefore there are no hidden issues, and the boost math round() function should round _away_ from 0, to give -11, shouldn't it? the above round1() function seems to do the right thing.... Regards,

1 0

Choosing a variable size
by John Dlugosz 12 Apr '10

12 Apr '10

Given a template function that has two incoming integral types to work with, I want to declare some variables for intermediate use. How do I easily make a typedef for the larger of the two? It doesn't need to be perfect. I'm just trying to avoid using a 64-bit integer when it isn't needed, since 32-bit targets will be penalized for that. TradeStation Group, Inc. is a publicly-traded holding company (NASDAQ GS: TRAD) of three operating subsidiaries, TradeStation Securities, Inc. (Member NYSE, FINRA, SIPC and NFA), TradeStation Technologies, Inc., a trading software and subscription company, and TradeStation Europe Limited, a United Kingdom, FSA-authorized introducing brokerage firm. None of these companies provides trading or investment advice, recommendations or endorsements of any kind. The information transmitted is intended only for the person or entity to which it is addressed and may contain confidential and/or privileged material. Any review, retransmission, dissemination or other use of, or taking of any action in reliance upon, this information by persons or entities other than the intended recipient is prohibited. If you received this in error, please contact the sender and delete the material from any computer.

3 2

[interprocess] managed_shm->find call causes assertion
by Moritz 12 Apr '10

12 Apr '10

Hi, I have a managed_shared_memory segment which contains a unique_instance of an object. When I try to call managed_shm->find<ObjectType>( ipc::unique_instance ); I get the following assertion: /usr/include/boost/interprocess/sync/posix/interprocess_recursive_mutex.hpp:110: void boost::interprocess::interprocess_recursive_mutex::unlock(): Assertion `res == 0' failed. Aborted This only happens in Release-Mode (with gcc -s -O2). I am not able to build a minimum example but I also can not track the problem. Any suggests? Kind regards

2 7

[Boost.mpi] Installation with Intel compilers
by Federico Golfrè Andreasi 12 Apr '10

12 Apr '10

Hi, I'm trying to build the boost.mpi 1.42.0 library with Intel compilers. I build the other libraries, so I believe it's just a matter of rightly configure everything. I've the bootstrap ./bootstrap.sh --with-toolset=intel-linux --with-libraries=mpi --prefix=/usr/local/boost-1.42.0-intelmpi I've added to the file project-config.jam the following row: using mpi : mpiicpc ; and then I run the bjam: ./bjam --with-mpi toolset=intel link=static --debug-configuration install but I receive this failure message ...patience... ...found 16685 targets... ...updating 21 targets... intel-linux.compile.c++ bin.v2/libs/mpi/build/intel-linux/release/link-static/threading-multi/broadcast.o icpc: command line warning #10006: ignoring unknown option '-fenable-new-dtags' icpc: command line error: multiple sources not allowed with -o option "icpc" -c -xc++ -O3 -w1 -inline-level=2 -pthread $libdir --enable-new-dtags -Xlinker -rpath /opt/intel/mpi-rt/3.2.2 -DBOOST_ALL_NO_LIB=1 -DBOOST_MPI_SOURCE=1 -DNDEBUG -I"." -I"/opt/intel/impi/ 3.2.2.006/include" -c -o "bin.v2/libs/mpi/build/intel-linux/release/link-static/threading-multi/broadcast.o" "libs/mpi/src/broadcast.cpp" ...failed intel-linux.compile.c++ bin.v2/libs/mpi/build/intel-linux/release/link-static/threading-multi/broadcast.o... [...] what's wrong with my configuration steps ? thank you. Federico

2 1

[Spirit?] core dump in endl?
by philip tucker 12 Apr '10

12 Apr '10

Hello, I enclose a Spirit parser with two BOOST_FOREACH loops, one of which works and the other coredumps. I also enclose a gdb backtrace. Can you explain what's going on here? TIA

4 3

compiler error with Phoenix and zip_iterator
by Surya Kiran Gullapalli 12 Apr '10

12 Apr '10

The following piece of code works fine with MSVC 9.0 but fails with Gcc-4.4.2. Compiler throws lot of error messages due to the for_each call. I'm unable to figure out the exact problem ================== #include <vector> #include <string> #include <iostream> #include <sstream> using namespace std ; #include <boost/spirit/include/phoenix.hpp> namespace phx = boost::phoenix ; namespace pha = phx::arg_names ; #include <boost/iterator/zip_iterator.hpp> #include <boost/assign.hpp> using namespace boost::assign ; void updateOut (const boost::tuple<const string&, const int&>& p_tuple, vector<string>& p_out) { ostringstream os ; os << p_tuple.get<0>() << '-' << p_tuple.get<1>(); p_out += os.str() ; } int main (void) { vector<string> vs, out ; vector<int> vi, vi2 ; vs += "String", "String", "String", "String", "String"; vi += 1,2,3,4,5 ; vector<string>::const_iterator sbegIter = vs.begin(); vector<string>::const_iterator sendIter = vs.end(); vector<int>::const_iterator ibegIter = vi.begin(); vector<int>::const_iterator iendIter = vi.end(); std::for_each ( boost::make_zip_iterator(boost::make_tuple(sbegIter, ibegIter)), boost::make_zip_iterator(boost::make_tuple(sendIter, iendIter)), phx::bind (&updateOut, pha::arg1, phx::ref(out)) ) ; } ============ I'm using Boost-1.42.0 What is wrong with for_each call ? Thanks in advance, Surya

2 1

[serialization] vector with custom allocator
by Kenny Riddile 12 Apr '10

12 Apr '10

What would be the easiest way to serialize a std::vector that uses a custom allocator type?

1 1

warning in boost concept
by oberhoff 12 Apr '10

12 Apr '10

Hi, this is using boost 1.42, I think the same happens in 1.43 Using boost::accumulators generates a compiler warning in boost/concept_check.hpp:335. it seems the Arg member is a reference, but gcc doesnt like that there is no way to initialize it since it is private and the class does not have a constructor. this is particularly annoying since due to metaprogramming and the lag of variadic templates the instantiation trace in the error message for a single error is a few pages long, and it comes each time I instantiate an accumulator. is there a way to avoid this? Best Daniel

4 5

Re: [Boost-users] Possible bug: regex, lexical_cast
by John.X.Foster＠nab.com.au 12 Apr '10

12 Apr '10

Hi all Having done some further research, I suspect this is NOT a boost bug, but is a bug in the microsoft implementation of ostringstream (which I suspect is used for the string concatenation). Replacing ostringstream with boost::format has resulted in several bugs with the same general charateristics disappearing! John John Foster Senior Quantitative Credit Developer Model Development, Group Credit Portfolio & Models National Australia Bank Level 15, 500 Bourke St, Melbourne VIC 3000 Tel: +61 (0)3 8641 5228 Email: John.X.Foster(a)nab.com.au This e-mail is sent by or on behalf of the named sender identified above. If: (a) you do not wish to receive any e-mail marketing material from this person in the future, please forward the contents of this email to unsubscribe(a)nab.com.au with the word "unsubscribe" in the subject box. (b) you wish to unsubscribe from all central e-mail marketing lists used by our business, please forward the contents of this e-mail to unsubscribeall(a)nab.com.au with the message "unsubscribe from all central e-mail marketing lists" in the subject box. If you do not forward the contents of this e-mail with your unsubscription then it may not be able to be implemented. The information contained in this e-mail communication may be confidential. You should only read, disclose, re-transmit, copy, distribute, act in reliance on or commercialise the information if you are authorised to do so. If you are not the intended recipient of this e-mail communication, please immediately notify us by e-mail to postmaster(a)nab.com.au, or reply by e-mail direct to the sender and then destroy any electronic and paper copy of this message. Any views expressed in this e-mail communication are those of the individual sender, except where the sender specifically states them to be the views of a member of the National Australia Bank Group of companies. Any advice contained in this e-mail has been prepared without taking into account your objectives, financial situation or needs. Before acting on any advice in this e-mail, National Australia Bank Limited recommends that you consider whether it is appropriate for your circumstances. If this e-mail contains reference to any financial products, the National recommends you consider the Product Disclosure Statement (PDS) or other disclosure document before making any decisions regarding any products. The National Australia Bank Group of companies does not represent, warrant or guarantee that the integrity of this communication has been maintained nor that the communication is free of errors, virus or interference.

1 0

[math/distributions] calculating p-value?
by Christian Meesters 11 Apr '10

11 Apr '10

Hi, Having a test which values are chi^2-distributed, I tried to calculate a p-value and utterly failed. My code, so far: #include <boost/math/distributions/chi_squared.hpp> using boost::math::chi_squared; <snip> chi_squared dist(N - 1); p = cdf(complement(dist, (std::fabs(beta)))) ; Here, N is the sample size and beta my beta-estimate. Reading Numerical Recipies my approach might be a bit naive, yet is there any short hand using boost? (Or am I making a stupid mistake here? Which?) TIA Christian

3 5

[asio] What happens when socket receive buffer overflows?
by Matheus Araújo Aguiar 11 Apr '10

11 Apr '10

Hello List, I have a network application written with asio that uses TCP. The message exchange between client and server is done using a protocol that puts a prefix on each message indicating the number its bytes number. This way, at one side a prefix is read, and the number of bytes indicated in the prefix is read as a message, then it reads another prefix and so on. While testing the application I was having some errors related to reading a prefix that would indicate a strange number of bytes incoming, a number that was far greater than the max size possible of message in my protocol. After assuring that the bytes on the stream were not being merged, i started suspecting about socket buffer size. So i reduced the socket buffer size to 1K, and the application crashed with a lot less network load than before. At the moment, i am almost sure that the problem is the socket receive buffer which overflows and the bytes are discarded, creating a "gap" in the byte stream which causes an inconsistent state on the application. Does that make sense? What should happen when the socket receive buffer overflows? It silently discards the bytes or what? Thanx for your attention, -- Matheus Araújo Aguiar Computer Scientist matheus.pit(a)gmail.com

3 4

compiling boost::asio w/ SSL
by David Kaplan 11 Apr '10

11 Apr '10

It seems that i have compiled boost::asio without SSL or something but whatever I do I cannot seem to get my previously perfectly compiling app to compile again. I get a bunch of errors such as: ‘SSL’ has not been declared app line 121, external location: /usr/local/include/boost/asio/ssl/detail/openssl_operation.hpp ‘struct boost::asio::ssl::detail::openssl_stream_service::impl_struct’ has no member named ‘ext_bio’ app line 195, external location: /usr/local/include/boost/asio/ssl/detail/openssl_stream_service.hpp ‘ssl_bio_’ was not declared in this scope app line 168, external location: /usr/local/include/boost/asio/ssl/detail/openssl_operation.hpp ‘::SSL’ has not been declared app line 37, external location: /usr/local/include/boost/asio/ssl/detail/openssl_operation.hpp etc. etc. etc. Any ideas?

1 1

How to serialize basic_string<unsigned char>
by Martin Dietze 10 Apr '10

10 Apr '10

I want to serialize an existing (low level) class which uses a `std::basic_string<unsigned char>' as member variable. Compiling the code (boost/serialization/string.hpp is included) fails with this message: /usr/include/boost/serialization/access.hpp:109: error: ‘class std::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char> >’ has no member named ‘serialize’ As I understand, std::string is now treated as a simple data type, but std:basic_string<unsigned char> is not. Is there already existing support for such instanciations of std::basic_string? Any hint on what I can do to get this working? Cheers, M'bert -- ----------- / http://herbert.the-little-red-haired-girl.org / ------------- =+= Warum geht ein Bratscher nicht �ber einen Friedhof? Zu viele Kreuze...

2 6

Distinct elements in a std::vector<T>
by Hicham Mouline 10 Apr '10

10 Apr '10

Hello, Given a std::vector<T> and a Compare<T> comparator, how can I: 1. determine the number of different elements in the vector? 2. get iterators to the list of distinct elements in the vector? My naive implementation for 1 is: /// v is const-ref to a std::vector<T> std::vector<T>::size_type distinct = v.empty()? 0: 1; std::vector<T>::const_iterator j; for (std::vector<T>::const_iterator i = v.begin()+1; i!=v.end(); ++i) { j = std::find(v.begin(), i, *i, Compare<T>()); if (j!=i) ++distinct; } Obviously, this is of worst order n*(n+1)/2. I'm sure a better order can be achieved. I don't quite see how to do 2. Does anything in the C++ std lib or boost facilitate this? Regards,

2 1

Re: [Boost-users] [boost][serialization] Binary portable archive (eos implementation in Vault)
by Marc Perso 10 Apr '10

10 Apr '10

> De : Pfligersdorffer, Christian [mailto:Christian.Pfligersdorffer@eos.info] > Hi Marc, Hi Christian, Thank you for considering my post. > since I do not always monitor the boost users list it is good you > contacted me in this issue. Your problem is almost certainly VC7.1 since > that is unfortunately not tested and not supported by me. We use VC8 > here and is to be considered outdated ;-) > I succeeded in building and running your example using me setup: > - VC8 > - boost 1.41 > - XP 32-bit > I am not sure where VC7.1 fails but it might be some template stuff that > was not fully supported then... Is upgrading your compiler an option for > you (and your team)? We are going to upgrade from VC7.1 to VC9 in few weeks or few months but for the moment nothing was confirmed administratively speaking so I'm not very confident right now about this upgrade. And this upgrade will be consequent in term of workload for us and we can assume that it will take few days to be completed. I will prefer to integrate your "portable archive" before this migration but I'm not able to identify the workload for tweaking your source code for VC7.1. I'm sure that a lot of Boost experts can be very helpful for finding this tweaking: maybe Robert Ramey? Any helps from Boost experts to have this nice tool running under VC7.1 will be greatly appreciated! Best regards, Marc Viala

1 0

[Date_Time] Visual Studio 8 debugger visualizer
by Bruno Durin 10 Apr '10

10 Apr '10

Hi, This is my second post in a mailing list and my first on boost-users so I apologize for the naive style and for my English (I am not a native English speaker). I would like to give a solution to a problem that kept annoying me for a long time when debugging code using Boost.Date_Time in Visual Studio 8. The library is based on an int representation of datetime and this int is displayed by the debugger, which gets hard to understand if it's the correct datetime or not. The solution, as already explained in http://www.virtualdub.org/blog/pivot/entry.php?id=120, is to customize Visual Studio debugger. I have found a solution in boost documentation section, provided by filip dot konvicka at logis dot cz, but you have to click refresh to get the info displayed. I thus suggest a partial brute force solution for boost::gregorian::date, boost::posix_time::time_duration and boost::posix_time::ptime (the only objects I use, but extension to local time zone should be easy). This solution simply recodes the conversion functions available in Boost.Date_Time, adding some formatting. I included it as an attachement because of the length of some lines is very long. As an example boost::posix_time::ptime a_time(boost::gregorian::date(2010, Apr, 7), boost::posix_time::hours(22)) would display instantaneously in the preview area in the debugger as a_time 2010-4-7 22h0m0s (0us) Note: us is microseconds. If you work with nanosecond resolution, you have to change the visualizer definition. In order to get it work, backup the file autoexp.dat (it's in the installation directory of Visual Studio), and add the content of the attachement in the [Visualizer] section. It should work without even restarting Visual Studio. I have only tested under Visual Studio 8 2005, but it should work as well with Visual Studio 9 2008. Hope that will help! Bruno Durin.

4 3

[program_options] Clearing variables_map
by Jason Reich 10 Apr '10

10 Apr '10

Hello, I'm using boost::program_options to parse an command line within a running program (i.e. not just at startup, whenever a new command comes in), and am trying to avoid memory deallocation/reallocation. Is there any way reuse a variable_map that has already had options stored into it? If I use the std::map<>.clear() it seems to clear the stored values, but when I next try to parse, the results are still empty. I think this is happening because the m_final variable (as far as I can understand). Is there some reason why the variables_map can't be cleared and reused? thanks in advance for any insight you can provide, Jason.

2 3

[boost-users][program_options] How can I restrict possible values?
by Germán Diago 10 Apr '10

10 Apr '10

Hello. I'm using boost.program_options and I want to know if I can restrict the possible values for an option. I couldn't find an obvious way in the documentation. Thanks.

2 1

Boost.Test - Advice needed on structuring tests
by pholding 10 Apr '10

10 Apr '10

I'm looking for some advice/recommendations on how I should structure a suite of unit tests for a project I've been working on. The code uses exceptions rather than return codes. Essentially the code is a wrapper around a C database library. In the future the code will grow into a full application, but I'm taking small steps at the moment. As I'm new to unit testing I'm unsure the tests should be structured and am keen to follow good practice. I'm thinking of structuring the unit tests as follows Unit test 1 - connect to database Unit test 2 - create table Unit test 3 - insert record into table Unit test 4 - select record from table Unit test 5 - (perform some other SQL statements) Unit test 6 - disconnect from database Some of these tests could be considered as setup and teardown code, but I want the unit tests to cover all code in my wrapper. What I'm unsure about is whether it's considered good practice for one unit test to depend upon a previous unit test creating something in order to allow the test to be performed. The other issue I've got is whilst the function may not have thrown an exception it doesn't necessary mean the function did what its supposed to do. For example unit test 2 might not throw an error, but the only way I'll know if the function worked correctly is to query the database metadata or do unit test 3. Should unit test 2 only check that an error was not thrown or should it also call another function to query the metadata and then check the result of that function before marking unit test 2 as a success? -- View this message in context: http://old.nabble.com/Boost.Test---Advice-needed-on-structuring-tests-tp281… Sent from the Boost - Users mailing list archive at Nabble.com.

2 1

boost 1.38 to 1.42 upgrade problem
by DE COCK Gregory 09 Apr '10

09 Apr '10

Hello, I'm using successfully boost library (interprocess part mainly) since a long time (ver 1.38) But when I try to upgrade to newer version (any version higher than 1.38), compilation is failing (using VC++ express 2008)... here is the error msg from compiler : d:\svn\fbistudio\dep\boost_latest\boost/preprocessor/iteration/detail/lo cal.hpp(37) : error C2664: 'helpdesk::objects::shm::shared_data::shared_data(helpdesk::objects::shm ::sharedmemory_type &) throw()' : cannot convert parameter 1 from 'const helpdesk::objects::shm::sharedmemory_type' to 'helpdesk::objects::shm::sharedmemory_type &' 1> Conversion loses qualifiers 1> d:\svn\fbistudio\dep\boost_latest\boost/preprocessor/iteration/detail/lo cal.hpp(37) : while compiling class template member function 'void boost::interprocess::detail::Ctor1Arg<T,is_iterator,P0>::construct(void *,boost::interprocess::detail::false_)' 1> with 1> [ 1> T=helpdesk::objects::shm::shared_data, 1> is_iterator=false, 1> P0=helpdesk::objects::shm::sharedmemory_type 1> ] 1> d:\svn\fbistudio\dep\boost_latest\boost/preprocessor/iteration/detail/lo cal.hpp(37) : see reference to class template instantiation 'boost::interprocess::detail::Ctor1Arg<T,is_iterator,P0>' being compiled 1> with 1> [ 1> T=helpdesk::objects::shm::shared_data, 1> is_iterator=false, 1> P0=helpdesk::objects::shm::sharedmemory_type 1> ] 1> ..\src\objects\shareddata.cpp(181) : see reference to function template instantiation 'T *boost::interprocess::detail::named_proxy<SegmentManager,T,is_iterator>: :operator ()<helpdesk::objects::shm::sharedmemory_type>(const P0 &) const' being compiled 1> with 1> [ 1> T=helpdesk::objects::shm::shared_data, 1> SegmentManager=boost::interprocess::segment_manager<char,boost::interpro cess::rbtree_best_fit<boost::interprocess::mutex_family>,boost::interpro cess::iset_index>, 1> is_iterator=false, 1> P0=helpdesk::objects::shm::sharedmemory_type 1> ] Any idea ? Thanks Greg

2 1

asio flushing a buffer
by Lloyd 09 Apr '10

09 Apr '10

Hi, I went through the documentation of boost::asio::read_until() function. It says that if some data left in the stream after a read_until() operation, it will be available in the next "read" opration from the stream. Is there any way to "flush" (simply remove) the unwanted data from the stream so as to receive entirely new data than the old "useless" data left in the stream? Thanks, Lloyd ______________________________________ Scanned and protected by Email scanner

3 2

Re: [Boost-users] serialization unordered_map
by alev mutlu 09 Apr '10

09 Apr '10

Hi Daniel, It gives the following compile time error: /boost/include/boost-1_37/boost/serialization/unordered_map_mod.hpp:49: error: redefinition of ‘template<class Archive, class Container, class InputFunction> void boost::serialization::stl::load_hash_collection(Archive&, Container&)’ /boost/include/boost-1_37/boost/serialization/hash_collections_load_imp.hpp:33: error: ‘template<class Archive, class Container, class InputFunction> void boost::serialization::stl::load_hash_collection(Archive&, Container&)’ previously declared here how should I proceed? _alev On Sat, Apr 3, 2010 at 8:52 PM, Daniel F. Savarese <dfs(a)savarese.org> wrote: > > In message <m2pd23942591004020904y909f9116x83d9b14ad2124bdf(a)mail.gmail.com>, > al > ev mutlu writes: > >I could not find any library for unordered_map? > >Is there one? > > No. This is what my company has been using for the past four years: > http://www.savarese.com/software/wispers/api/a00254_source.html > > daniel > > >

1 0

[test] Problem with Boost.Test command-line parameters in 1.42.0
by Florian Winter 09 Apr '10

09 Apr '10

Hi, We have recently upgraded our unit test suite from Boost 1.35.0 to 1.42.0. Now we have the following problem: Some of our unit test applications take command-line parameters of their own, and there seem to be name conflicts with command-line options of Boost.Test. For example, some of our test applications accept a command line parameter "-f", which takes no arguments. However, Boost.Test also accepts a "-f" parameter, which takes 1 argument. So whenever we specify our "-f" option when running a test, we get an error message from Boost.Test similar to the following: "Invalid output format: -L" We don't like the idea of changing our own command-line interface, because some tests take a lot of command-line parameters with short names, and there are likely to be new name conflicts with future Boost versions. Is there an easy way to disable or bypass the command-line parser of Boost.Test, or at least to disable parsing of short options? -- Florian Winter Senior Software developer Motama GmbH Lortzingstraße 10 · 66111 Saarbrücken · Germany tel +49 681 940 85 50 · fax +49 681 940 85 49 mlohse(a)motama.com · www.motama.com Companies register · district council Saarbrücken · HRB 15249 Law registered office · Saarbrücken CEOs · Dr.-Ing. Marco Lohse, Michael Repplinger This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and destroy this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden.

1 0

Re: [Boost-users] [Serialization] std::set<std::string> restore performance
by Brian Wood 08 Apr '10

08 Apr '10

> Recently we're profiling our tool for restoration for a large electronic > design. And we're restoring two archive of same number of elements - one > uses vector as container while the other uses set. And it appears that > restoration of set is much much slower than the vector. Both the restoration > called from same parent which is called just once. And vector restoration > took 2% of parent while set restoration took 83% of parent. And most of set > restoration time is spent in : I wrote about that here http://webEbenezer.net/comparison.html. Ticket 2945 is related. https://svn.boost.org/trac/boost/ticket/2945 -- Brian Wood http://webEbenezer.net (651) 251-9384 "The kingdom of heaven is like a treasure hidden in the field, which a man found and hid again; and from joy over it he goes and sells all that he has and buys that field."

3 2

Compiling on HPUX RISC
by Marc Bernier 08 Apr '10

08 Apr '10

We are compiling the boost library (just the RegEx portion) on an HP-UX machine using the aCC compiler v A.03.70. Straight off, it does not compile (a #error in hp_acc.hpp reports that version A.03.80 or higher is needed). We can suppress the error, but we quickly run into a compiler error "Not enough memory is available to finish the compilation". My suspicion is that the aCC compiler restriction was imposed because of this very problem and that there is no work-around. But I'd like to confirm this, and if I'm wrong, are there any suggestions or work-arounds that anyone may have. Unfortunately, we cannot upgrade our compiler due to customer requirements. --Marc Bernier

1 0

logical operators in lambda
by Conoscenza Silente 08 Apr '10

08 Apr '10

Hi All I am trying to use boost::lambda using logicat operator. I would like to use it in a STL std::find_if call. What I receive is always the same error error: no match for ‘operator==’ in ‘boost::lambda::<unnamed>::_1 == 13’ Do you know what I am doing wrong? Thanks AFG using namespace boost::assign; int main( int argc, char** argv ){ std::vector< int > v; v += 12,13,14,15; bool found_tmp = false; boost::lambda::var_type< bool >::type found( boost::lambda::var(found_tmp) ); std::find_if( v.begin(), v.end(), ( found = ( boost::lambda::_1 == 13 ), return found ) ); }

2 4

boost::filesystem::rename
by immanuel litzroth 08 Apr '10

08 Apr '10

Morning List, looking at the documentation of >template <class Path1, class Path2> void rename(const Path1& from_p, const Path2& to_p); > > Requires: Path1::external_string_type and Path2::external_string_type are the same type. > > Effects: Renames from_p to to_p, as if by POSIX rename(). > > Postconditions: !exists(from_p) && exists(to_p), and the contents and attributes of the file originally named from_p are otherwise unchanged. > > [Note: If from_p and to_p resolve to the same file, no action is taken. Otherwise, if to_p resolves to an existing file, it is removed. A symbolic link >is itself renamed, rather than the file it > resolves to being renamed. -- end note] that does not seem to be what the code does since it checks whether to_p exists and throws an error if it does. I need an atomic overwrite to an existing file since that filename is generated by mkstemp. What will be the semantics of rename i.e. is the documentation in error or is the code (or am I missing something)? Thanks in advance, Immanuel

1 0

Re: [Boost-users] std::list and intrusive_list
by Hicham Mouline 08 Apr '10

08 Apr '10

-----Original Message-----From: strasser(a)uni-bremen.deDate: 07/04/2010 10:28 PMTo: boost-users(a)lists.boost.orgSubject: Re: [Boost-users] std::list and intrusive_listZitat von Hicham Mouline <hicham(a)mouline.org>;: > Hello, I have say 10 (could very well be 1000) instances of const > std::list containers holding the same type T.T is a boost::tuple, > the first field of which is boost::gregorian::date, 4 other double > fields.All the lists are ordered by date. The first, last dates > ranges overlap across lists.The size of each list is of the order of > a 10000 entries. The lists may have different sizes.Further > development of the product may lead to millions of entries in each > list.The objective is to get a uniform set of 10 ranges of dates > from these 10 lists.That is, 1. we apply first an external > [start,finish] date range and reduce the viable entries in each list > to those included in this range.2. As start and finish might not > match a date present in some/all the lists, we further reduce this > date range until we find a range [actual_start, actual_finish] with > these bounds present in all the 10 lists.3. At this stage, we want > to take the union of all the dates available in all the 10 lists, > and where the dates are missing, set the entries to values from the > previous entry in the same list.As the lists are const, and may be > very large, I wish not to modify nor copy the lists to add the > missing dates in each of the 10 list.Instead I thought of adding a > second std::list for each of the 10 lists, and somehow treat the > combined 2 lists as 1 input, using a begin/end pair of iterators > that would iterate over the combined 2 lists as if they were 1 > list.This is impossible to do if I also want to have these iterators > _be_ std::list<T>::iterator.However, if I relax this constraint, I > should be able to write a new iterator class (bidirectional like > list's) that take the 2 lists and would let me iterate over the > combination.Can Boost.Intrusive's list help with this?regards,that was slightly confusing, but IIUC you need an iterator that merges multiple sorted ranges. you could write a boost::iterator_facade that uses a std::priority_queue to decide which of the underlying lists contains the next value. if you can store the resulting list, you can use std::merge/std::inplace_merge instead. _______________________________________________ All right, I will use a boost::iterator_facade. Thank you,

1 0

[Boost.Test] Floating point NAN comparison
by Brian O'Kennedy 08 Apr '10

08 Apr '10

Hi, This bit of Boost.Test code fails: ////////////////////////////////////////////////////////////////////// BOOST_AUTO_TEST_CASE( nantest ) { float a,b; a = b = 1.0; BOOST_CHECK_EQUAL( a, b ); // passes a = b = NAN; BOOST_CHECK_EQUAL( a, b ); // fails } ////////////////////////////////////////////////////////////////////// The failure is because, by definition, NAN != NAN. What I'm after is a test macro which takes this into account and will pass the equality test when both elements are NAN. BOOST_CHECK_CLOSE has the same behaviour. Is the best solution to write my own custom predicate? Brian

2 2

library linking
by mh00219＠surrey.ac.uk 08 Apr '10

08 Apr '10

hello, I am a new student to C++ and using boost libraries in my project. I have a problem please solve it. I am using boost header files in my programs. When I compile using g++ on cygwin by giving the path of boost root directory (c:\boost\boost_1_42_0) it is ok. But when I try to make .exe file from .o file then it gives me error. Please tell me how should I link boost libraries to my program? in which directory are these boost libraries.? please reply must. my whole project is just a pice of writing nothing else. thank you

2 3

How to use property_map?
by Yaohua Xiong 08 Apr '10

08 Apr '10

Hi, I'm trying to figure out how to use property_map in boost graph, after I reduce the problem to the minimal I still don't know what the problem is. Can someone help with this? Thanks in advance. Here is the simplified example: #include <iostream> #include <map> #include <string> #include <boost/property_map/property_map.hpp> using std::string; using boost::put; using boost::get; int main() { typedef std::map<std::string, int> Map; typedef boost::associative_property_map<Map> PMap; PMap map; put(map, string("acc"), 1); get(map, string("acc")); return EXIT_SUCCESS; } This version compiles OK with mingw 4.4, but crash when running. If I make a change from "PMap map;" into "PMap map();" which I think is equivalent, then this code fail to compile, and say D:\myproject\test\boost_test\property_map\pp.cpp: In function 'int main()': D:\myproject\test\boost_test\property_map\pp.cpp:15: error: no matching function for call to 'put(main()::PMap (&)(), std::string, int)' D:\myproject\test\boost_test\property_map\pp.cpp:16: error: no matching function for call to 'get(main()::PMap (&)(), std::string)' What's the problem is? -- Yaohua Xiong Traffic and Transportation Engineering College, Tongji Univ. Cao An Road 4800#, Jia Ding District, Shanghai, China

2 3

[Boost.UTF] Documentation issues
by Adam Nielsen 07 Apr '10

07 Apr '10

Hi all, Just reporting a couple of issues I've come across with the Boost test framework documentation. Would it be possible to get an explanation of the --break_exec_path option added to the runtime parameter reference? http://www.boost.org/doc/libs/1_42_0/libs/test/doc/html/utf/user-guide/runt… On the main doc page http://www.boost.org/doc/libs/1_42_0/libs/test/doc/html/utf.html the link to BOOST_TEST_PASSPOINT goes to the wrong page. Cheers, Adam.

2 1

[Boost.UTF] Suggestion - test tracking
by Adam Nielsen 07 Apr '10

07 Apr '10

Hi all, I have a suggestion for the Boost unit-test library. If this is already possible and I've just missed it, please let me know. It would be nice if there was a sure-fire way to guarantee certain parts of the code were being tested. For example an if/else statement would ideally have tests that cover both execution paths, but at the moment this relies on coding the tests correctly. It's possible to make a mistake in the test and cause it to succeed without actually testing the code in question, and because the test succeeds you may never notice. Would it be possible to have something like a BOOST_TESTED_BY macro, which causes the named test to fail if it completes without running that line? (As well as documenting where that part of the code is tested.) For example: if (condition) { BOOST_TESTED_BY(my_test); } else { BOOST_TESTED_BY(my_other_test); } BOOST_AUTO_TEST_CASE(my_test) { // This test fails if BOOST_TESTED_BY(my_test) doesn't run } Of course this is a simplified example, you'd probably want counts and things as well, but I thought it might be a useful addition to the test framework (assuming it can't be done already!) Thanks, Adam.

2 1

std::list and intrusive_list
by Hicham Mouline 07 Apr '10

07 Apr '10

Hello, I have say 10 (could very well be 1000) instances of const std::list containers holding the same type T.T is a boost::tuple, the first field of which is boost::gregorian::date, 4 other double fields.All the lists are ordered by date. The first, last dates ranges overlap across lists.The size of each list is of the order of a 10000 entries. The lists may have different sizes.Further development of the product may lead to millions of entries in each list.The objective is to get a uniform set of 10 ranges of dates from these 10 lists.That is, 1. we apply first an external [start,finish] date range and reduce the viable entries in each list to those included in this range.2. As start and finish might not match a date present in some/all the lists, we further reduce this date range until we find a range [actual_start, actual_finish] with these bounds present in all the 10 lists.3. At this stage, we want to take the union of all the dates available in all the 10 lists, and where the dates are missing, set the entries to values from the previous entry in the same list.As the lists are const, and may be very large, I wish not to modify nor copy the lists to add the missing dates in each of the 10 list.Instead I thought of adding a second std::list for each of the 10 lists, and somehow treat the combined 2 lists as 1 input, using a begin/end pair of iterators that would iterate over the combined 2 lists as if they were 1 list.This is impossible to do if I also want to have these iterators _be_ std::list<T>::iterator.However, if I relax this constraint, I should be able to write a new iterator class (bidirectional like list's) that take the 2 lists and would let me iterate over the combination.Can Boost.Intrusive's list help with this?regards,

2 1

[Serialization] std::set<std::string> restore performance
by Soumen 07 Apr '10

07 Apr '10

Recently we're profiling our tool for restoration for a large electronic design. And we're restoring two archive of same number of elements - one uses vector as container while the other uses set. And it appears that restoration of set is much much slower than the vector. Both the restoration called from same parent which is called just once. And vector restoration took 2% of parent while set restoration took 83% of parent. And most of set restoration time is spent in : boost::serialization::stl::archive_input_unique<boost::archive::binary_iarchive, std::set<std::string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::string<char, std::char_traits<char>, std::allocator<char>>> > >::operator ()(boost::archive::binary_iarchive&, std::set<std::string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::string<char, std::char_traits<char>, std::allocator<char>>> >&, unsigned) Distribution to callers: 128886 times boost::serialization::stl::load_collection<boost::archive::binary_iarchive, std::set<std::string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::string<char, std::char_traits<char>, std::allocator<char>>> >, boost::serialization::stl::archive_input_unique<boost::archive::binary_iarchive, std::set<std::string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::string<char, std::char_traits<char>, std::allocator<char>>> > >, boost::serialization::stl::no_reserve_imp<std::set<std::string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::string<char, std::char_traits<char>, std::allocator<char>>> >> >(boost::archive::binary_iarchive&, std::set<std::string<char, std::char_traits<char>, std::alloca Contributions from descendants: 128886 times (99.98%) boost::archive::detail::basic_iarchive::reset_object_address( const*, const*) 128886 times ( 0.01%) std::set<std::string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::string<char, std::char_traits<char>, std::allocator<char>>> >::insert(std::string<char, std::char_traits<char>, std::allocator<char>> const&) Is there any known performance problem for std::set<std::string> restoration? Or do we need to do some special to overcome this performance problem of std::set<std::string>? Since we need to use frequent lookup while inserting, we can't switch to vector. So, can I get better performance with hash_set or tr1::unordered_set if those are supported for boost::serialization? We're using 1.35 version of boost. Regards, ~ Soumen -- View this message in context: http://old.nabble.com/-Serialization--std%3A%3Aset%3Cstd%3A%3Astring%3E-res… Sent from the Boost - Users mailing list archive at Nabble.com.

2 1

Hitting a mysterious memory limit for shared mutex
by Stefan Stefansson 07 Apr '10

07 Apr '10

Hi. I'm trying to expose a "framebuffer API" via a C interface in a shared library. The idea is to have something like the following scenario: 1. Call "init" to initialize a sharable mutex and a shared memory segment for the framebuffer. 2. A process that wants to read the framebuffer would obtain a shared lock by calling ruauv_camReadLock() and get a handle on the mutex back (as a void*). 3. After doing what it needs to the framebuffer (which usually means copying it) it would call ruauv_camReadUnlock(void*) and send in the handle it got from step 2. I've implemented this and a test application that simply loops and does this repeatedly but the problem I have is that after exactly 65501 iterations I get an error stating: terminate called after throwing an instance of 'boost::interprocess::interprocess_exception' what(): Cannot allocate memory Here is a link to the relevant code that I'm using: http://pastebin.com/4ERTWEzj If it's of any relevance, I'm creating a shared library from the code above the main() in this snippet and then I'm compiling the main() into an executable and linking with the library. As I say, the for loop is able to iterate 65501 times and then fails the next time (the failure occurs at line 33 in the snippet above). I would really appreciate any help. -- Kær kveðja | With best regards Stefán Freyr Stefánsson Tölvunarfræðideild | School of Computer Science Sérfræðingur | Specialist Beint/Direct +354 599 6534 | GSM/Mobile +354 822 1667 Háskólinn í Reykjavík | Reykjavik University stefan(a)ru.is Menntavegur 1, Nauthólsvík | 101 Reykjavík | Iceland Sími/Tel +354 599 6200 | Fax + 354 599 6201 www.ru.is

2 2

bjam buil "hangs"
by Jean-Pierre Bergamin 07 Apr '10

07 Apr '10

Hello everyone I'm trying to build boost 1.42 on XP with Visual Studio 2005 with the following commands in the Visual Studio Command Prompt: > set boost_dir=C:\Programme\boost\boost_1_42_0 > bjam --build-type=complete --with-thread --with-test --with-system --with-serialization --with-regex --with-program_options --with-filesystem --with-date_time --prefix=%boost_dir% --includedir=%boost_dir% --libdir=%boost_dir%\lib --exec-prefix=%boost_dir% install Now bjam "hangs", using 50% CPU (one core fully utilized), after this output: D:\Downloads\boost_1_42_0>bjam --build-type=complete --with-thread --with-test --with-system --with-serialization --with-regex --with-program_options --with-filesystem --with-date_time --prefix=%boost_dir% --includedir=%boost_dir% --libdir=%boost_dir%\lib --exec-prefix=%boost_dir% install WARNING: No python installation configured and autoconfiguration failed. See http://www.boost.org/libs/python/doc/building.html for configuration instructions or pass --without-python to suppress this message and silently skip all Boost.Python targets warning: No toolsets are configured. warning: Configuring default toolset "msvc". warning: If the default is wrong, your build may not work correctly. warning: Use the "toolset=xxxxx" option to override our guess. warning: For more configuration options, please consult warning: http://boost.org/boost-build2/doc/html/bbv2/advanced/configuration.html warning: Building Boost.Regex with the optional Unicode/ICU support disabled. note: Please refer to the Boost.Regex documentation for more information note: this is a strictly optional feature. Interestingly enough, just running "bjam --build-type=complete" without any other options, starts the build as expected. Any hints how to debug this? Regards James

2 4

[spirit][karma+phoenix] Show result of member function
by Ravi 07 Apr '10

07 Apr '10

Hi, How can karma be used to show the result of applying a member function to objects in a container? Consider the following code (which does not compile) to show the real and the imaginary parts of complex numbers stored in a vector: --8<----8<----8<----8<----8<----8<----8<----8<----8<----8<----8<----8<-- #include <boost/spirit/include/karma.hpp> #include <boost/spirit/include/phoenix_bind.hpp> #include <boost/spirit/include/phoenix_core.hpp> #include <boost/spirit/include/phoenix_operator.hpp> #include <complex> #include <iostream> #include <vector> namespace test { template <typename Container> void show_container( const Container &ctr ) { typedef typename Container::value_type complex_t; typedef typename complex_t::value_type real_t; const real_t& ( complex_t::*real_func )() const = &complex_t::real; const real_t& ( complex_t::*imag_func )() const = &complex_t::imag; namespace karma = boost::spirit::karma; namespace phoenix = boost::phoenix; std::cout << karma::format( ( karma::double_[ // What goes here to extract the real part? karma::_1 = phoenix::bind( real_func, karma::_val ) ] << ',' << karma::double_[ karma::_1 = phoenix::bind( imag_func, karma::_val ) ] ) % karma::eol, ctr ); } } // namespace test int main( int, char *[] ) { std::vector< std::complex<double> > vec( 5 ); test::show_container( vec ); return 0; } --8<----8<----8<----8<----8<----8<----8<----8<----8<----8<----8<----8<-- The issue is that "karma::_1 = phoenix::bind( real_func, karma::_val )" seems unacceptable to the compiler (gcc 4.4.3, boost 1.42, Linux x86_64). The example above is a simplified version of much more complex code. Regards, Ravi

3 5

Boost.Interprocess: Can I share the multi_index array between processes?
by arm2arm 07 Apr '10

07 Apr '10

Hello, I would like to load multiindex container by one process lets say serverside_loader. And access that array by another clientside_analyser process? How to do that? Lets assume that I have a container: <code> struct particleID { int ID;// real ID for particle from Gadget2 file "ID" block unsigned int IDf;// postition in the file particleID(int id,const unsigned int idf):ID(id),IDf(idf){} bool operator<(const particleID& p)const { return ID<p.ID;} unsigned int getByGID()const {return (ID&0x0FFF);}; }; struct ID{}; struct IDf{}; struct IDg{}; typedef multi_index_container< particleID, indexed_by< ordered_unique< tag<IDf>, BOOST_MULTI_INDEX_MEMBER(particleID,unsigned int,IDf)>, ordered_non_unique< tag<ID>,BOOST_MULTI_INDEX_MEMBER(particleID,int,ID)>, ordered_non_unique< tag<IDg>,BOOST_MULTI_INDEX_CONST_MEM_FUN(particleID,unsigned int,getByGID)> > > particlesID_set; </code> kind regards Arman. -- View this message in context: http://old.nabble.com/Boost.Interprocess%3A-Can-I-share-the-multi_index-arr… Sent from the Boost - Users mailing list archive at Nabble.com.

4 4

Boost & OpenMP
by Robert Jones 07 Apr '10

07 Apr '10

Hi All Some vague navel-gazing follows, please bear with me.... I've recently encountered OpenMP, and wondered if there's any activity within Boost to exploit this. Although OpenMP is new to me I appreciate it's been around a while, so apologies in advance if this is all old hat! In a nutshell as I understand it OpenMP is an open standard for explicity directing the compiler to exploit potential parallelism in the code by embedding #pragmas when statements or loops can be parallelised, and specifying in the pragma which variables are common and which are per execution path. The compiler then sorts out threads and locking etc. We have seen some dramatic performance gains using OpenMP. Ok, some (possibly very naive) thoughts - In some ways this is an alternative to Boost thread pools. - Using explicit pragmas is an intermediate step, and ultimately it might be hoped that a compiler would be able to do all this without external direction. - The whole OpenMP notion is too specific for a general library like Boost It occurs to me that there might be benefit in parallelised standard algorithms (for_each, find, etc), although these might have slightly different behaviour to the existing single thread versions. For example, find() would find any occurance of a value, not necessarily the first. Has any work been done in this area, and would it be of interest to anyone? Are there any known show-stoppers that blow the whole notion out of the water? Thanks for listening, - Rob.

5 5

Important: Server Upgrade Wednesday, April 7
by Doug Gregor 07 Apr '10

07 Apr '10

The main Boost server will be down for a Trac upgrade on Wednesday, April 7 from 8am-9am Eastern time. The following services will be affected: Web server (boost.org) Subversion Trac Mailing list archives Mailing lists should still function as normal. My apologies for the late notice. - Doug

1 0

compile problem with wstring in cross-compilation for ARM
by Jürgen Blümer 07 Apr '10

07 Apr '10

Hi, with boost 1.42.0 I have tried to cross-compile an application on a Kubuntu 9.04 for an ARM processor. The application is processing ini-files, so the file 'boost/property_tree/ptree.hpp' is included. During compilation I got the errors: ../../../boost/boost/property_tree/ptree_fwd.hpp:91: error: 'wstring' is not a member of 'std' ../../../boost/boost/property_tree/string_path.hpp:60: error: expected unqualified-id before '&' token ../../../boost/boost/property_tree/string_path.hpp:60: error: expected ',' or '...' before '&' token ../../../boost/boost/property_tree/string_path.hpp:60: error: ISO C++ forbids declaration of 'parameter' with no type ../../../boost/boost/property_tree/string_path.hpp: In function 'std::string boost::property_tree::detail::dump_sequence(int)': ../../../boost/boost/property_tree/string_path.hpp:62: error: 's' was not declared in this scope By looking in the 'hpp'-files referenced in the error message I found, that in 'boost/property_tree/ptree_fwd.hpp' a '#ifndef BOOST_NO_CWCHAR' is only used on line on line 109 for encapsulating wstring usage. Using this ifndef for encapsulating also the other erroneous lines, the error vanishes and everything is compiled. Is there a reason, why the ifndefs are not inserted at the other position? Thanx for help Jürgen Blümer

1 0

[Boost.UTF] --run_test doesn't match long names
by Adam Nielsen 07 Apr '10

07 Apr '10

Hi all, Is there any documentation on permissible test names? Some of my names don't work correctly with the --run_test parameter. I can put up to 15 characters and end with '*' and the tests will be run, but once I specify the 16th character (with a wildcard or without) it prints the error 'no test cases matching filter'. Is there a length limit on test names? I didn't see any mention of one in the docs and didn't get any compile warnings. If there is a limit, is there an easy way to extend it? Thanks, Adam.

2 2

boost lib search path
by mh00219＠surrey.ac.uk 06 Apr '10

06 Apr '10

hello, I am using boost header files in my program. I need to compile it using gcc 4.3.4. but I dont know how to give the search paths of boost libraries to my linker. please reply me with answers. thank you

2 1

Visual Studio 2009 and BOOST_NO_MEMBER_TEMPLATE_FRIENDS
by Daniel Bradburn 06 Apr '10

06 Apr '10

I have just upgraded a project from Visual Studio 2005 to 2008 and suddenly I am getting compile errors using boost::multi_index: error C2247: 'boost::multi_index::detail::random_access_index<SuperMeta,TagList>::operator []' not accessible because 'boost::multi_index::detail::ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>' uses 'protected' to inherit from 'boost::multi_index::detail::random_access_index<SuperMeta,TagList>' I figure that this is to do with the BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS define, so I tried changing #if _MSC_VER <= 1400 // 1400 == VC++ 8.0 # define BOOST_NO_MEMBER_TEMPLATE_FRIENDS #endif to #if _MSC_VER <= 1500 // 1500 == VC++ 9.0 # define BOOST_NO_MEMBER_TEMPLATE_FRIENDS #endif in visualc.hpp which fixes the compile error. Is this a bug with the visualc.hpp config in boost? I can't believe I would be the first to spot it. Has anyone else experienced this? Are member template friends actually supported in visual c++ 9? _________________________________________________________________ Download gratis emoticons voor Messenger http://www.rulive.nl/aspx/emoticons.aspx

2 1

[Graph] Need help with Subgraph and adjacent_vertices.
by Marcus Fontaine 06 Apr '10

06 Apr '10

I'm having trouble finding the adjacent vertices in a subgraph, using the adjacent_vertices function. Although, it seems to work fine on a graph that isn't the subgraph of another. I'm using the g++ compiler, along with boost_1_37_0. The following code demonstrates the problem; the adjacent vertices to 4 in subG should be 2 and 3. However, I get 5 when I run the program. Any fixes or suggestions would be greatly appreciated. #include <iostream> #include <vector> #include <boost/config.hpp> #include <boost/graph/adjacency_list.hpp> #include <boost/graph/subgraph.hpp> using namespace std; using namespace boost; typedef subgraph< adjacency_list<vecS, vecS, undirectedS, property<vertex_index_t, int>, property<edge_index_t, int> > > Graph; int main() { Graph G; add_edge(0, 1, G); add_edge(1, 2, G); add_edge(2, 3, G); add_edge(1, 5, G); add_edge(5, 6, G); add_edge(6, 8, G); add_edge(6, 7, G); add_edge(7, 8, G); add_edge(4, 2, G); add_edge(4, 3, G); add_edge(4, 6, G); Graph subG = G.create_subgraph(); add_vertex(1, subG); add_vertex(2, subG); add_vertex(3, subG); add_vertex(4, subG); add_vertex(7, subG); add_vertex(8, subG); graph_traits<Graph>::adjacency_iterator ai; graph_traits<Graph>::adjacency_iterator ai_end; cout << "Adjacent vertices of 4 in G: "; //Should be (and is): 2 3 6 for(tie(ai, ai_end) = adjacent_vertices(4, G); ai != ai_end; ++ai) { cout << *ai << " "; } cout << endl; //------------------------------------------------------------------------ cout << "Adjacent vertices of 4 in subG: "; //Should be (is not): 2 3 for(tie(ai, ai_end) = adjacent_vertices(4, subG); ai != ai_end; ++ai) { cout << *ai << " "; } cout << endl; return 0; }

2 1

[serialization] error in boost_serialization of static variable
by ashish srivastava 06 Apr '10

06 Apr '10

Hello I am trying to serialize my main code using boost_serialization (attached is the small program I have written to extract my actual problem of how to serialize the static int class member variable). Without boost_serialization of static int variable the code is running fine. But when I try to serialize the static int variable in "Public" of linklist class I get the error (segmentation fault). I tried to use the "BOOST_STRONG_TYPEDEF" to wrap the "int" to "tracked_int" but the effort was in vain. Kindly help me. regards,ashish The INTERNET now has a personality. YOURS! See your Yahoo! Homepage. http://in.yahoo.com/

1 0

[Spirit] compilation problem
by philip tucker 06 Apr '10

06 Apr '10

Hello, I have a simple Spirit parser program which won't compile. I am running boost 1_42_0 with gcc on a mac. The code and error message are attached. I hope you can tell me two things: first, what have I done wrong, and second (if necessary), how can I figure out what I've done wrong from the error message. Thanks again.

2 2

[boost.asio] error Software caused connection abort
by imin imup 06 Apr '10

06 Apr '10

Hello, When I use a tcp socket to connect to remote host, I may get an "actively refused" or "time out" error in 1st time. That's normal. Then when I retry to connect to remote host, I "always" got "Software caused connection abort" error for every rtrial. It seems a programming issue. Could anyone explain what this error mean and how to avoid it? or point me to some document? Thanks Imin

2 4

Property maps hierarchy compilation errors
by ostroganov 05 Apr '10

05 Apr '10

Hi, I want to create hierarchy of property maps like this: #include <boost/graph/adjacency_list.hpp> #include <boost/property_map/property_map.hpp> using namespace boost; struct Base_NodeP { int basic_property; }; struct NodeP : public Base_NodeP { // using Base_NodeP::basic_property int derived_property; }; int main(){ typedef adjacency_list<setS, vecS, undirectedS, property<vertex_index_t,int,NodeP>, no_property> TGraph; property_map<TGraph, int NodeP::*>::type _basic_property; property_map<TGraph, int NodeP::*>::type _derived_property; TGraph tgraph; _derived_property = get(&NodeP::derived_property, tgraph); _basic_property = get(&NodeP::basic_property, tgraph); return 0; } When I compile this code in MSVS 2008, I'm getting error C2679: binary '=' : no operator found which takes a right-hand operand of type 'boost::bundle_property_map<Graph,Descriptor,Bundle,T>' (or there is no acceptable conversion). gcc 4.3.2 gives similar error: error: no match for ‘operator=’ in ‘_basic_property = boost::get [with OutEdgeListS = boost::setS, VertexListS = boost::vecS, DirectedS = boost::undirectedS, VertexProperty = boost::property<boost::vertex_index_t, int, NodeP>, EdgeProperty = boost::no_property, GraphProperty = boost::no_property, EdgeListS = boost::listS, T = int, Bundle = Base_NodeP](&Base_NodeP::basic_property, ((boost::adjacency_list<boost::setS, boost::vecS, boost::undirectedS, boost::property<boost::vertex_index_t, int, NodeP>, boost::no_property, boost::no_property, boost::listS>&)(& tgraph))) When I uncomment "using Base_NodeP::basic_property" in NodeP declaration, MSVS is happy, but gcc still cannot compile the code. Do you have any suggestions, how can I make this code work under gcc? Am I doing something wrong? Thanks for any help, Oleg -- View this message in context: http://old.nabble.com/Property-maps-hierarchy-compilation-errors-tp28137714… Sent from the Boost - Users mailing list archive at Nabble.com.

2 1

serialization unordered_map
by alev mutlu 05 Apr '10

05 Apr '10

I could not find any library for unordered_map? Is there one?

3 2

serialization 1.42 problems with enable_shared_from_this ?
by Avi Bahra 05 Apr '10

05 Apr '10

Not quite sure what is going on here. I am serializing shared_ptr, that make use of derivation from enable_shared_from_this. However when my class is restored from disk, it appears that accessing shared_from_this() throws a tr1::bad_weak_ptr. Using boost 1.42, gcc 4.2.1, on suse linux. Has any one hit a similar issues, or found any work arounds ? Any help greatly appreciated. Here is some contrived standalone code, that demonstrate the problem. /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // =========== file Main.cpp =================== // After restoring a class via shared_ptr it // appears as if enable_shared_from_this has not // been honoured. When accessing shared_from_this() // I get tr1::bad_weak_ptr exception. #include <iostream> #include <fstream> #include <assert.h> #include <boost/archive/text_iarchive.hpp> #include <boost/archive/text_oarchive.hpp> #include <boost/serialization/base_object.hpp> #include <boost/serialization/string.hpp> #include <boost/serialization/vector.hpp> #include <boost/serialization/shared_ptr.hpp> #include <boost/serialization/export.hpp> #include <boost/shared_ptr.hpp> #include <boost/enable_shared_from_this.hpp> using namespace std; using namespace boost; class Base : public boost::enable_shared_from_this<Base> , private boost::noncopyable { protected: Base() {} virtual ~Base() {} public: virtual const std::string& name() const = 0; private: friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int){} }; typedef boost::shared_ptr<Base> base_ptr; class Derived : public Base { public: Derived(const std::string& name ) : Base(), name_(name){} Derived() {} virtual ~Derived() {} virtual const std::string& name() const { return name_;} base_ptr find(const std::string& name) const { if (name_ == name) { Derived* nonConstThis = const_cast<Derived*>(this); return nonConstThis->shared_from_this(); // throws after restore ? } return base_ptr(); } private: std::string name_; friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int) { ar & boost::serialization::base_object<Base>(*this); ar & name_; } }; typedef boost::shared_ptr<Derived> d_ptr; class Holder { public: Holder() {} void add(d_ptr b) { vec_.push_back(b);} base_ptr find(const std::string& name) const { for(size_t i=0; i < vec_.size(); i++){ base_ptr base = vec_[i]->find(name); if (base) return base; } return base_ptr(); } private: std::vector<d_ptr> vec_; friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int){ ar & vec_; } }; void save(const Holder& holder, const char* filename) { std::ofstream ofs( filename ); boost::archive::text_oarchive oa( ofs ); oa << holder; } void restore(Holder& holder, const char* filename) { std::ifstream ifs( filename ); boost::archive::text_iarchive ia( ifs ); ia >> holder; } int main() { std::string fileName = "test.txt"; { Holder holder; holder.add( d_ptr(new Derived("me"))); holder.add( d_ptr(new Derived("you"))); base_ptr b = holder.find("me"); assert(b.get()); // works save(holder, fileName.c_str()); } Holder restored; restore(restored,fileName.c_str()); // why does the restored class throw // a weak ptr exception try { base_ptr b = restored.find("me"); // fails ? assert(b.get()); // never gets here } catch (std::exception& e) { std::cout << "Ooops exception " << e.what() << " thrown, test failed??? \n"; std::remove(fileName.c_str()); return 1; } std::remove(fileName.c_str()); cout << "test passed\n"; } Best regards, Ta, Avi

2 1

[posix_time] time_duration operator/() overload
by Norbert Wenzel 04 Apr '10

04 Apr '10

Hello, I use boost::posix_time a lot in my code and I really do appreciate the library. But there's one thing I was recently missing when comparing time_durations to each other. double time_duration::operator/(time_duration); From my point of view this is a perfectly valid operation (as opposed to operator*(time_duration)) that returns the proportion of the two durations. I need that operation to compute statistics like "n% of the time I did x" or similar. What I'm currently doing is computing the proportions via time_duration::total_*() which works fine, but leads to some coding effort, since I'll have to cast one result to a real number to avoid integer division and some checks to prevent /0. I assume I'm not the first to compare time_durations so I was wondering if there was a reason operator/() is not overloaded for time_duration? Or if there is generally a better way to compare two durations? thanks, Norbert

4 4

[Spirit] simplified struct.cpp coredumps
by philip tucker 04 Apr '10

04 Apr '10

Hello, I have a Spirit program that fails with a segmentation fault and I can't see why. I hope you can help. I'm starting from a simplified version of struct.cpp, known to work. I want to abstract the identifier grammar into its own struct and use that instead of the inline grammar for an identifier. The problem code is attached. What have I done wrong? Thanks as always for your patient, expert, and helpful comments. P.S. I'm running boost_1_42_0 with gcc -v: Using built-in specs. Target: i686-apple-darwin9 Configured with: /var/tmp/gcc_42/gcc_42-5574~1/src/configure -- disable-checking --enable-werror --prefix=/usr --mandir=/usr/share/ man --enable-languages=c,objc,c++,obj-c++ --program-transform-name=/^ [cg][^.-]*$/s/$/-4.2/ --with-slibdir=/usr/lib --build=i686-apple- darwin9 --with-gxx-include-dir=/usr/include/c++/4.0.0 --host=i686- apple-darwin9 --target=i686-apple-darwin9 Thread model: posix gcc version 4.2.1 (Apple Inc. build 5574) on Model Name: iMac Model Identifier: iMac9,1 Processor Name: Intel Core 2 Duo Processor Speed: 2.66 GHz Number Of Processors: 1 Total Number Of Cores: 2 L2 Cache: 6 MB Memory: 2 GB Bus Speed: 1.07 GHz Boot ROM Version: IM91.008D.B08 SMC Version (system): 1.44f0 P.S.S If you want the coredump, let me know.

2 3

[Regex] Major performance difference between Boost.Regex and Linux regex library
by Kieran O'Donohoe 04 Apr '10

04 Apr '10

Hi, I am just starting to use Boost.Regex, porting from the Linux system regex library to Boost.Regex, and after doing initial testing on my first change I see a major performance impact, where Boost.Regex is about 30 times slower than the system regex library. The Boost.Regex documentation seems to imply that its performance has a positive comparsion with existing libraries so I expect that I am doing something wrong but can't see it. My regex strings are relatively short normal strings, e.g. "Authentication-Info", that is they contain no RE like syntax. The str passed to regex_search() (also tried regex_match()) can be an exact match to the regex, but may differ by case or surrounded by white space. Boost.Regex is used as follows: // I have a heap pointer to 44 boost::regex objects, all stored in a list // also associated with each boost::regex object is a function unique to each boost::regex* myRegex = new boost::regex("Authentication-Info", boost::regex::icase|boost::regex::nosubs); ... /* boost::regex_search() is called in a loop on the above list of boost::regex objects, for each test iteration there are 9 different values of name, all of which have a match in the above list, that is boost::regex_search() can be called up 396 times per test iteration, I performed a 1000 iteration test. */ // const char* name could be " authentication-info " and should match positively (and does) with the regex if(boost::regex_search(name, *myRegex, boost::match_nosubs)==true) { // do stuff on match - that is call associated function // then exit loop } I have also tried flags other than does listed, all with the same result. I put the test through a profiler and see that calls on match_results and sub_match are called a number of times (over 9 million) which makes me pretty sure that this is where the problem is, I don't need any match_results/sub_match, I just need validation that the string exists. Obviously a match needs to be made, but approx 51 match_results object constructions per search seems over the top. Fyi, here is an entry from the profiler output calling boost::regex_search() 186,000 times, which is expected: [5] 94.9 0.00 2.46 186000 bool boost::regex_search<char const*, char, boost::regex_traits<char, boost::cpp_regex_traits<char> > >(char const*, char const*, boost::basic_regex<char, boost::regex_traits<char, boost::cpp_regex_traits<char> > > const&, boost::regex_constants::_match_flags) [5] But this entry where boost::match_results::match_results() is called 9,486,000 times is unexpected: [9] 35.3 0.18 0.73 9486000 boost::match_results<char const*, std::allocator<boost::sub_match<char const*> > >::match_results(std::allocator<boost::sub_match<char const*> > const&) [9] The same code executes 30 times faster if I replace new boost::regex(...) with a call to regcomp(&m_preg, "Authentication-Info", REG_EXTENDED | REG_ICASE) where m_preg is wrapped in a UDT that is heap allocated and likewise boost::regex_search(..) is replaced with a call to regexec() where nmatch is 0. _________________________________________________________________ Hotmail: Trusted email with powerful SPAM protection. https://signup.live.com/signup.aspx?id=60969

2 1

Using type_trait-like functionality to detect incomplete types
by Michael Cox 04 Apr '10

04 Apr '10

I'm using googlemock to do some unit-testing via mock objects and I'm getting compiler errors on some of my mock methods. Because googlemock has some sophisticated meta-template programming techniques to allow it to print out the arguments passed to a mock method, I'm getting compiler errors on some of the methods that have incomplete types used as arguments. Is there anyway via boost::/tr1:: type_traits that I can detect this situation and have the gmock PrintTo template function just print "incomplete". I was hoping to find a nice "is_complete<T>" template function that would do the trick, but haven't found such a thing. Is it even possible to detect it without causing a compiler error? Michael

2 1

[Function] requiring an exact match in function signature?
by Nathan Ridge 04 Apr '10

04 Apr '10

Hello, I'm wondering if there is a way to force boost::function to only accept functions/functors with the exact same signature. I need this because there are cases in my program where passing a function with a different but convertible signature is almost certainly an error, and it would really be nice if such uses triggered a compiler error. For instance, boost::function will readily convert a mutator function with this signature: T mutate(const T&) to a function with this signature: void mutate(T&) even though the two functions clearly have different semantics. I know I could force the signatures to be the same by simply using a plain function pointer, but I want to give the user the flexibility to pass in function objects (functors) as well. Any suggestions? Cheers, Nate. _________________________________________________________________ Got a phone? Get Hotmail & Messenger for mobile! http://go.microsoft.com/?linkid=9724464

2 4

Spirit: simplified struct.cpp won't compile
by philip tucker 03 Apr '10

03 Apr '10

Why not? Thanks.

2 1

[boost][serialization] Binary portable archive (eos implementation in Vault)
by Marc Perso 03 Apr '10

03 Apr '10

Hi all, Right now, we are involved in a development stage that requires data exchange between processes running on various operating systems, i.e. Windows XP 32bits <→ Windows Seven 64bits. We are using a TCP/IP communication protocol based on Boost∷Asio and Boost∷Serialization for that. In order to manage the portability of our data exchange (int, float, double,…), we have tried to use the binary portable archive posted by Christian Pfligersdorffer in Vault /Serialization but we are not able to use it; we are experiencing a lot of compilation errors. For illustrating this point, I’ve attached a very simple source file based on GPS example of Boost.Serialization: if the line #7 (#define PORTABLE_ARCHIVE) is commented the file compilation runs smoothly but with this “define” it fails. Our setup is the following: - Boost 1.40 - VC 7.1 - OS/WinXP I would like to know if someone around there has play with this portable implementation and how we must proceed. Any help? Best regards, Marc Viala

1 0

[spirit,regex] Linking problems in VS 2008
by Adam Badura 03 Apr '10

03 Apr '10

I am using regex_p parser in Spirit. This uses Boost.Regex. The code compiles fine but does not link. Error messages are (debug mode, static linking, Boost 1.42): -------------------- 1>configuration.obj : error LNK2019: unresolved external symbol "public: void __thiscall boost::re_detail::raw_storage::resize(unsigned int)" (?resize@raw_storage@re_detail@boost@@QAEXI@Z) referenced in function "public: void * __thiscall boost::re_detail::raw_storage::extend(unsigned int)" (?extend@raw_storage@re_detail@boost@@QAEPAXI@Z) 1>configuration.obj : error LNK2019: unresolved external symbol "public: void * __thiscall boost::re_detail::raw_storage::insert(unsigned int,unsigned int)" (?insert@raw_storage@re_detail@boost@@QAEPAXII@Z) referenced in function "public: struct boost::re_detail::re_syntax_base * __thiscall boost::re_detail::basic_regex_creator<char,struct boost::regex_traits<char,class boost::cpp_regex_traits<char> > >::insert_state(int,enum boost::re_detail::syntax_element_type,unsigned int)" (?insert_state@?$basic_regex_creator@DU?$regex_traits@DV?$cpp_regex_traits@D@boost@@@boost@@@re_detail@boost@@QAEPAUre_syntax_base@23@HW4syntax_element_type@23@I@Z) 1>D:\Studies\Thesis\Debug\prover.exe : fatal error LNK1120: 2 unresolved externals -------------------- The interesting thing is that if I turn language extensions on (/Za option) in the project the problem disappears. How can this be solved? Adam Badura

2 4

[Proto?][Phoenix?] : Advice on creating lazy data structures
by Manjunath Kudlur 03 Apr '10

03 Apr '10

With Phoenix or lambda-like DSELs implemented with Proto, it is easy to implement stuff when the expected actual parameters to the lambda expressions are primitive types. When I want to pass arbitrary types to the lambda expression and manipulate it in the lambda expression, things become complex. For example, consider the following function : struct point { float x; float y; }; float sum(point p) { return p.x+p.y; } If I want to have a lazy version of this function, I cannot simply do (arg1.x + arg1.y)(p). I have to implement functions that return Proto or Phoenix expressions and use it in the language. In the above case, it would look something like (point_get_x_(arg1) + point_get_y_(arg2))(p). So for every type I want to support in the DSEL, I have to implement lazy versions of functions to get and set the type members, or call some methods. In other words, the language has to be aware of all the data types that can be used with it. I am looking for some advice on a standard or a generic way for creating such lazy data structures. Has something like this been done before? I will be grateful for any pointers and suggestions. Thanks, Manjunath

2 4

Boost Graph: edge indices
by Trevor Harmon 02 Apr '10

02 Apr '10

Hi, In the Boost Graph library, vertices have an index (vertex_index_t), and I was under the impression that edges have one, too. At least, there's a predefined type called edge_index_t. However, I can't figure out how to access an edge's index. For example, consider a graph defined like: typedef adjacency_list<vecS, vecS, directedS, Foo*> MyGraph; typedef graph_traits<MyGraph>::vertex_descriptor Vertex; typedef graph_traits<MyGraph>::edge_descriptor Edge; And let's say I've got a vertex descriptor called "u". I can iterate over u's outgoing edges like this: typedef graph_traits<MyGraph>::out_edge_iterator out_iter; std::pair<out_iter, out_iter> outp; for (outp = out_edges(u, g); outp.first != outp.second; ++outp.first) { Edge e = *outp.first; Vertex v = target(e, g); cout << index[v] << std::endl; // Works fine cout << index[e] << std::endl; // Compiler error } In this example, index[v] works as expected, but index[e] gives me a compiler error: "no match for ‘operator[]’ in ‘index[e]". Perhaps my graph typedef needs to be changed so that its edges have a property map for edge_index_t, although I'm not sure how to do that. (And anyway I wouldn't expect vertices to have indices by default but edges not...) Thanks for any help, Trevor

3 11

begin, end and directory iterators
by Robert Jones 02 Apr '10

02 Apr '10

Do boost::begin() and boost::end() support directory iterators? ie., can you write void f(boost::filesystem::path&); boost::filesystem::path some_directory; std::for_each(boost::begin(some_directory), boost::end(some_directory), f); If they don't, could they and should they? - Rob.

3 2

[1.43.0] Change of release schedule
by Beman Dawes 02 Apr '10

02 Apr '10

To allow a large block of weekend time for last tweaks, from now on the release schedule is going to be changed to the first Monday of the second month of each quarter. Updated calendar 1.43.0: http://www.boost.org/development/index.html General date info: http://svn.boost.org/trac/boost/wiki/ReleaseSchedule --Release managers

1 0

[Graph] Problem trying to delete vertices from a graph using named vertices, please help!
by Camillo Anania 02 Apr '10

02 Apr '10

Hi guys, I have a graph so defined: typedef boost::adjacency_list<boost::listS, boost::listS, boost::bidirectionalS, Osm::VertexProperties, EdgeProperties> Graph; Graph osmGraph; I'm trying to delete some vertices from osmGraph using the usual remove_vertex(Vertex, Graph) but I get the following error from Visual Studio 2008 when compiling: boost_1_40_0\boost/graph/named_graph.hpp(349) : error C2664: 'boost::multi_index::detail::hashed_index_iterator<Node,BucketArray> boost::multi_index::detail::hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>::erase(boost::multi_index::detail::hashed_index_iterator<Node,BucketArray>)' : cannot convert parameter 1 from 'void *' to 'boost::multi_index::detail::hashed_index_iterator<Node,BucketArray>' the code I use is: { vector<int> component(num_vertices(osmGraph)); int num = strong_components(osmGraph, make_iterator_property_map(&component[0], get(&Osm::VertexProperties::id, osmGraph)), vertex_index_map(get(&Osm::VertexProperties::id, osmGraph))); int main_comp = component[depotID]; for (int i = 0; i != component.size(); i++){ if (component[i] == main_comp) continue; if (is_incident_to_required_edge(osmGraph, i)){ cerr << "Required components on input topology are not strongly connected. Check the input .osm file" << endl; return 1; } else { clear_vertex(osm_get_vertex(i, osmGraph), osmGraph); Osm::Vertex osm_v = osm_get_vertex(i, osmGraph); cout << "id=" << osmGraph[osm_v].id << endl; remove_vertex(osm_v, osmGraph); } } } why it doesnt work? why the same code with the graph defined in the following way works? typedef adjacency_list < listS, listS, bidirectionalS, property < vertex_name_t, std::string, //vertex property property < vertex_unique_id_t, int, property < vertex_color_t, boost::default_color_type> ............. >, //edge property property < edge_index_t, int, property < edge_num_bins_t, int, property < edge_unique_id_t, int, property < edge_name_t, std::string> ..............> > Graph; PLEASE help. Camillo Ciao

2 4

Release 1.12 of the C++ Middleware Writer on line
by Brian Wood 01 Apr '10

01 Apr '10

B"H Release 1.12 of the C++ Middleware Writer is now on line. This release fixes several bugs and adds support for the following: 1. Multiple inheritance, but we don't support virtual inheritance yet. G-d willing, we'll add that later. 2. boost::scoped_ptr, auto_ptr/unique_ptr. 3. Accounts An account is now needed to use the command line interface of the C++ Middleware Writer. When an account is created, a directory will be associated with the account. That directory is reused with each request and only the input files that have changed since your last request are transmitted. The command line interface config file, direct.cfg, refers to an Account-Number. That file has to be updated after you set up an account. Use this page -- http://webEbenezer.net/cgi-bin/account.cgi -- to set up an account. Setting up an account is currently trivial -- no questions asked -- just click the button. There's an example of the multiple inheritance and scoped_ptr support here -- http://webEbenezer.net/release/112.example . Cheers, Brian Wood http://www.webEbenezer.net (651) 251-9384

1 0

trying to build custom property_map
by Sandeep Gupta 01 Apr '10

01 Apr '10

Hi, I created a simple property_map as follows: struct VecMap { typedef int value_type; typedef int key_type; typedef read_write_property_map_tag category; typedef int* reference; std::vector<int> vec_store; }; void put(VecMap& rmap, int key, int val) { rmap.vec_store[key] = val; } int get(VecMap& rmap, int key) { return rmap.vec_store[key]; } /// End code The compiler gcc-4.4.1 against latest boost-trunk gives errorerror: no type named value_type in struct boost::property_traits<VecMap> The code however compiles fine with boost_1_40. Please take a look. The full code is available here http://codepad.org/KtmbXkLa Thanks Sandeep

2 7

[Boost-build] Bjam flags
by Carlos 01 Apr '10

01 Apr '10

Hi, I need to use the "whole-archive" flag to force an executable to link some static objects. I know how to do it with autotools, but it is possible to do using boost-build system? Thanks

1 0

Cross compiling boost 1.33.1
by srinath duraisamy 01 Apr '10

01 Apr '10

Hi all, I have to cross compile the boost 1.33.1 for my development board. I downloaded boost_1_33_1 from the sourceforge download page and I followed the steps provided as per this link ( http://www.boost.org/doc/tools/build/doc/html/bbv2/tasks/crosscompile.html ) 1. specify your cross compiler in user-config.jam using gcc : arm : arm-none-linux-gnueabi-g++ ; 2. bjam toolset=gcc-arm It needs bjam, so I download and installed the bjam from boost download page. when I run bjam toolset=gcc-arm, I am getting the following error: don't know how to make toolset=gcc-arm ...found 1 target... ...can't find 1 target... It will be very helpful, if someone guide me with the steps to cross compile boost1.33.1 version. Thanks in advance.

4 5

Help for using interprocess::managed_mapped_file
by Kanthimathi Kalyanamandapam 01 Apr '10

01 Apr '10

Hi: I am experimenting with managed_mapped_file to store a vector of a complex_data encapsulating a string and an array quite like the provided "containers of containers" example. However, the program behaves in a rather erratic manner , throwing up boost::interprocess_exception::library_error quite randomly after inserting a few elements. I am including the program below , any help on this will be highly appreciated, With Regards, Kanthi K ///////////////////////// // Compile with: g++ -ansi -Wall -O2 -lrt -o output progname.cc #include <iostream> #include <string> #include <map> #include <list> #include <boost/tuple/tuple.hpp> #include <boost/interprocess/managed_mapped_file.hpp> #include <boost/interprocess/allocators/allocator.hpp> #include <boost/interprocess/containers/string.hpp> #include <boost/interprocess/containers/vector.hpp> #include <boost/interprocess/exceptions.hpp> #define MEGABYTE 1048576L /** * Class for storing data in a mmap file */ class memmapfile { private: typedef boost::interprocess::managed_mapped_file managed_mapped_file_t; typedef managed_mapped_file_t::segment_manager segment_manager_t; typedef boost::interprocess::allocator<void, segment_manager_t> void_alloc; typedef boost::interprocess::allocator<int, segment_manager_t> int_alloc; typedef boost::interprocess::allocator<char, segment_manager_t> char_alloc; typedef boost::interprocess::vector<int, int_alloc> mm_int_vector; typedef boost::interprocess::basic_string<char, std::char_traits<char>, char_alloc> mm_string; typedef std::list<int> std_int_list; /* holder */ struct holder { holder(mm_string mstr, mm_int_vector mintvec) : mstr_(boost::interprocess::move(mstr)), mintvec_(boost::interprocess::move(mintvec)) { } ~holder() {} private: mm_string mstr_; mm_int_vector mintvec_; }; typedef boost::interprocess::allocator<holder, segment_manager_t> holder_alloc; typedef boost::interprocess::vector<holder, holder_alloc> mm_holder_vector; /** functions */ /** segment functions */ void open_file() { segment = managed_mapped_file_t(boost::interprocess::open_or_create, file_location_.c_str(), file_size_); void_alloc alloc_inst(segment.get_segment_manager()); mm_holder_vector *usevec; usevec = segment.find_or_construct<mm_holder_vector> (boost::interprocess::unique_instance) (alloc_inst); std::cerr << "Vec Size at open : " << usevec->size() << std::endl; } void grow_file(std::size_t ExtraBytes) { if (ExtraBytes <= 0) ExtraBytes=file_incr_unit; std::cerr << "Growing file : " << file_size_ << " + " << ExtraBytes << " = "; segment.grow(file_location_.c_str(),ExtraBytes); segment = managed_mapped_file_t(boost::interprocess::open_only, file_location_.c_str()); file_size_ = segment.get_size(); std::cerr << file_size_ << std::endl; } void init_usevec(bool clear) { void_alloc alloc_inst(segment.get_segment_manager()); mm_holder_vector *usevec; std::size_t count=0; boost::tie(usevec,count) = segment.find<mm_holder_vector> (boost::interprocess::unique_instance); if (count==0) { std::cerr << "Cannot find vector" << std::endl; exit(1); } if (clear) { std::cerr << "Clearing vector" << std::endl; segment.destroy<mm_holder_vector>(boost::interprocess::unique_instance); usevec = segment.construct<mm_holder_vector> (boost::interprocess::unique_instance) (alloc_inst); } } /* variables */ std::string file_location_; std::size_t file_size_; const std::size_t file_incr_unit; managed_mapped_file_t segment; public: memmapfile(const std::string file_location, const std::size_t file_size, bool clear) : file_location_(file_location), file_size_(file_size), file_incr_unit(file_size) { try { open_file(); if (file_size_ > segment.get_size()) grow_file(file_size_ - segment.get_size()); init_usevec(clear); } catch (...) { std::cerr << " Cannot init mmapfile " << std::endl; exit(1); } } virtual ~memmapfile() {} /** * add: add an entry */ template<class T> std::size_t add(const std::string& in_str, const T& in_list) { std::size_t ret=0; try { std::size_t min_space_need = (in_str.length() * sizeof(char)) + (in_list.size() * sizeof(typename T::value_type)); while ( min_space_need*4 > segment.get_free_memory() ) { grow_file(file_incr_unit); } void_alloc alloc_inst(segment.get_segment_manager()); mm_holder_vector *usevec; std::size_t count=0; boost::tie(usevec,count) = segment.find<mm_holder_vector> (boost::interprocess::unique_instance); if (count==0) { std::cerr << "Cannot find vector" << std::endl; exit(1); } mm_string move_mstr(alloc_inst); mm_int_vector move_mintvec(alloc_inst); move_mstr = in_str.c_str(); for (typename T::const_iterator it = in_list.begin() ; it!= in_list.end() ; ++it) { move_mintvec.push_back(*it); } usevec->push_back(holder(move_mstr,move_mintvec)); ret = usevec->size(); std::cerr << "Added, Vec size: " << usevec->size() << "/" << usevec->max_size() << ", "; std::cerr << "Memory free: " << segment.get_free_memory() << "/" << segment.get_size() << ", "; double f = ((double)segment.get_free_memory()/(double)segment.get_size()) * 100; std::cerr << "% : " << f << std::endl; } catch (boost::interprocess::interprocess_exception e) { std::cerr << "Cannot add: " << e.what() << std::endl; exit(1); } return ret; } }; int main() { typedef std::list<int> std_int_list; std::string in_str = "abcdefghijklmnopqrstuvwxyz"; std_int_list in_list; for (int i=0; i<1024*8; ++i) { in_list.push_back(i) ; } std::size_t min_space_need = (in_str.length() * sizeof(char)) + (in_list.size() * sizeof(std_int_list::value_type)); std::cerr << "#### min space needed: " << min_space_need << std::endl; memmapfile* m = new memmapfile("test.bin",MEGABYTE,false); int i=0; while (++i<100) { std::size_t sz = m->add<std_int_list>(in_str,in_list); std::cerr << "Added in main loop: " << sz << std::endl; } } Your Mail works best with the New Yahoo Optimized IE8. Get it NOW! http://downloads.yahoo.com/in/internetexplorer/

1 0

inappropriate ADL
by Volker Schöch 01 Apr '10

01 Apr '10

Hi all, given this code... #include <deque> #include <boost/algorithm/string/find.hpp> #include <boost/operators.hpp> template< class Rng, class T > typename boost::range_iterator<Rng>::type find( Rng& rng, T const& t ) { return std::find( boost::begin(rng), boost::end(rng), t ); } struct STest : boost::equality_comparable<STest> { bool operator==(STest const& test) const { return true; } }; void main() { std::deque<STest> deq; find( deq, STest() ); } ...the VS9 compiler fails with "error C2668: 'find' : ambiguous call to overloaded function". This is due to the fact that STest inherits from a type that is defined in boost namespace which triggers the compiler to try ADL which finds boost::algorithm::find(RangeT& Input, const FinderT& Finder). An obvious solution is to prefix the call to find(...) with ::, but this feels wrong: It does not make sense that the compiler does ADL in this case. There is nothing special about boost::equality_comparable<...> that would make it a more natural argument for boost::algorithm::find(RangeT& Input, const FinderT& Finder) than any other type, and there is nothing special about boost::algorithm::find(RangeT& Input, const FinderT& Finder) that would make it a more natural find implementation for boost::equality_comparable<...> than my find(Rng& rng, T const& t). Maybe the function and the type should not be in the same namespace in the first place. Currently, the mere presence of the specific implementation boost::algorithm::find(RangeT& Input, const FinderT& Finder) disallows the implementation of the canonical find(Rng& rng, T const& t). Opinions? Suggestions? Thanks a lot, Volker -- Volker Schöch · vschoech(a)think-cell.com Senior Software Engineer think-cell Software GmbH · Chausseestr. 8/E · 10115 Berlin, Germany http://www.think-cell.com · phone +49 30 666473-10 · toll-free (US) +1 800 891 8091 Directors: Dr. Markus Hannebauer, Dr. Arno Schoedl · Amtsgericht Berlin-Charlottenburg, HRB 85229

2 1

[serialization] baffled by very long archive load time
by Martin Weinberg 01 Apr '10

01 Apr '10

I have been developing and maintaining a large computatation statistics package (http://www.astro.umass.edu/BIE) It is an MPI application that uses boost::sersialization to implement persistence. After recently adding a new class, I notice that the archive load times have gone from seconds to over an hour!! The binary archive size is 30MB. Regression tests suggest that the resumed state is correct albeit the very long load time. The package is implemented in multiple shared libraries and classes are exported as suggested in the documentation. I have noticed that I need to compile with "-Ox -fno-inline-small-functions" when x=2,3. I'm not sure if this is significant. The system is Debian/GNU Linux, 2.2Ghz 0pteron 64bit. The behavior is the same with Boost 1.37, 1.38 and 1.42. The new class has many nested STL container instances e.g. vector< vector<float> > . . . but very few archived pointers. I've not been able to isolate the cause in test cases (e.g. making very large instances of STL nested containers; these are deserialized in under a second). Any thoughts on things to track down? Thanks! -- Martin Weinberg Phone: (413) 545-3821 Dept. of Astronomy FAX: (413) 545-4223 530 Graduate Research Tower weinberg(a)astro.umass.edu University of Massachusetts Amherst, MA 01003-4525

5 11

[Iostreams] How to check whether file has ben opened?
by Daniel Eiband 01 Apr '10

01 Apr '10

Hi, I'm using Boost 1.42.0 and I have the same problem like vandamme described in this post at the end: http://groups.google.com/group/boost-list/browse_thread/thread/c290c987bf1f… The following code will assert if the file "test" does not exist: std::string filename("test"); boost::iostreams::stream<boost::iostreams::file_source> file; file.open(filename.c_str()); if (file.is_open()) { // assert fires if file "test" does not exist assert(boost::filesystem::exists(filename)); } The indirect_streambuf doesn't check the device and just returns true if open has been called (independent of whether open has been successful). If I use the std::ifstream supplied with MSVC 9.0 is_open() returns false if the file does not exits. Checked by replacing file declaration with: std::ifstream file; Is this a bug? If not how can I test whether opening the stream succeeds? Thanks, Daniel

2 5

boost::thread destructor and detach()
by Eric J. Holtman 01 Apr '10

01 Apr '10

It looks like the new C++ standard threading library is going to call terminate() on a thread if it's being destructed, and has not been detached or joined. Is boost::thread going to change to emulate that behavior? (Currently, it calls detach(), not terminate()). I hadn't been calling detach () in my programs when I was spinning off a thread that I didn't care about joining later. Should I be doing that, just so my code works with either library?

2 1

[boost::numeric::functional::plus_base] Why the arguments are not const reference
by Kan Li 01 Apr '10

01 Apr '10

It seems like the operators define in boost::numeric::functional takes reference as argument instead of const reference. Which makes it compile error if I use boost::numeric::functional::plus<int, int> op; int n = op(1,1); The way to work around is boost::numeric::functional::plus<const int, const int> op; int n = op(1,1); This is very ugly and not makes much sense, compared to std::plus. So is it a design flaw or is there some other reason for designing it in this way?

1 0

boost path???
by mh00219＠surrey.ac.uk 31 Mar '10

31 Mar '10

Hello everybody, Can you please tell me should I give the path of boost libraries in my windows PATH variable after installation.? thank you

2 1

[serialization][Fwd: Re: Saving and reloading a container to/from disk]
by Jeff Flinn 31 Mar '10

31 Mar '10

I've forwarded this from comp.lang.c++. The OP has tried the demo.cpp example (I think), and is getting results different from those the demo says are expected. This is related to versioning... but I'm confused as to what should be the result. Jeff -------- Original Message -------- Subject: Re: Saving and reloading a container to/from disk Date: Wed, 31 Mar 2010 13:59:16 +0200 From: jacob navia <jacob(a)jacob.remcomp.fr> Reply-To: jacob(a)jspamsink.org Organization: lccwin Newsgroups: comp.lang.c++ References: <4bb2e6b3$0$15818$ba4acef3(a)reader.news.orange.fr> <81gc4oFua5U6(a)mid.individual.net> Ian Collins a écrit : > On 03/31/10 07:07 PM, jacob navia wrote: >> Hi >> >> What would be the best way to save and reload later a container >> to/from disk in C++? > > It depends, there isn't really a best way. Do you want portability? > > http://www.boost.org/doc/libs/1_42_0/libs/serialization/doc/index.html > > Is a good place to start. > Thanks. I downloaded the boost libraries, and compiled them in my machine. Unziped the source code is 269MB. Compilation took 14 minutes. Machine Mac-pro OS X with 8 CPUs and 12GB RAM. Then, I compiled the example of the serialization. The class being saved/restored looks like this: original schedule 6:24 bob 0x0x100200440 34?135'52.56" 134?22'78.3" 24th Street and 10th Avenue 0x0x1002004d0 35?137'23.456" 133?35'54.12" State street and Cathedral Vista Lane 0x0x100200530 35?136'15.456" 133?32'15.3" White House when restored, the restored stuff looks like this: 6:24 0x0x100200e30 34?135'52.56" 134?22'78.3" 24th Street and 10th Avenue 0x0x100200f40 35?137'23.456" 133?35'54.12" State street and Cathedral Vista Lane 0x0x1002012c0 35?136'15.456" 133?32'15.3" White House As you can see the name "bob" is missing. The same bug appears with all other saved/restored class instances. I am not fluent in C++ to figure out this, sorry. But maybe this is a bug in the example, I can't determine what is the reason. jacob

2 1

boost::timer elapsed time
by Federico Golfrè Andreasi 31 Mar '10

31 Mar '10

Hi, I've read the post from Roman, and I'm not sure that I've understand. Under linux the timer.elapsed() function will not return the total time needed to do all the operations but only the CPU time, this excludes network communication in parallel programs, time spent for I/O operations ? For example if I need to measure the time needed to read an input file I should not use the timer library? What else? Thank you, Federico

3 2