“if”语句对性能有多大影响？

Posted 2023-02-16

【中文标题】“if”语句对性能有多大影响？

【英文标题】：How much "if" statements effect on performance?

【发布时间】：2016-08-20 13:48:11

【问题描述】：

有一些不同大小的 IPTables（例如 255 或 16384 或 512000！！）。每个表的每个条目都包含一个唯一的 IP 地址（十六进制格式）和一些其他值。 IP总数为800万。 所有IPTable的所有IP都排序

我们需要每秒搜索 IPTable 300,000 次。我们目前寻找IP的算法如下：

// 10 <number of IPTables <20
//_rangeCount = number of IPTables 
s_EntryItem* searchIPTable(const uint32_t & ip) 
        for (int i = 0; i < _rangeCount; i++) 
            if (ip > _ipTable[i].start && ip < _ipTable[i].end) 
                int index = ip - _ipTable[i].start;
                    return (_ipTable[i].p_entry + index);
                
            
            return NULL;
        

可以看出，在最坏的情况下，给定 IP 地址的比较次数为 _rangeCount *2，“if”语句检查的次数为 _rangeCount。

假设我想更改 searchIPTable 并使用更有效的方法在 IPTables 中查找 IP 地址。据我所知，对于排序数组，著名搜索算法（如二分搜索）的最佳软件实现需要 log(n) 比较（在最坏的情况下）。

因此，查找 IP 地址的比较次数是 log(8000000)，等于 ~23。

问题一：

可以看出，两种算法（_rangeCount 与 23）所需的比较次数之间存在少许差距，但在第一种方法中，有一些“if”语句可能会影响性能。如果你想运行第一个算法 10 次，显然第一个算法具有更好的性能，但我知道运行两个算法 3000,000 次的想法！你的想法是什么？

问题2：

是否有更高效的算法或解决方案来搜索 IP？

【问题讨论】：

查找数据结构，例如树、二进制搜索等。它们可能会帮助您加快算法速度。

暴力搜索总是很慢。排序，并使用二进制印章，或使用树结构，或按第一个字节对您的 IP 地址进行半散列，并且仅在其中搜索。除了蛮力搜索之外的任何东西。那是你的问题，而不是 if 语句的小优化。

"log(8000000) that is equal to ~29000" 你是怎么得到这个数字的？ log2(8000000) = ~23.

基数树通常用于 IP 查找。

之前已经完全做到了...您将需要使用二进制搜索。排序数组上的lower_bound 将是最快的可移植方法。您还可以使用 SIMD 搜索 btree 以获得更多性能：***.com/a/20617359/209199

【参考方案1】：

好奇心被激起，我编写了一个测试程序（如下）并在我的 macbook 上运行它。

这表明基于std::unordered_map（查找时间 == 恒定时间）的简单解决方案能够以每秒 560 万次的速度搜索包含 800 万个条目的 ip4 地址表。

这很容易超过要求。

更新：回应我的批评，我已将测试空间增加到所需的 8m ip 地址。我还将测试规模增加到 1 亿次搜索，其中 20% 将成为热门搜索。

通过这么大的测试，我们可以清楚地看到使用 unordered_map 与有序映射（对数时间查找）相比的性能优势。

所有测试参数均可配置。

#include <iostream>
#include <vector>
#include <algorithm>
#include <chrono>
#include <unordered_map>
#include <unordered_set>
#include <map>
#include <random>
#include <tuple>
#include <iomanip>
#include <utility>

namespace detail

    template<class T>
    struct has_reserve
    
        template<class U> static auto test(U*p) -> decltype(p->reserve(std::declval<std::size_t>()), void(), std::true_type());
        template<class U> static auto test(...) -> decltype(std::false_type());

        using type = decltype(test<T>((T*)0));
    ;


template<class T>
using has_reserve = typename detail::has_reserve<T>::type;


using namespace std::literals;

struct data_associated_with_ip ;
using ip_address = std::uint32_t;

using candidate_vector = std::vector<ip_address>;

static constexpr std::size_t search_space_size = 8'000'000;
static constexpr std::size_t size_of_test = 100'000'000;

std::vector<ip_address> make_random_ip_set(std::size_t size)

    std::unordered_set<ip_address> results;
    results.reserve(size);

    std::random_device rd;
    std::default_random_engine eng(rd());
    auto dist = std::uniform_int_distribution<ip_address>(0, 0xffffffff);
    while (results.size() < size)
    
        auto candidate = dist(eng);
        results.emplace(candidate);
    

    return  std::begin(results), std::end(results) ;


template<class T, std::enable_if_t<not has_reserve<T>::value> * = nullptr>
void maybe_reserve(T& container, std::size_t size)

    // nop


template<class T, std::enable_if_t<has_reserve<T>::value> * = nullptr>
decltype(auto) maybe_reserve(T& container, std::size_t size)

    return container.reserve(size);


template<class MapType>
void build_ip_map(MapType& result, candidate_vector const& chosen)

    maybe_reserve(result, chosen.size());
    result.clear();

    for (auto& ip : chosen)
    
        result.emplace(ip, data_associated_with_ip);
    


// build a vector of candidates to try against our map
// some percentage of the time we will select a candidate that we know is in the map
candidate_vector build_candidates(candidate_vector const& known)

    std::random_device rd;
    std::default_random_engine eng(rd());
    auto ip_dist = std::uniform_int_distribution<ip_address>(0, 0xffffffff);
    auto select_known = std::uniform_int_distribution<std::size_t>(0, known.size() - 1);
    auto chance = std::uniform_real_distribution<double>(0, 1);
    static constexpr double probability_of_hit = 0.2;

    candidate_vector result;
    result.reserve(size_of_test);
    std::generate_n(std::back_inserter(result), size_of_test, [&]
                    
                        if (chance(eng) < probability_of_hit)
                        
                            return known[select_known(eng)];
                        
                        else
                        
                            return ip_dist(eng);
                        
                    );

    return result;



int main()


    candidate_vector known_candidates = make_random_ip_set(search_space_size);
    candidate_vector random_candidates = build_candidates(known_candidates);


    auto run_test = [&known_candidates, &random_candidates]
    (auto const& search_space)
    

        std::size_t hits = 0;
        auto start_time = std::chrono::high_resolution_clock::now();
        for (auto& candidate : random_candidates)
        
            auto ifind = search_space.find(candidate);
            if (ifind != std::end(search_space))
            
                ++hits;
            
        
        auto stop_time = std::chrono::high_resolution_clock::now();
        using fns = std::chrono::duration<long double, std::chrono::nanoseconds::period>;
        using fs = std::chrono::duration<long double, std::chrono::seconds::period>;
        auto interval = fns(stop_time - start_time);
        auto time_per_hit = interval / random_candidates.size();
        auto hits_per_sec = fs(1.0) / time_per_hit;

        std::cout << "ip addresses in table: " << search_space.size() << std::endl;
        std::cout << "ip addresses searched: " << random_candidates.size() << std::endl;
        std::cout << "total search hits    : " << hits << std::endl;
        std::cout << "searches per second  : " << std::fixed << hits_per_sec << std::endl;
    ;

    
        std::cout << "building unordered map:" << std::endl;
        std::unordered_map<ip_address, data_associated_with_ip> um;
        build_ip_map(um, known_candidates);
        std::cout << "testing with unordered map:" << std::endl;
        run_test(um);
    

    
        std::cout << "\nbuilding ordered map  :" << std::endl;
        std::map<ip_address, data_associated_with_ip> m;
        build_ip_map(m, known_candidates);
        std::cout << "testing with ordered map  :" << std::endl;
        run_test(m);
    

示例结果：

building unordered map:
testing with unordered map:
ip addresses in table: 8000000
ip addresses searched: 100000000
total search hits    : 21681856
searches per second  : 5602458.505577

building ordered map  :
testing with ordered map  :
ip addresses in table: 8000000
ip addresses searched: 100000000
total search hits    : 21681856
searches per second  : 836123.513710

测试条件：

MacBook Pro (Retina, 15-inch, Mid 2015)
Processor: 2.2 GHz Intel Core i7
Memory: 16 GB 1600 MHz DDR3
Release build (-O2)

使用主电源运行。

【讨论】：

喜欢这种方法。

@ncke 在性能测试中，实验数据是唯一的真理。在我的观察中，几乎总是有一个 std 容器会胜过任何本土算法。通常在这类问题中，下一个问题是“我应该让它无锁吗？”。同样，答案几乎总是“不”。

如果我没记错的话，表中应该有8M的地址，而不是300k。我测试了 C# Dictionary 并获得了每秒 1100 万次搜索，散列方法应该足够快。

@RichardHodges 喜欢你的工作，但看看上面的评论！

【参考方案2】：

在这种情况下，确定最快实现的唯一实用方法是实现这两种方法，然后对每一种方法进行基准测试。

而且，有时，这样做比尝试找出哪个更快。而且，有时，如果你这样做，然后继续你选择的方法，你会发现你错了。

【参考方案3】：

看起来您的问题不是if 语句的性能成本，而是哪种数据结构可以回答“您是否包含此元素？”这个问题。尽可能快。如果这是真的，那么使用Bloom Filter 怎么样？

提供快速查找（比对数复杂度更快）的数据结构是哈希表，其平均复杂度为 O(1)。在Boost.Unordered 中实现了一种这样的实现。

【讨论】：

这不是答案，请改用评论

问题的第二部分是“有没有更高效的算法或解决方案来搜索IP？” - 我想我实际上已经提供了答案。

我的评论是在您编辑答案之前添加 "second part" 。无论如何，关于哈希表有不同的考虑。

【参考方案4】：

当然，您需要使用真实数据进行测试……但考虑到 IPV4，我会先尝试一种不同的方法：

EntryItem* searchIPTable(uint32_t ip) 
    EntryItem** tab = master_table[ip >> 16];
    return tab ? tab[ip & 65535] : NULL;

换句话说，一个包含 65536 个条目的主表是指向每个包含 65536 个条目的详细表的指针。

根据数据类型，不同的细分而不是 16+16 位可能会更好（更少的内存）。

将详细信息页面直接作为 IP 条目而不是指向条目的指针也是有意义的。