Fill< T >()

static void System.SpanHelpers.Fill< T > ( ref T refData, nuint numElements, T value )

inlinestatic

Definition at line 2842 of file SpanHelpers.cs.

    {
        if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>() && Vector.IsHardwareAccelerated && Unsafe.SizeOf<T>() <= Vector<byte>.Count && BitOperations.IsPow2(Unsafe.SizeOf<T>()) && numElements >= (uint)(Vector<byte>.Count / Unsafe.SizeOf<T>()))
        {
            T source = value;
            Vector<byte> value2;
            if (Unsafe.SizeOf<T>() == 1)
            {
                value2 = new Vector<byte>(Unsafe.As<T, byte>(ref source));
            }
            else if (Unsafe.SizeOf<T>() == 2)
            {
                value2 = (Vector<byte>)new Vector<ushort>(Unsafe.As<T, ushort>(ref source));
            }
            else if (Unsafe.SizeOf<T>() == 4)
            {
                value2 = ((typeof(T) == typeof(float)) ? ((Vector<byte>)new Vector<float>((float)(object)source)) : ((Vector<byte>)new Vector<uint>(Unsafe.As<T, uint>(ref source))));
            }
            else if (Unsafe.SizeOf<T>() == 8)
            {
                value2 = ((typeof(T) == typeof(double)) ? ((Vector<byte>)new Vector<double>((double)(object)source)) : ((Vector<byte>)new Vector<ulong>(Unsafe.As<T, ulong>(ref source))));
            }
            else if (Unsafe.SizeOf<T>() == 16)
            {
                Vector128<byte> vector = Unsafe.As<T, Vector128<byte>>(ref source);
                if (Vector<byte>.Count == 16)
                {
                    value2 = vector.AsVector();
                }
                else
                {
                    if (Vector<byte>.Count != 32)
                    {
                        goto IL_022e;
                    }
                    value2 = Vector256.Create(vector, vector).AsVector();
                }
            }
            else
            {
                if (Unsafe.SizeOf<T>() != 32 || Vector<byte>.Count != 32)
                {
                    goto IL_022e;
                }
                value2 = Unsafe.As<T, Vector256<byte>>(ref source).AsVector();
            }
            ref byte source2 = ref Unsafe.As<T, byte>(ref refData);
            nuint num = numElements * (nuint)Unsafe.SizeOf<T>();
            nuint num2 = num & (nuint)(2 * -Vector<byte>.Count);
            nuint num3 = 0u;
            if (numElements >= (uint)(2 * Vector<byte>.Count / Unsafe.SizeOf<T>()))
            {
                do
                {
                    Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref source2, num3), value2);
                    Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref source2, num3 + (nuint)Vector<byte>.Count), value2);
                    num3 += (uint)(2 * Vector<byte>.Count);
                }
                while (num3 < num2);
            }
            if ((num & (nuint)Vector<byte>.Count) != 0)
            {
                Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref source2, num3), value2);
            }
            Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref source2, num - (nuint)Vector<byte>.Count), value2);
            return;
        }
        goto IL_022e;
        IL_022e:
        nuint num4 = 0u;
        if (numElements >= 8)
        {
            nuint num5 = numElements & ~(nuint)7u;
            do
            {
                Unsafe.Add(ref refData, (nint)(num4 + 0)) = value;
                Unsafe.Add(ref refData, (nint)(num4 + 1)) = value;
                Unsafe.Add(ref refData, (nint)(num4 + 2)) = value;
                Unsafe.Add(ref refData, (nint)(num4 + 3)) = value;
                Unsafe.Add(ref refData, (nint)(num4 + 4)) = value;
                Unsafe.Add(ref refData, (nint)(num4 + 5)) = value;
                Unsafe.Add(ref refData, (nint)(num4 + 6)) = value;
                Unsafe.Add(ref refData, (nint)(num4 + 7)) = value;
            }
            while ((num4 += 8) < num5);
        }
        if ((numElements & 4) != 0)
        {
            Unsafe.Add(ref refData, (nint)(num4 + 0)) = value;
            Unsafe.Add(ref refData, (nint)(num4 + 1)) = value;
            Unsafe.Add(ref refData, (nint)(num4 + 2)) = value;
            Unsafe.Add(ref refData, (nint)(num4 + 3)) = value;
            num4 += 4;
        }
        if ((numElements & 2) != 0)
        {
            Unsafe.Add(ref refData, (nint)(num4 + 0)) = value;
            Unsafe.Add(ref refData, (nint)(num4 + 1)) = value;
            num4 += 2;
        }
        if ((numElements & 1) != 0)
        {
            Unsafe.Add(ref refData, (nint)num4) = value;
        }
    }

References System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Runtime.Intrinsics.Vector256< T >.Create(), System.Numerics.Vector< T >.IsHardwareAccelerated, System.Numerics.BitOperations.IsPow2(), System.source, System.T, and System.value.