Question

我正在试图弄清楚如何编写一个针对ASCII优化的非常快速is_iequal函数，以便在不区分大小写的情况下比较两个字符是否相等。

最终目标是将此仿函数与boost::algorithm::starts_with等一起使用

到目前为止，我的尝试产生了以下结果：

#include <locale>
unsigned long fast_rand(void);

template<class Ch> struct is_iequal
{
    std::ctype<Ch> const &ctype;
    is_iequal(std::ctype<Ch> const &ctype) : ctype(ctype) { }
    bool operator()(Ch const c1, Ch const c2) const
    {
        return c1 == c2 ||
            ('a' <= c1 && c1 <= 'z' && c1 - 'a' == c2 - 'A') ||
            ('A' <= c1 && c1 <= 'Z' && c1 - 'A' == c2 - 'a') ||
            !(c1 <= '\x7F' && c2 <= '\x7F') &&
            ctype.toupper(c1) == ctype.toupper(c2);
    }
};

int main()
{
    size_t const N = 1 << 26;
    typedef wchar_t TCHAR;
    std::locale loc;
    std::ctype<TCHAR> const &ctype = std::use_facet<std::ctype<TCHAR> >(loc);
    is_iequal<TCHAR> const is_iequal(ctype);  // Functor

    TCHAR *s1 = new TCHAR[N], *s2 = new TCHAR[N];
    for (size_t i = 0; i < N; i++) { s1[i] = fast_rand() & 0x7F; }
    for (size_t i = 0; i < N; i++) { s2[i] = fast_rand() & 0x7F; }

    bool dummy = false;
    clock_t start = clock();
    for (size_t i = 0; i < N; i++) { dummy ^= is_iequal(s1[i], s2[i]); }
    printf("%u ms\n", (clock() - start) * 1000 / CLOCKS_PER_SEC, dummy);
}

unsigned long fast_rand(void)  // Fast RNG for testing (xorshf96)
{
    static unsigned long x = 123456789, y = 362436069, z = 521288629;

    x ^= x << 16;
    x ^= x >> 5;
    x ^= x << 1;

    unsigned long t = x;
    x = y;
    y = z;
    z = t ^ x ^ y;

    return z;
}

，在我的计算机上，运行时间为584毫秒（VC ++ 2011 x64）。

虽然我的应用程序仍然有点太慢 - 但它仍然是我实际程序中的瓶颈，如果可能的话，会导致轻微的UI延迟。

如何在不更改界面的情况下进一步优化is_iequals？

注意：是的，我我了解此代码存在的各种问题（UTF-16处理，与{{1}隐式转换的迂腐C ++问题等等......）但它们与我的目标无关，所以我暂时完全无视它们。

Answer 1

考虑为c<127内联更少 - 内存成本足够小，可以在缓存中，但速度可能更好：

char localToLow[128] =....
return c1 < 127 && c2 < 127 ? localToLow[c1]==localToLow[c2] :
    ctype.toupper(c1) == ctype.toupper(c2);

（＆lt; 127可以替换为（（c1 | c2）＆amp; ~127）:)）

Answer 2

@Mysticial的评论以及一些调整确实似乎有所帮助。

首先我尝试了这个：

template<class Ch>
struct is_iequal
{
    std::ctype<Ch> const &ctype;
    is_iequal(std::ctype<Ch> const &ctype) : ctype(ctype) { }
    bool operator()(Ch const a, Ch const b) const
    {
        return a == b ||
            ('a' <= a && a <= 'z' || 'A' <= a && a <= 'Z') &&
            (a & ~('a' - 'A')) == (b & ~('a' - 'A')) ||
            a > SCHAR_MAX && b > SCHAR_MAX &&
            ctype.toupper(a) == ctype.toupper(b);
    }
};

这没多大帮助，但后来我想，嘿，为什么不交换&&的双方？

template<class Ch>
struct is_iequal
{
    std::ctype<Ch> const &ctype;
    is_iequal(std::ctype<Ch> const &ctype) : ctype(ctype) { }
    bool operator()(Ch const a, Ch const b) const
    {
        return a == b ||
            (a & ~('a' - 'A')) == (b & ~('a' - 'A')) &&
            ('a' <= a && a <= 'z' || 'A' <= a && a <= 'Z') ||
            a > SCHAR_MAX && b > SCHAR_MAX &&
            ctype.toupper(a) == ctype.toupper(b);
    }
};

这让它降到了138毫秒！

Answer 3

128x128查找表。始终执行此查找（屏蔽输入）。

这会将你的分支减少到一个（你打电话给鞋帮吗？）。计算那个没有做＆amp;＆amp;或|| - 使用无分支逻辑。

也许使表格成为一个整数字节。还可以尝试使用更严格的查找表，在这里您可以使用bit twiddling提取查找，并且更多地使用twiddling来确定它是否被抛出并改为使用==。 (a&b)|(c&~b)是b?a:c，没有分支。

分支预测失败很糟糕。

在试验和测试后选择表格大小。

所以我的表是bool equal[128][128] = {…} - 不是查找然后是相等的，而只是查找。

Answer 4

如果我更换，我的结果会更快：

('a' <= a && a <= 'z' || 'A' <= a && a <= 'Z') ||

...来自你的回答：

(unsigned char)((a & 0x20) - 'A') < 26 ||

a & 0x20会崩溃到大写（它也会影响其他一些字符，但我们会在一秒内将它们屏蔽掉）。如果折叠值小于'A'，则减去A然后会生成负数。转换为无符号会减少模UCHAR_MAX（通常为255），因此负数会变为大的正数。然后只进行一次测试，我们发现是否以大写或小写字母开头。

Answer 5

我的回答是在C中，但也许它对你有用......

在编写更快（~3x）tolower函数的过程中，我还在三台不同的机器上测试了各种形式的不区分大小写的ascii字符相等。这是我能获得的最快速度，令人惊讶的是，它比基于整数的位操作略快：

uint8_t is_eq_bsc(char c, char i){
    c |= (c | ' ');
    i |= (i | ' ');
    return c == i;
}

这是三个不同机器上基准测试的要点和我测试的各种代码： https://gist.github.com/benwills/5170f2e6adbb67e3ec4c

非常快is_iequal？（不区分大小写的相等比较）

5 个答案:

非常快is_iequal？ （不区分大小写的相等比较）

5 个答案:

非常快is_iequal？（不区分大小写的相等比较）