how to speed up map insertion? [closed] - c++11

Question

Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 3 years ago.
Improve this question
Looks like I finally improved a little map insertion speed (sorting before inserting). What do you think about these results ? Are there anymore optimisations ?
#include <map>
#include <iostream>
#include <algorithm>
int main (int argc, char* argv []) {
//a map<size_t, size_t> random initilisation
std::map<size_t, size_t> m0, m1;
{
std::vector<std::pair<size_t, size_t> > t (10000, std::pair<size_t, size_t> ((size_t) -1, (size_t) -1));
std::vector<std::pair<size_t, size_t> >::iterator i (t.begin ());
for (; i != t.end (); ++i) {
i->first = rand () % 1000000;
i->second = rand () %1;
}
m0.insert (t.begin (), t.end ());
m1 = m0;
}
//vins :
std::vector<std::pair<size_t, size_t> > vins (10000, std::pair<size_t, size_t> (0, 0));
{
std::vector<std::pair<size_t, size_t> >::iterator i (vins.begin ());
for (; i != vins.end (); ++i) {
i->first = rand () % 1000000;
i->second = rand () %1;
}
}
//normal insertion
clock_t t0 (clock ()), t1 (t0);
{
m0.insert (vins.begin (), vins.end ());
}
t1 = clock ();
std::cout << "normal insertion took " << (size_t) (t1 - t0) << " ticks" << std::endl;
//sort + hint insertion
t0 = t1;
{
std::sort (vins.begin (), vins.end (), [] (std::pair<size_t, size_t>& p0, std::pair<size_t, size_t>& p1)->bool {
return (p0.first < p1.first ? true:false);
});
std::map<size_t, size_t>::iterator ihint (m1.begin ());
//std::vector<std::pair<size_t, size_t> >::iterator i (vins.begin ());
//imroved and more C++11 solution
std::for_each (vins.begin (), vins.end (), [&ihint, &m1] (std::pair<size_t, size_t>& p) {
ihint = m1.insert (ihint, p);
});
}
t1 = clock ();
std::cout << "insertion after sorting took " << (size_t) (t1 - t0) << " ticks" << std::endl;
if (m0 != m1) std::cout << "but insertion is nok" << std::endl;
else std::cout << "and insertion is ok" << std::endl;
}
A result on a Lenovo Think Centre :
insertion took 2355 ticks
sort then insertion took 1706 ticks
and insertion is ok

Answer 1

If you don't need your items to be ordered, then using std::unordered_map is usually a better choice than std::map - it uses a hashtable rather than a balanced tree in most implementations, which means that operations are on average O(1) rather than O(log n). In addition, it can have a performance boost from cache-locality, as the underlying data structure (array) is usually more cache-friendly than a tree.
Enabling -O3 (or similar optimisation level) might increase the performance of your code, but is unlikely to effect the performance of the map's insertion/find operations (as it's already been compiled). Bear in mind that using -Ofast means the compiler no longer needs to strictly adhere to the standards, which is usually not a great idea - use it if performance is critical and you've checked your code works as expected with it, but usually -O3 is enough.
On my machine (Debian, g++ 6.3.0), using a few runs and taking rough averages:
Configuration Normal Hint Insertion Hint Insertion
------------------------- ----------------------- ----------------
std::map, -O0 9750 9200
std::map, -O3 8000 4250
std::unordered_map, -O0 7000 9700
std::unordered_map, -O3 4200 5000