Question

我需要使用xlC_r编译器在AIX（64位）下对这样的结构数组进行排序：

struct digest_line {
    uint64_t first;
    uint64_t second;
};

现在我正在做很长的事情（比较第一个元素，如果它们相等，则比较第二个元素。）是否有更快的方法来比较这些值？

编辑：我忘了提到我正在使用AIX的qsort()功能。根据{{1}}的手册页，比较函数定义为

qsort

（对我来说）意味着我不能只返回int (*ComparisonPointer)(const void*, const void*);值，而是这样：

int64_t

这看起来不是...... 正确。我一直认为必须有更好的方法。

Answer 1

您的代码存在问题，因为您正在对未签名的数据进行签名比较。使用以下替代方案之一：

更正统

这快得多。

int compare_digests(const void *a, const void *b)
{
        const struct digest_line *aa = (const struct digest_line *) a;
        const struct digest_line *bb = (const struct digest_line *) b;

        if (aa->first > bb->first)
            return +1;
        else if (aa->first < bb->first)
            return -1;
        else if (aa->second > bb->second)
            return +1;
        else if (aa->second < bb->second)
            return -1;
        else
            return 0;
}

不太正统

这明显慢了;不要使用它。

int compare_digests(const void *a, const void *b)
{
        struct digest_line aa = *(struct digest_line *) a;
        struct digest_line bb = *(struct digest_line *) b;

        if (aa.first > bb.first)
            return +1;
        else if (aa.first < bb.first)
            return -1;
        else if (aa.second > bb.second)
            return +1;
        else if (aa.second < bb.second)
            return -1;
        else
            return 0;
}

时序

经过一些测量后，很明显“较不正统”的方法也较慢。超过20次运行（每次执行100,000,000次迭代，并在每次迭代中比较不同的值对），我得到了平均时间和标准偏差（以秒为单位）：

            Mean        Standard Deviation
Value       0.732914    0.005000
Pointer     0.655853    0.003895
Null        0.353649    0.003448

值和指针版本之间的差异很大（0.077s是标准偏差的许多倍），指针版本更快。因此，使用传统的基于指针的比较器版本。 'Null'时间使用比较器函数，它只返回0而根本没有比较。

代表性输出线：

Value:   0.730634 (less =  51517909, more =  48482090, equl =         1)
Pointer: 0.684107 (less =  51517909, more =  48482090, equl =         1)
Null:    0.351807 (less =         0, more =         0, equl = 100000000)

测试代码

两个比较器重命名为compare_digests_val()用于比较值，compare_digests_ptr()用于比较指针。时钟类型和clk_*函数是在我测试的平台上使用gettimeofday()的高分辨率计时器包。很明显，循环中有一个相当大的开销，增量和累积统计数据，但这只是意味着比较器的差异更大。

static int compare_digests_nul(const void *a, const void *b)
{
    return 0;
}

static void time_comparisons(const char *tag, int (*compare)(const void *, const void *))
{
    struct digest_line a = { 0, 0 };
    struct digest_line b = { 0, 0 };
    int less = 0;
    int more = 0;
    int equl = 0;
    Clock clk;
    char buffer[32];
    clk_init(&clk);
    clk_start(&clk);
    for (int i = 0; i < 100000000; i++)
    {
        int j = (*compare)(&a, &b);
        if (j < 0)
            less++;
        else if (j > 0)
            more++;
        else
            equl++;
        a.first  += 1234567890123ULL;
        a.second += 2345678901234ULL;
        b.first  += 7654321098765ULL;
        b.second += 8765432109876ULL;
    }
    clk_stop(&clk);
    printf("%-8s %s (less = %9d, more = %9d, equl = %9d)\n", tag,
           clk_elapsed_us(&clk, buffer, sizeof(buffer)),
           less, more, equl);
}

int main(void)
{
    for (int i = 0; i < 20; i++)
    {
        time_comparisons("Value:",   compare_digests_val);
        time_comparisons("Pointer:", compare_digests_ptr);
        time_comparisons("Null:",    compare_digests_nul);
    }
    return 0;
}

Answer 2

任何平台上的最佳选择可能只是使用memcmp。这应该在任何体面的架构上高度优化（和内联）。查看汇编程序应该告诉您编译器是否正在进行一些聪明的优化。然后基准测试可以告诉您哪个版本最好，因为对齐问题也可能起作用，并取决于您拥有的数据类型。

我手头没有你的架构，所以我用gcc快速检查了我的老式i686。以下函数的汇编程序

int compare(struct digest* a, struct digest* b) {
  return memcmp(a, b, sizeof *a);
}

看起来非常精细优化。

编辑：Jonathan的评论是正确的，这并不一定会给出128位模式的数字排序。但只要您只对订单的一致排序感兴趣，请将其放入您的摘要中，这应该适用于所有平台。 AFAIR AIX平台是大端的，因此它应该特别适用于那里。

AIX（64位）下的128位比较用于排序哈希值

2 个答案:

更正统

不太正统

时序

测试代码