c++ array accessing program doesn't scale - c++

Question

I have a short piece of code which does the following thing:
Accessing an array of struct (vec1) sequentially
Accessing to an int array (hashT) randomly according to the value got from the struct array
Modifying the values of the struct array using the value got from the int array.
I ran the program on 8 physical cpus on the same numa node. But with hashT of size 5M (i.e. there are 5M ints in it) I only got x7.2 speedup. I changed the size of hashT and saw that when it's small, I got x7.9 speedup, but as it grows larger and at some point (when there are 3M ints in the array) the speedup starts to drop down. I have a 200GB RAM so memory should not be a problem. I also measured the memory bandwidth and I'm nowhere near a half of the maximal available bandwidth. So I thought that it might be due of contention of cache. I have a 20MB L3 cache which is shared by all threads. But I measured the L2 and L3 cache misses and I found that they are almost the same no matter how many threads I use (it is true that increasing the size of hashT causes more cache misses, though). So I don't see any reasons why the speedup drops. Can anybody give me an idea?
#include<iostream>
#include<vector>
#include<chrono>
#include<omp.h>
#include<stdio.h>
using namespace std;
typedef std::chrono::milliseconds ms;
struct Element{
int a, b, c;
Element() : a(0), b(1), c(2) {}
Element(int aa, int bb, int cc) : a(aa), b(bb), c(cc) {}
};
int main(int argc, char *argv[]){
int HASHT_SIZE = atoi(argv[1]);
int RID_SIZE = 5000000;
auto start = std::chrono::high_resolution_clock::now();
auto end = std::chrono::high_resolution_clock::now();
vector<vector<Element> > vec1(40);
for(size_t i = 0; i < vec1.size(); i++){
vec1[i].reserve(RID_SIZE);
for(size_t j = 0; j < vec1[i].capacity(); j++){
vec1[i].push_back(Element(rand() % HASHT_SIZE,0,0));
}
}
//initialize hashT
vector<int> hashT;
hashT.reserve(HASHT_SIZE);
for(int i = 0; i < HASHT_SIZE; i++){
hashT.push_back(rand() % 2);
}
start = std::chrono::high_resolution_clock::now();
//test program
#pragma omp parallel for schedule(dynamic)
for(int j = 0; j < 40; j++)
{
for(size_t i = 0; i < RID_SIZE; i++){
int nid = hashT[vec1[j][i].a];
for(int k = 0; k < 10; k++){
vec1[j][i].b += nid / (k+1);
vec1[j][i].c += nid / (k+1);
}
}
}
end = std::chrono::high_resolution_clock::now();
for(int i = 0; i < 40; i++){
for(int j = 0; j < 10; j++){
cout << vec1[i][j].a << vec1[i][j].b << vec1[i][j].c;
}
}cout << endl;
cout << "Time used: " << std::chrono::duration_cast<ms>(end - start).count() << endl;
return 0;
}