SIMD优化拼图

时间:2010-10-28 21:29:14

标签: algorithm optimization assembly sse simd

我想使用SIMD(SSE2& such)优化以下功能:

int64_t fun(int64_t N, int size, int* p)
{
    int64_t sum = 0;
    for(int i=1; i<size; i++)
       sum += (N/i)*p[i];
    return sum;
}

这似乎是一个非常可矢量化的任务,除了所需的指令不存在......

我们可以假设N非常大(10 ^ 12到10 ^ 18)并且大小~sqrt(N)。我们还可以假设p只能取值-1,0和1;所以我们不需要真正的乘法,(N / i)* p [i]可以用四条指令(pcmpgt,pxor,psub,pand)完成,如果我们可以以某种方式计算N / i。

4 个答案:

答案 0 :(得分:2)

这就像我可以使用矢量化代码一样接近。我真的不希望它更快。我只是试着写SIMD代码。

#include <stdint.h>

int64_t fun(int64_t N, int size, const int* p)
{
    int64_t sum = 0;
    int i;
    for(i=1; i<size; i++) {
        sum += (N/i)*p[i];
    }
    return sum;
}

typedef int64_t v2sl __attribute__ ((vector_size (2*sizeof(int64_t))));

int64_t fun_simd(int64_t N, int size, const int* p)
{
    int64_t sum = 0;
    int i;
    v2sl v_2 = { 2, 2 };
    v2sl v_N = { N, N };
    v2sl v_i = { 1, 2 };
    union { v2sl v; int64_t a[2]; } v_sum;

    v_sum.a[0] = 0;
    v_sum.a[1] = 0;
    for(i=1; i<size-1; i+=2) {
        v2sl v_p = { p[i], p[i+1] };
        v_sum.v += (v_N / v_i) * v_p;
        v_i += v_2;
    }
    sum = v_sum.a[0] + v_sum.a[1];
    for(; i<size; i++) {
        sum += (N/i)*p[i];
    }
    return sum;
}

typedef double v2df __attribute__ ((vector_size (2*sizeof(double))));

int64_t fun_simd_double(int64_t N, int size, const int* p)
{
    int64_t sum = 0;
    int i;
    v2df v_2 = { 2, 2 };
    v2df v_N = { N, N };
    v2df v_i = { 1, 2 };
    union { v2df v; double a[2]; } v_sum;

    v_sum.a[0] = 0;
    v_sum.a[1] = 0;
    for(i=1; i<size-1; i+=2) {
        v2df v_p = { p[i], p[i+1] };
        v_sum.v += (v_N / v_i) * v_p;
        v_i += v_2;
    }
    sum = v_sum.a[0] + v_sum.a[1];
    for(; i<size; i++) {
        sum += (N/i)*p[i];
    }
    return sum;
}

#include <stdio.h>

static const int test_array[] = {
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0,
 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1, 0
};
#define test_array_len (sizeof(test_array)/sizeof(int))

#define big_N (1024 * 1024 * 1024)

int main(int argc, char *argv[]) {
    int64_t res1;
    int64_t res2;
    int64_t res3;
    v2sl a = { 123, 456 };
    v2sl b = { 100, 200 };
    union { v2sl v; int64_t a[2]; } tmp;

    a = a + b;
    tmp.v = a;
    printf("a = { %ld, %ld }\n", tmp.a[0], tmp.a[1]);

    printf("test_array size = %zd\n", test_array_len);

    res1 = fun(big_N, test_array_len, test_array);
    printf("fun() = %ld\n", res1);

    res2 = fun_simd(big_N, test_array_len, test_array);
    printf("fun_simd() = %ld\n", res2);

    res3 = fun_simd_double(big_N, test_array_len, test_array);
    printf("fun_simd_double() = %ld\n", res3);

    return 0;
}

答案 1 :(得分:2)

1/x的衍生工具为-1/x^2,这意味着x变大,N/x==N/(x + 1)

对于N/x的已知值(我们称之为r),我们可以确定x的下一个值(让我们调用该值x',以便{ {1}}:

N/x'<r

因为我们正在处理整数:

x'= N/(r - 1)

所以,循环变成这样:

x'= ceiling(N/(r - 1))

对于足够大的N,int64_t sum = 0; int i=1; int r= N; while (i<size) { int s= (N + r - 1 - 1)/(r - 1); while (i<s && i<size) { sum += (r)*p[i]; ++i; } r= N/s; } return sum; 将有许多相同值的运行。当然,如果你不小心的话,你会将零除以零。

答案 2 :(得分:1)

我建议你使用浮点SIMD操作 - 根据你的精度要求,单精度或双精度。使用SSE从int转换为float或double的速度相对较快。

答案 3 :(得分:1)

成本主要集中在计算分歧上。 SSE2中没有用于积分除法的操作码,因此您必须自己一点一点地实现除法算法。我不认为这是值得的:SSE2允许你并行执行两个实例(你使用64位数字,SSE2寄存器是128位)但我发现手工划分算法可能至少是比CPU idiv操作码慢两倍。

(顺便说一句,你是在32位还是64位模式下编译?后者对64位整数更加舒适。)

减少总体划分数似乎是一种更有前途的方式。可以注意到,对于正整数 x y ,则 floor(x /(2y))= floor(floor(x / y)/ 2)< / em>的。在C术语中,一旦计算出N/i(截断的除法),您只需将其右移一位即可获得N/(2*i)。如果使用得当,这会使你的一半部门几乎免费(“正确”还包括以不会对缓存造成严重破坏的方式访问数十亿p[i]值,因此它看起来并不容易)。 / p>