Boost logo

Boost Users :

From: Trent Hill (trent.hill_at_[hidden])
Date: 2005-01-06 18:20:14

Hi Peter,

Peter Dimov wrote:


>> Four copies - I had hoped to only see a single copy. Logically, there
>> doesn't seem to be a need for more than one copy. Is there an
>> implementation issue that requires this many copies?
> Not really, but eliminating the unnecessary copies is (relatively) hard,
> at least with the current code base (it has been developed with
> portability in mind and supports VC6, among others). The specification
> requires one copy. One more is almost unavoidable. The other two can be
> eliminated, in theory. But...

Ok, thanks. Out of interest, is there a simple explanation for why one
more is almost unavoidable.


> ... please note that the copies occur at bind time. In a typical
> scenario you bind once and call O(N) times (or bind and store in a
> function<> with the associated dynamic memory allocation), so this isn't
> usually a problem. And, as others have pointed out, there's always
> ref(). ;-)

Yes I understand. I guess I'm not using bind typically ;-)

FYI and for those suggesting boost::ref, the actual case is using bind
for message passing between threads. I have a polymorphic wrapper for
bind something like this:

     class bind_wrapper
         virtual void execute() = 0;

     template <typename binder_t>
     class bind_wrapper_impl : public bind_wrapper
         bind_wrapper_impl(const binder_t &binder_a)
             : binder_m(binder_a)
         virtual void execute()
         binder_t binder_m;

     template <typename binder_t>
     make_bind_wrapper(const binder_t &binder_a)
         return std::auto_ptr<bind_wrapper>(
             new bind_wrapper_impl<binder_t>(binder_a));

Now the idea is that certain functions transparently transfer work to a
worker thread. So for such a function "foo", there would be an internal
implementation function:

     void foo_impl(const std::string &string_a)
         // do stuff

and a public proxy that requests foo_impl to be called on the worker thread:

     future foo_async(const std::string &arg_a)
         std::auto_ptr<bind_wrapper> message_l(
             make_bind_wrapper(boost::bind(&foo_impl, arg_a)));
         // add message_l to message queue and return future to allow
         // rendezvous

The worker thread will collect this message and call execute(),
something like:

     void worker_thread()
         // retrieve from message queue and execute
         std::auto_ptr<bind_wrapper> message_l = ...

So, in this case:
   1. Yes, a copy is required - boost::ref is not appropriate.
   2. Each bind corresponds to a single call (not O(N) calls)

We have a home grown solution (less general than bind of course)
requiring only a single copy. I was hoping to replace it with bind but
it's hard to justify adding the extra argument copies.

Thanks for the info though,
Cheers, Trent.

Boost-users list run by williamkempf at, kalb at, bjorn.karlsson at, gregod at, wekempf at