Re: Marshalling deques

On Aug 19, 5:39 pm, Ebenezer <woodbria...@gmail.com> wrote:


Thanks to "Roy Rogers" for pointing out that I wasn't
using a reference here. I've separated the tests now
into two separate mains and also remembered to turn on
-O3 optimization when building.

First, here's the implementation that uses deque iterators:
#include <sys/time.h>
#include <deque>
#include <iostream>
#include <SendBuffer.hh>
#include <Msgs.cg.hh>

int
main()
{
  ::std::deque<int> adeque;

  for (int j = 1; j <= 50000; ++j) {
    adeque.push_back(j);
  }

  SendBuffer sendbuf;
  Msgs msgs(400000);

  struct timezone tz;
  timeval before, after;
  gettimeofday(&before, &tz);

  msgs.Marshal(sendbuf, adeque);
  gettimeofday(&after, &tz);
  if (before.tv_sec != after.tv_sec) {
    after.tv_usec += 1000000;
  }
  ::std::cout << "Using deque iterators: " << after.tv_usec -
before.tv_usec << ::std::endl;
  ::std::cout << "Buf size is " << sendbuf.getBufsize()
<< ::std::endl;
  return 1;
}

The Marshal function hasn't changed and can be found in my
previous post.

And here's the implementation using the insider information:

#include <sys/time.h>
#include <deque>
#include <vector>
#include <iostream>
#include <SendBuffer.hh>

void
optimizedMarshalling(SendBuffer& sendbuf
                     , ::std::deque<int> const& dq
                     , ::std::vector<int> indices
                    )
{
  sendbuf.Receive32(dq.size());
  ::std::vector<int>::const_iterator vprev = indices.begin();
  ::std::vector<int>::const_iterator vit = vprev + 1;
  for (; vit != indices.end(); ++vit) {
    sendbuf.Receive(&dq[*vprev], (*vit - *vprev) * sizeof(int));
    vprev = vit;
  }
  sendbuf.Receive(&dq[*vprev], (dq.size() - *vprev) * sizeof(int));
}

int
main()
{
  ::std::deque<int> adeque;

  for (int j = 1; j <= 50000; ++j) {
    adeque.push_back(j);
  }

  int index = 1;
  ::std::vector<int> indices;
  indices.push_back(0);
  ::std::deque<int>::iterator prev = adeque.begin();
  ::std::deque<int>::iterator it = prev + 1;
  for (; it != adeque.end(); ++it) {
    if (&*it != (&*prev + 1)) {
      indices.push_back(index);
    }
    prev = it;
    ++index;
  }

  SendBuffer sendbuf;
  struct timezone tz;
  timeval before, after;
  gettimeofday(&before, &tz);

  optimizedMarshalling(sendbuf, adeque, indices);
  gettimeofday(&after, &tz);
  if (before.tv_sec != after.tv_sec) {
    after.tv_usec += 1000000;
  }
  ::std::cout << "Optimized approach: " << after.tv_usec -
before.tv_usec << ::std::endl;
  ::std::cout << "Buf size is " << sendbuf.getBufsize()
<< ::std::endl;

  return 1;
}

[gs]# ./dq_iterators ; ./dq_iterators ; ./dq_iterators
Using deque iterators: 315
Buf size is 20004
Using deque iterators: 295
Buf size is 20004
Using deque iterators: 298
Buf size is 20004

[gs]# ./dq_iterators ; ./dq_iterators ; ./dq_iterators
Using deque iterators: 320
Buf size is 20004
Using deque iterators: 338
Buf size is 20004
Using deque iterators: 307
Buf size is 20004

[gs]# ./dq_iterators ; ./dq_iterators ; ./dq_iterators
Using deque iterators: 310
Buf size is 20004
Using deque iterators: 305
Buf size is 20004
Using deque iterators: 304
Buf size is 20004

[gs]# ./insider_info ; ./insider_info ; ./insider_info
Optimized approach: 96
Buf size is 20004
Optimized approach: 88
Buf size is 20004
Optimized approach: 103
Buf size is 20004

[gs]# ./insider_info ; ./insider_info ; ./insider_info
Optimized approach: 87
Buf size is 20004
Optimized approach: 94
Buf size is 20004
Optimized approach: 84
Buf size is 20004

[gs]# ./insider_info ; ./insider_info ; ./insider_info
Optimized approach: 100
Buf size is 20004
Optimized approach: 96
Buf size is 20004
Optimized approach: 101
Buf size is 20004

The deque iterator approach is over 3 times slower than
the approach that gets help from the deque. I believe
there's good reason to add a function to deque's interface
to assist in marshalling.