Function perf_insert_erase

test/flat_map_unittest.cpp:1211–1378

template <typename T>
void perf_insert_erase(bool random, const T& value) {
    size_t nkeys[] = { 100, 1000, 10000 };
    const size_t NPASS = ARRAY_SIZE(nkeys);

    std::vector<uint64_t> keys;
    butil::FlatMap<uint64_t, T> id_map;
    butil::MultiFlatMap<uint64_t, T> multi_id_map;
    std::map<uint64_t, T> std_map;
    butil::PooledMap<uint64_t, T> pooled_map;
    std::unordered_map<uint64_t, T> std_unordered_map;
    std::unordered_multimap<uint64_t, T> std_unordered_multimap;
    butil::hash_map<uint64_t, T> hash_map;
    butil::Timer id_tm, multi_id_tm, std_tm, pooled_tm,
                 std_unordered_tm, std_unordered_multi_tm, hash_tm;
    
    size_t max_nkeys = 0;
    for (size_t i = 0; i < NPASS; ++i) {
        max_nkeys = std::max(max_nkeys, nkeys[i]);
    }
    id_map.init((size_t)(nkeys[NPASS-1] * 1.5));
    multi_id_map.init((size_t)(nkeys[NPASS-1] * 1.5));

    // Make DS hot
    for (size_t i = 0; i < max_nkeys; ++i) {
        id_map[i] = value;
        std_map[i] = value;
        pooled_map[i] = value;
        hash_map[i] = value;
    }
    id_map.clear();
    std_map.clear();
    pooled_map.clear();
    std_unordered_map.clear();
    std_unordered_multimap.clear();
    hash_map.clear();

    LOG(INFO) << "[ value = " << sizeof(T) << " bytes ]";
    for (size_t pass = 0; pass < NPASS; ++pass) {
        int start = rand();
        keys.clear();
        for (size_t i = 0; i < nkeys[pass]; ++i) {
            keys.push_back(start + i);
        }

        if (random) {
            random_shuffle(keys.begin(), keys.end());
        }

        id_map.clear();
        id_tm.start();
        for (size_t i = 0; i < keys.size(); ++i) {
            id_map[keys[i]] = value;
        }
        id_tm.stop();

        multi_id_map.clear();
        multi_id_tm.start();
        for (size_t i = 0; i < keys.size(); ++i) {