我的cpu支持到avx2, 没有整数除法。但是Intel提供了svml，可以高效模拟除法和取模运算。

我试着用svml优化了C++，这次时间缩短到3.67秒。

simd还是明显提高了速度。 不过估计整数除法是模拟的，提高远没有8倍那么多。


int intperf3()
{
    constexpr int n = 5000 * 10000;
    int cc = 1;
    
    int* buf = new int[n];
    buf[0] = 2;

    int vn = 8;
    __m256i zero = _mm256_set_epi32(0, 0, 0, 0, 0, 0, 0, 0);
    __m256i one = _mm256_set_epi32(1, 1, 1, 1, 1, 1, 1, 1);


    __m256i vi, vj,vk;
    for (int i = 3;i <= n;++i)
    {
        vi = _mm256_set_epi32(i, i, i, i, i, i, i, i);
        int flag = 1;
        int it = 0;
        for (;it < cc-vn;it+=vn)
        {
            vj = _mm256_set_epi32(buf[it], buf[it + 1], buf[it + 2], buf[it + 3],
                buf[it + 4], buf[it + 5], buf[it + 6], buf[it + 7]);

            vk = _mm256_rem_epi32(vi, vj);

            if (_mm256_testz_si256(_mm256_cmpeq_epi32(vk,zero),one)==0)
            {
                flag = 0;
                break;
            }

            int j = buf[it];
            if (j * j > i)
                break;
        }

        for (;it < cc;++it)
        {
            int j = buf[it];
            if (i % j == 0)
            {
                flag = 0;
                break;
            }
            if (j * j > i)
                break;
        }

        if (flag) { buf[cc++] = i; }
    }
    return cc;
}

【 在 leadu 的大作中提到: 】
: avx 等没有除法，优化不了，这个算法只能做partition然后靠cpu或gpu堆，写起来相当麻烦，一没留神就比不优化更慢
:
--
FROM 123.112.64.*

今天晚上重新实现了C#的simd， 在我的i5 8265U上只需要1.8秒了，比simd 的C++的2.96秒还快很多。

需要说明的是，昨天直接用AVX2指令实现simd， 因为不支持除法，先把int转成float然后做除法。
结果一直不对，发现是对于比较大的i，转成float后精度损失了，所以结果就不对了。

今天用double实现，原来8路向量，现在只能4路。 但是结果还是不错的。 只要1.8秒。

比较赞的是dotnet把simd操作封装到Vector，不用考虑具体指令集了,也不用管cpu支持几路向量了，
jit会在运行时检查硬件。

C++的simd 要近3秒，是因为我用了SVML的整数取模指令，是intel用其他指令编程合成的，所以会慢。
如果也用double实现， 应该跟C#速度类似。

对C#的profiling, 向量除法运算这一语句耗时用到全部程序的50%。


        public static int intperf3(int n)
        {
            int cc = 1;

            int vn = Vector<double>.Count;
          

            double[] buf = new double[n];

            buf[0] = 2;
            for (int i = 3; i <= n; i += 2)
            {
                int flag = 1;
                int it = 0;
                var vi = new Vector<double>(i);

                int m = cc - vn;
                for (; it < m; it += vn)
                {
                    var vj = new Vector<double>(buf, it);
                    var t1 = vi/vj;
                    var t2 = Vector.Floor(t1);

                    if (Vector.EqualsAny(t1, t2))
                    {
                        flag = 0;
                        break;
                    }

                    double j = buf[it];
                    if (j * j > i)
                        break;

                }
                if (flag == 0) continue;

                for (; it < cc; it++)
                {
                    int j = (int)buf[it];
                    if (i % j == 0)
                    {
                        flag = 0;
                        break;
                    }
                    if (j*j > i)
                        break;
                }

                if (flag == 1)
                {
                    buf[cc++] = i;
                  
                }
            }
            return cc;
        }





【 在 leadu 的大作中提到: 】
: cpu密集的程序性能上，高级语言没有能比得上c/cpp/rust的，都会比他们多几条指令，多几纳秒。
: 定量5kw内求素数，上面也早就给了数据了，cpp确实快一些，但快的这一些，拉一下滚动条都能抵消，99.9%使用场景下没有值得考虑的价值
: cpu simd，gpu，fpga都是硬件优化范畴，本身使用的都是另外的接口，和语言本身无关，哪个语言也都能用
: ...................
--
FROM 123.112.64.*

今晚有时间，改了下C++的代码。

1个是在原始的没有手工调用AVX2指令的版本，把 把int buf[] 改成double[]

这时，程序速度大幅度提高，最快只需要3.2秒。原因是 double除法可以用simd优化。


另一个，我把原来的整数版的手工AVX2 指令， 改成全部用double， 这时，就只需要1.66秒



【 在 finlab 的大作中提到: 】
: 用vc++2022版测试， 6.55秒， 还是明显比c#慢。
:
--
FROM 123.112.64.*

我认为这个对比还是有意义的。它为关注性能的人提供了一个考虑问题的起点和基础：

单纯基本计算和数组访问，C#和C++的性能已经非常接近。

如果出现巨大的差异，那么一般是使用的上层设施和高级特性导致的。

通过避免或者绕过这些特性，就可能取得明显的性能提升。



【 在 puke 的大作中提到: 】
: 单纯看简单daimaq
: jit和aot本来就没有这么大区别。
: 写的差的C++代码还不一定比得过C#和Java
: ...................
--
FROM 123.112.69.*