在D语言中比较两块内存的最有效方法是什么？

Question

我需要一个内存块的比较函数，用于对D编程语言中的字节数组进行二进制搜索。 它不需要任何有用的语义。 它只需要很快并且是一个有效的比较函数（产生总排序的函数）。 已知要比较的存储器块具有相同的长度。

C的memcmp实际上非常慢，因为它试图保留有用的字符串比较语义，这是我不需要的。 以下是迄今为止我提出的最佳方法。 有没有人知道更好的事情，最好不要使用非便携式CPU特定指令？

// Faster than C's memcmp because it doesn't preserve any meaningful
// semantics.  It's just a completely arbitrary, but really fast,
// comparison function.
int memoryCompare(const(void)* lhs, const(void)* rhs, size_t n) {
    for(; n >= uint.sizeof; n -= uint.sizeof) {
        if( *(cast(uint*) lhs) < *(cast(uint*) rhs)) {
            return -1;
        } else if( *(cast(uint*) lhs) > *(cast(uint*) rhs)) {
            return 1;
        }
        lhs += uint.sizeof;
        rhs += uint.sizeof;
    }

    for(; n >= ubyte.sizeof; n -= ubyte.sizeof) {
        if( *(cast(ubyte*) lhs) < *(cast(ubyte*) rhs)) {
            return -1;
        } else if( *(cast(ubyte*) lhs) > *(cast(ubyte*) rhs)) {
            return 1;
        }
        lhs += ubyte.sizeof;
        rhs += ubyte.sizeof;
    }

    return 0;
}

编辑：我已阅读SSE，我不想使用它有三个原因：

1. 它不便携。
2. 它需要在ASM中编程。
3. 比较指令假设您的数据是浮点数，如果某些数据恰好与NaN的模式匹配，则可能会出现问题。

Answer 1

你可以尝试：

• 检查uint是否是适合目标CPU的最大类型（ulongs可能更适合本机寄存器）
• 使用该类型的2个指针
• 使用* p ++使用2个局部变量（不要为1个值取消引用指针2次）
• 将第一个循环的计数器放在前面（使用while（counter--））
• 通过用开关替换它来展开第二个循环（如果sizeof（适合寄存器的类型）是已知的并且将始终相同。）

编辑 ：如果第一个循环是瓶颈，展开可能是答案。 结合在相同值的情况下将条件数量减半，为了展开4次，我得到类似的结果：

uint* lp = (uint*)lhs;
uint* rp = (uint*)rhs;
uint  l;
uint  r;
int count = (n / uint.sizeof) / 4;

while (count--) {
    if( (l = *lp++) != (r = *rp++) {
        return (l < r) ? -1 : 1;
    }
    if( (l = *lp++) != (r = *rp++) {
        return (l < r) ? -1 : 1;
    }
    if( (l = *lp++) != (r = *rp++) {
        return (l < r) ? -1 : 1;
    }
    if( (l = *lp++) != (r = *rp++) {
        return (l < r) ? -1 : 1;
    }
}

当然留下了(n / uint.sizeof) % 4次迭代，你可以通过交错开关混合到这个循环中，我把它(n / uint.sizeof) % 4读者邪恶咧嘴的练习。

Answer 2

我不太了解它，但有一些向量指令可以同时对多个字节应用指令。 您可以使用这些结果来执行快速的memcmp。 我不知道您需要哪些说明，但如果您查看Larrabee新说明或查看本文，您可能会找到您要找的内容http://www.ddj.com/architect/216402188

注意：此CPU不是ATM AFAIK

-Edit-现在我肯定有一个指令集（尝试查看SSE或SSE2），如果它们对齐，可以一次比较16个字节。

您可以尝试这个纯c ++代码。

template<class T>
int memoryCompare(const T* lhs, const T * rhs, size_t n) {
    const T* endLHS = lhs + n/sizeof(T);
    while(lhs<endLHS) {
        int i = *lhs - *rhs;
        if(i != 0) return i > 0 ? 1 : -1;
        lhs++;
        rhs++;
    }
    //more code for the remaining bytes or call memoryCompare<char>(lhs, rhs, n%sizeof(T));
    return 0;
}

这里的优点是你增加了指针，所以你可以取消引用它而不应用索引（它的ptr_offset [index] vs ptr_offset）。 以上使用模板，因此您可以在64位计算机上使用64位。 和汇编中的CMP实际上只是减去检查N和Z标志。 而不是比较N和减少N我只是比较我的版本。

Answer 3

我认为memcmp被指定进行逐字节比较，而不管数据类型如何。 您确定编译器的实现保留了字符串语义吗？ 它不应该。

Answer 4

好很多取决于您的系统和数据。 我们可以做出很多假设。 你在用什么处理器？ 它必须是直接的C代码吗？ CPU寄存器有多宽？ CPU的缓存结构是什么？ 等等

它还取决于您的数据有多不同。 如果每个缓冲区的第一个字节不太可能相同，那么函数的速度就毫无意义，因为从逻辑上讲，它不会到达函数的其余部分。 如果前n-1个字节很可能通常是瑕疵，那么它就变得更加重要了。

无论您如何进行测试，所有人都不太可能看到太多变化。

无论如何这是我自己的一个小实现，它可能，或者可能不会比你自己更快（或者，考虑到我刚刚完成它，它可能会，也可能不会工作;））：

int memoryCompare(const void* lhs, const void* rhs, size_t n) 
{
    uint_64 diff    = 0

    // Test the first few bytes until we are 32-bit aligned.
    while( (n & 0x3) != 0 && diff != 0 )
    {
        diff = (uint_8*)lhs - (uint_8*)rhs;
        n--;
        ((uint_8*)lhs)++;
        ((uint_8*)rhs)++;              
        }

    // Test the next set of 32-bit integers using comparisons with
    // aligned data.
    while( n > sizeof( uint_32 ) && diff != 0 )
    {
        diff = (uint_32*)lhs - (uint_32*)rhs;
        n   -= sizeof( uint_32 );
        ((uint_32*)lhs)++;
        ((uint_32*)rhs)++;
    }

    // now do final bytes.
    while( n > 0 && diff != 0 ) 
        {
        diff = (uint_8*)lhs - (uint_8*)rhs;
        n--;
        ((uint_8*)lhs)++;
        ((uint_8*)rhs)++;  
        }

    return (int)*diff / abs( diff ));
}

Answer 5

这个问题的答案对你有帮助吗？

如果编译器支持将memcmp（）实现为内部/内置函数，那么您似乎很难获得它。

我不得不承认对D知之甚少，所以我不知道D编译器是否支持内在函数。

Answer 6

如果您信任编译器的优化，可以尝试对acidzombie24s建议进行一些修改：

template<class T> int memoryCompare(const T* lhs, const T * rhs, size_t n) {
    const T* endLHS = &lhs[n];
    while(lhs<endLHS) {
        //A good optimiser will keep these values in register
        //and may even be clever enough to just retest the flags
        //before incrementing the pointers iff we loop again.
        //gcc -O3 did the optimisation very well.
        if (*lhs > *rhs) return 1;
        if (*lhs++ < *rhs++) return -1;
    }
    //more code for the remaining bytes or call memoryCompare<char>(lhs, rhs, n%sizeof(T));
    return 0;
}

这是上面C版本的x86汇编程序代码中的整个gcc -O3优化内循环，只传递char数组指针：

Loop:
        incl    %eax         ; %eax is lhs
        incl    %edx         ; %edx is rhs
        cmpl    %eax, %ebx   ; %ebx is endLHS
        jbe     ReturnEq
        movb    (%edx), %cl
        cmpb    %cl, (%eax)
        jg      ReturnGT
        jge     Loop
ReturnLT:
        ...