C#向量<；双倍>；。复制速度比非SIMD版本快多少？_C#_Html_Vector_Simd

C#向量<；双倍>；。复制速度比非SIMD版本快多少？

c# html vector

C#向量<；双倍>；。复制速度比非SIMD版本快多少？,c#,html,vector,simd,C#,Html,Vector,Simd,更新：前面提到的span问题在.net core 2.1版本中得到了修复（目前正在预览中）。这些问题实际上使span向量*比数组向量*快注意：在一个“英特尔至强E5-1660 v4”上测试这个，CPU-Z告诉我有“MMX、SSE、SSE2、SSE3、SSE3、SSE4.1、SSE4.2、EM64T、VT-x、AES、AVX、AVX2、FMA3、RSX”的指令，所以应该可以在回答a之后，我想我会尝试实现一些BLAS函数。我发现那些正在读取/求和的数据（比如点积）相当不错，但我正在写回数组的数据

更新：前面提到的span问题在.net core 2.1版本中得到了修复（目前正在预览中）。这些问题实际上使span向量*比数组向量*快

注意：在一个“英特尔至强E5-1660 v4”上测试这个，CPU-Z告诉我有“MMX、SSE、SSE2、SSE3、SSE3、SSE4.1、SSE4.2、EM64T、VT-x、AES、AVX、AVX2、FMA3、RSX”的指令，所以应该可以

在回答a之后，我想我会尝试实现一些BLAS函数。我发现那些正在读取/求和的数据（比如点积）相当不错，但我正在写回数组的数据却很糟糕——比非SIMD数据要好，但几乎没有

那么我是做错了什么，还是JIT需要更多的工作

这个例子（假设x.Length=y.Length，不为null等等诸如此类）：

我做错什么了吗？我几乎想不出一个更简单的例子，所以我不这么认为？

您可能想用2.1而不是2.0进行测试；在我的笔记本电脑上（与我的台式电脑相比，它的SIMD很差），我得到：

使用代码：

using System;
using System.Diagnostics;
using System.Numerics;
class Program
{
    static void Main(string[] args)
    {
        double alpha = 0.5;
        double[] x = new double[16 * 1024], y = new double[x.Length];
        var rand = new Random(12345);
        for (int i = 0; i < x.Length; i++)
            x[i] = rand.NextDouble();

        RunAll(alpha, x, y, 1, false);
        RunAll(alpha, x, y, 10000, true);
    }

    private static void RunAll(double alpha, double[] x, double[] y, int loop, bool log)
    {
        GC.Collect(GC.MaxGeneration);
        GC.WaitForPendingFinalizers();

        var watch = Stopwatch.StartNew();
        for(int i = 0; i < loop; i++)
        {
            daxpy_naive(alpha, x, y);
        }
        watch.Stop();
        if (log) Console.WriteLine($"{nameof(daxpy_naive)} x{loop}: {watch.ElapsedMilliseconds}ms");

        watch = Stopwatch.StartNew();
        for (int i = 0; i < loop; i++)
        {
            daxpy_arr_vector(alpha, x, y);
        }
        watch.Stop();
        if (log) Console.WriteLine($"{nameof(daxpy_arr_vector)} x{loop}: {watch.ElapsedMilliseconds}ms");


        watch = Stopwatch.StartNew();
        for (int i = 0; i < loop; i++)
        {
            daxpy_span(alpha, x, y);
        }
        watch.Stop();
        if (log) Console.WriteLine($"{nameof(daxpy_span)} x{loop}: {watch.ElapsedMilliseconds}ms");

        watch = Stopwatch.StartNew();
        for (int i = 0; i < loop; i++)
        {
            daxpy_vector(alpha, x, y);
        }
        watch.Stop();
        if (log) Console.WriteLine($"{nameof(daxpy_vector)} x{loop}: {watch.ElapsedMilliseconds}ms");

        watch = Stopwatch.StartNew();
        for (int i = 0; i < loop; i++)
        {
            daxpy_vector_no_slice(alpha, x, y);
        }
        watch.Stop();
        if (log) Console.WriteLine($"{nameof(daxpy_vector_no_slice)} x{loop}: {watch.ElapsedMilliseconds}ms");
    }

    public static void daxpy_naive(double alpha, double[] x, double[] y)
    {
        for (var i = 0; i < x.Length; ++i)
            y[i] = y[i] + x[i] * alpha;
    }

    public static void daxpy_arr_vector(double alpha, double[] x, double[] y)
    {
        var i = 0;
        if (Vector.IsHardwareAccelerated)
        {
            var length = x.Length + 1 - Vector<double>.Count;
            for (; i < length; i += Vector<double>.Count)
            {
                var valpha = new Vector<double>(alpha);
                var vx = new Vector<double>(x, i);
                var vy = new Vector<double>(y, i);
                (vy + vx * valpha).CopyTo(y, i);
            }
        }
        for (; i < x.Length; ++i)
            y[i] = y[i] + x[i] * alpha;
    }
    public static void daxpy_span(double alpha, Span<double> x, Span<double> y)
    {
        for (var i = 0; i < x.Length; ++i)
            y[i] += x[i] * alpha;
    }

    public static void daxpy_vector(double alpha, Span<double> x, Span<double> y)
    {
        if (Vector.IsHardwareAccelerated)
        {
            var vx = x.NonPortableCast<double, Vector<double>>();
            var vy = y.NonPortableCast<double, Vector<double>>();

            var valpha = new Vector<double>(alpha);
            for (var i = 0; i < vx.Length; ++i)
                vy[i] += vx[i] * valpha;

            x = x.Slice(Vector<double>.Count * vx.Length);
            y = y.Slice(Vector<double>.Count * vy.Length);
        }

        for (var i = 0; i < x.Length; ++i)
            y[i] += x[i] * alpha;
    }

    public static void daxpy_vector_no_slice(double alpha, Span<double> x, Span<double> y)
    {
        int i = 0;
        if (Vector.IsHardwareAccelerated)
        {
            var vx = x.NonPortableCast<double, Vector<double>>();
            var vy = y.NonPortableCast<double, Vector<double>>();

            var valpha = new Vector<double>(alpha);
            for (i = 0; i < vx.Length; ++i)
                vy[i] += vx[i] * valpha;

            i = Vector<double>.Count * vx.Length;
        }

        for (; i < x.Length; ++i)
            y[i] += x[i] * alpha;
    }
}

使用系统；
使用系统诊断；
使用系统数字；
班级计划
{
静态void Main（字符串[]参数）
{
双α=0.5；
double[]x=新双精度[16*1024]，y=新双精度[x.长度]；
var rand=新随机变量（12345）；
对于（int i=0；i


它正在使用dotnet build-c发行版
和dotnet run-c发行版
，其中dotnet-version
报告“2.2.0-preview1-008000”（不久前的“每日”）
我的桌面上，我想这个差别会更好。
你查过了VC++代码生成的<代码> IL >代码吗？@天哪，在IL没有什么奇怪的，恐怕我对汇编没有足够的了解，去解释应该或不应该存在的……使用System.Buffer.BlockCopy
和*alpha
步骤进行两次通过操作，实际上可以获得更快的性能。@Tigran IL在这里几乎不相关；JIT完成了所有的magicHow，您能解释一下Span
版本比原始版本慢一些吗？这可能是因为在Span的情况下，元素存在就地累积，抖动可能会以不同的方式进行优化？我只是从提供的代码中看不到任何其他的glari
public static void daxpy(double alpha, double[] x, double[] y)
{
    var i = 0;
    if (Vector.IsHardwareAccelerated)
    {
        var length = x.Length + 1 - Vector<double>.Count;
        for (; i < length; i += Vector<double>.Count)
        {
            var valpha = new Vector<double>(alpha);
            var vx = new Vector<double>(x, i);
            var vy = new Vector<double>(y, i);
            (vy + vx * valpha).CopyTo(y, i);
        }
    }
    for (; i < x.Length; ++i)
        y[i] = y[i] + x[i] * alpha;
}

public static void daxpy(double alpha, Span<double> x, Span<double> y)
{
    for (var i = 0; i < x.Length; ++i)
        y[i] += x[i] * alpha;
}

public static void daxpy(double alpha, Span<double> x, Span<double> y)
{
    if (Vector.IsHardwareAccelerated)
    {
        var vx = x.NonPortableCast<double, Vector<double>>();
        var vy = y.NonPortableCast<double, Vector<double>>();

        var valpha = new Vector<double>(alpha);
        for (var i = 0; i < vx.Length; ++i)
            vy[i] += vx[i] * valpha;

        x = x.Slice(Vector<double>.Count * vx.Length);
        y = y.Slice(Vector<double>.Count * vy.Length);
    }

    for (var i = 0; i < x.Length; ++i)
        y[i] += x[i] * alpha;
}

Naive       1.0
Vector      0.8
Span Naive  2.5 ==> Update: Span Naive  1.1
Span Vector 0.9 ==> Update: Span Vector 0.6

daxpy_naive x10000: 144ms
daxpy_arr_vector x10000: 77ms
daxpy_span x10000: 173ms
daxpy_vector x10000: 67ms
daxpy_vector_no_slice x10000: 67ms

using System;
using System.Diagnostics;
using System.Numerics;
class Program
{
    static void Main(string[] args)
    {
        double alpha = 0.5;
        double[] x = new double[16 * 1024], y = new double[x.Length];
        var rand = new Random(12345);
        for (int i = 0; i < x.Length; i++)
            x[i] = rand.NextDouble();

        RunAll(alpha, x, y, 1, false);
        RunAll(alpha, x, y, 10000, true);
    }

    private static void RunAll(double alpha, double[] x, double[] y, int loop, bool log)
    {
        GC.Collect(GC.MaxGeneration);
        GC.WaitForPendingFinalizers();

        var watch = Stopwatch.StartNew();
        for(int i = 0; i < loop; i++)
        {
            daxpy_naive(alpha, x, y);
        }
        watch.Stop();
        if (log) Console.WriteLine($"{nameof(daxpy_naive)} x{loop}: {watch.ElapsedMilliseconds}ms");

        watch = Stopwatch.StartNew();
        for (int i = 0; i < loop; i++)
        {
            daxpy_arr_vector(alpha, x, y);
        }
        watch.Stop();
        if (log) Console.WriteLine($"{nameof(daxpy_arr_vector)} x{loop}: {watch.ElapsedMilliseconds}ms");


        watch = Stopwatch.StartNew();
        for (int i = 0; i < loop; i++)
        {
            daxpy_span(alpha, x, y);
        }
        watch.Stop();
        if (log) Console.WriteLine($"{nameof(daxpy_span)} x{loop}: {watch.ElapsedMilliseconds}ms");

        watch = Stopwatch.StartNew();
        for (int i = 0; i < loop; i++)
        {
            daxpy_vector(alpha, x, y);
        }
        watch.Stop();
        if (log) Console.WriteLine($"{nameof(daxpy_vector)} x{loop}: {watch.ElapsedMilliseconds}ms");

        watch = Stopwatch.StartNew();
        for (int i = 0; i < loop; i++)
        {
            daxpy_vector_no_slice(alpha, x, y);
        }
        watch.Stop();
        if (log) Console.WriteLine($"{nameof(daxpy_vector_no_slice)} x{loop}: {watch.ElapsedMilliseconds}ms");
    }

    public static void daxpy_naive(double alpha, double[] x, double[] y)
    {
        for (var i = 0; i < x.Length; ++i)
            y[i] = y[i] + x[i] * alpha;
    }

    public static void daxpy_arr_vector(double alpha, double[] x, double[] y)
    {
        var i = 0;
        if (Vector.IsHardwareAccelerated)
        {
            var length = x.Length + 1 - Vector<double>.Count;
            for (; i < length; i += Vector<double>.Count)
            {
                var valpha = new Vector<double>(alpha);
                var vx = new Vector<double>(x, i);
                var vy = new Vector<double>(y, i);
                (vy + vx * valpha).CopyTo(y, i);
            }
        }
        for (; i < x.Length; ++i)
            y[i] = y[i] + x[i] * alpha;
    }
    public static void daxpy_span(double alpha, Span<double> x, Span<double> y)
    {
        for (var i = 0; i < x.Length; ++i)
            y[i] += x[i] * alpha;
    }

    public static void daxpy_vector(double alpha, Span<double> x, Span<double> y)
    {
        if (Vector.IsHardwareAccelerated)
        {
            var vx = x.NonPortableCast<double, Vector<double>>();
            var vy = y.NonPortableCast<double, Vector<double>>();

            var valpha = new Vector<double>(alpha);
            for (var i = 0; i < vx.Length; ++i)
                vy[i] += vx[i] * valpha;

            x = x.Slice(Vector<double>.Count * vx.Length);
            y = y.Slice(Vector<double>.Count * vy.Length);
        }

        for (var i = 0; i < x.Length; ++i)
            y[i] += x[i] * alpha;
    }

    public static void daxpy_vector_no_slice(double alpha, Span<double> x, Span<double> y)
    {
        int i = 0;
        if (Vector.IsHardwareAccelerated)
        {
            var vx = x.NonPortableCast<double, Vector<double>>();
            var vy = y.NonPortableCast<double, Vector<double>>();

            var valpha = new Vector<double>(alpha);
            for (i = 0; i < vx.Length; ++i)
                vy[i] += vx[i] * valpha;

            i = Vector<double>.Count * vx.Length;
        }

        for (; i < x.Length; ++i)
            y[i] += x[i] * alpha;
    }
}