absl::flat_hash_map is much slower than std::unordered_map

[fancyerii]

I want to replace std::unordered_map with absl::flat_hash_map to speed up traverse all key/value pairs. But when I replace std::unordered_map with absl::flat_hash_map, it's much slower. I think there is something wrong. Here is my codes where absl::flat_hash_map is used.

1. load map from json

struct pair_hash {
    template <class T1, class T2>
    std::size_t operator () (const std::pair<T1,T2> &p) const {
        auto h1 = std::hash<T1>{}(p.first);
        auto h2 = std::hash<T2>{}(p.second);
        // borrow from boost
        return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
        
    }
};

absl::flat_hash_map<std::pair<int, int>, int, pair_hash> read_pair_counts(std::string dir){
    std::ifstream f(dir + "/pair_counts.json");
    json data = json::parse(f);
    absl::flat_hash_map<std::pair<int, int>, int, pair_hash> pair_counts;
    for (auto const& [key, val] : data.items()) {
        auto const key_vec = split_string_to_ints(key, ",");
        std::pair<int, int> pair {key_vec[0], key_vec[1]};
        pair_counts[pair] = int(val);
    }
    return pair_counts;
}

2. use it in main loop.
   I only use absl::flat_hash_map this way:

pair_counts[old_pair] -= wc; 
pair_counts.erase(old_pair); 
pair_counts[new_pair] += wc;

the following is related codes:

    for(int wordid : affected_words_copy){
        const auto& word_tokens = wordid_encodings[wordid];
        auto& wc = wordid_counts.at(wordid);

        const int token_size = word_tokens.size();
        for(int i = 0; i < token_size - 1; ++i){
            std::pair<int, int> old_pair(word_tokens[i], word_tokens[i + 1]);
            auto update_start = std::chrono::steady_clock::now(); 
            pair_counts[old_pair] -= wc;
            // auto it = pair_counts.find(old_pair);
            // if (it != pair_counts.end()) {
            //     it->second -= wc;
            // }else{
            //     std::cout << "bug: " << old_pair.first << ", " << old_pair.second << std::endl;
            // }
            auto update_end = std::chrono::steady_clock::now(); 
            pair_counts_update_time += (update_end - update_start);
            if(pair_counts[old_pair] <= 0){
                auto erase_start = std::chrono::steady_clock::now(); 
                pair_counts.erase(old_pair);
                auto erase_end = std::chrono::steady_clock::now(); 
                pair_counts_erase_time += (erase_end - erase_start);
            }else{

            }
        }

        int i = 0;
        std::vector<int> new_tokens;
        // code omitted.
        const int new_tokens_size = new_tokens.size();
        
        
        for(int i = 0; i < new_tokens_size - 1; ++i){
            std::pair<int, int> new_pair(new_tokens[i], new_tokens[i + 1]);
            auto update_start = std::chrono::steady_clock::now();
            pair_counts[new_pair] += wc;
            // auto [it, inserted] = pair_counts.try_emplace(new_pair, wc);
            // if (!inserted) {
            //     
            //     it->second += wc;
            // }
            auto update_end = std::chrono::steady_clock::now();
            pair_counts_update_time2 += (update_end - update_start);
        }

    }

3. time comparision(flat_hash_map vs unordered_map)
   update time: 2534ms vs 1213ms
   iterate through all key/value: 9802ms vs 8211ms

the iterate code:

for(const auto& [pair, count] : pair_counts){
    // do something with pair, count
}

[fancyerii]

close