Question

I just started implementing my own vector class and i’m testing it with a simple file to check the time it takes to finish. One test took 2:30 minutes while the others took 90 and 29 seconds.

Something is hitting the performance of this class. Can you help me trace the source?

The test:

#include "MyVector.h"

const unsigned int SIZE_V= 1000000;
const unsigned int RUNS= 10000;

int main() {

      MyVector v(SIZE_V);

      for (unsigned int j=0; j<RUNS; ++j) {
        for (unsigned int i=0; i<SIZE_V; ++i) {
          v[i]= i;
        }
      }

      return 0;
}

The class:

MyVector.h:

#ifndef MY_VECTOR_H
#define MY_VECTOR_H

class MyVector {

 public:

      MyVector(unsigned int size);
      ~MyVector();

      int& operator[](unsigned int i);

 private:
      int* _data;
      unsigned int _size;
      MyVector(const MyVector&);
      MyVector& operator=(const MyVector&);

};
#endif

MyVector.cpp:

#include "MyVector.h"
#include <assert.h>

MyVector::MyVector(unsigned int size) : _data(new int[size]) {
}

MyVector::~MyVector() {
      delete[] _data;
}

int& MyVector::operator[](unsigned int i) {
      assert(i<_size);
      return _data[i];
}

EDIT:

These are the test results:

granularity: each sample hit covers 4 byte(s) for 0.04% of 27.09 seconds

index % time    self  children    called     name
                                                 <spontaneous>
[1]    100.0   12.51   14.58                 main [1]
               11.28    0.00 1410065408/1410065408     MyVector::operator[](unsigned int) [2]
                3.31    0.00       1/1           MyVector::~MyVector() [3]
                0.00    0.00       1/1           MyVector::MyVector(unsigned int) [7]
-----------------------------------------------
               11.28    0.00 1410065408/1410065408     main [1]
[2]     41.6   11.28    0.00 1410065408         MyVector::operator[](unsigned int) [2]
-----------------------------------------------
                3.31    0.00       1/1           main [1]
[3]     12.2    3.31    0.00       1         MyVector::~MyVector() [3]
-----------------------------------------------
                0.00    0.00       1/1           main [1]
[7]      0.0    0.00    0.00       1         MyVector::MyVector(unsigned int) [7]
-----------------------------------------------

Answer 1

One thing you might want to do is make operator[] inline. When I do this, the performance of your code on my box improves threefold from

real    0m18.270s

to

real    0m6.030s

In the latter test, each iteration of the test loop takes about 0.6ns (!) or about 1.5 clock cycles.

This is on a Sandy Bridge box using g++ 4.7.2 with -O3.

P.S. There’s a bug in the code: the constructor doesn’t initialize _size, so the assert() has undefined behaviour.