Performance issue with vectors - c++

Question

I am using a couple of structs in my code. The first struct is constructed after reading data from a line of text file and the second struct contains a vector of structs of the first kind.
struct A{
long a, b, c, d, e, f;
string x, y, z;
}
struct B{
string id1;
vector<A> aVec;
}
Now I read my file and initialize a vector of struct B's. Then based on what the incoming new line's id1 and id2 are, I create a new A and push it into the correct B.
vector<B> bVec;
vector<A> atmpVec;
B btmp;
//Initializing bVec
for(int i = 0; i < 7; i++)
{
btmp.id1 = "c"+to_string(i);
btmp.aVec = atmpVec;
//tried using reserve too.
//btmp.aVec.reserve(50000);
bVec.push_back(btmp);
}
//readerCode
while(getline(file, line))
{
A = readA(line); //readA reads and sets the fields of struct A.
int idx = getBIdx(bVec, A); //getBIdx returns which B struct should i be using.
bVec[idx].aVec.push_back(A);
}
Now the last line has become a bottleneck. If I simply declare a vector of A and keep on pushing back to it, the time taken to process a million records is ~10 seconds.
On the other hand, with this approach, it takes 60 seconds to just process 50k records.
Is there a way I can keep the above general structure without losing the performance.
Any ways to efficiently implement this?

Answer 1

Isn't the time spent in the getBIdx method ? Pushing to a single vector or one between N should be almost the same.
Trying with a simple getBIdx:
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
#include <time.h>
using namespace std;
const int NUMBER_OF_A = 3E7;
const int NUMBER_OF_B = 7;
struct A {
long a, b, c, d, e, f;
string x, y, z;
};
struct B {
string id1;
vector<A> aVec;
};
struct A readA() {
A a;
a.a = 1;
a.b = 2;
return a;
}
int getBIdx(const A& a) {
return rand() % NUMBER_OF_B;
}
void Test1() {
vector<B> bVec;
for(int i = 0; i < NUMBER_OF_B; i++) {
B btmp;
bVec.push_back(btmp);
}
for(int i = 0; i < NUMBER_OF_A; ++i) {
A a = readA();
int idx = getBIdx(a);
bVec[idx].aVec.push_back(a);
}
}
void Test2() {
vector<A> vector;
for(int i = 0; i < NUMBER_OF_A; ++i) {
A a = readA();
int idx = getBIdx(a);
vector.push_back(a);
}
}
int main() {
time_t start = time(0);
Test1();
time_t end_of_test1 = time(0);
Test2();
time_t end_of_test2 = time(0);
cout << "Elapsed test 1:" << end_of_test1 - start << " s" << endl;
cout << "Elapsed test 2:" << end_of_test2 - end_of_test1 << " s" << endl;
return 0;
}
Result: (old Pentium 4 single core machine)
Elapsed test 1:17 s
Elapsed test 2:13 s
So it's slower but not that slower.
With -O3 the difference is even smaller:
Elapsed test 1:9 s
Elapsed test 2:7 s

Answer 2

I　would try to optimize this code in two ways
define vector<A*> aVec instead of vector<A> aVec, to avoid copy constructor call ,since you are using C++0x
estimate the size of size of aVec in B, using resize() to resever some space might save some time

Answer 3

You should probably using the sizing constructor on bVec as it's size is known.
Then for the main culprit of filling it with vector of A, you probably
want to use vector::reserve on each avec inside bVec with an arbitrary size depending on your number of data to be fed.
Also, are you sure you compile with -O3 ?