1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Diagnostics;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics.X86;
using System.Text;
using Internal.Runtime.CompilerServices;
namespace System.Runtime.Intrinsics
{
// We mark certain methods with AggressiveInlining to ensure that the JIT will
// inline them. The JIT would otherwise not inline the method since it, at the
// point it tries to determine inline profability, currently cannot determine
// that most of the code-paths will be optimized away as "dead code".
//
// We then manually inline cases (such as certain intrinsic code-paths) that
// will generate code small enough to make the AgressiveInlining profitable. The
// other cases (such as the software fallback) are placed in their own method.
// This ensures we get good codegen for the "fast-path" and allows the JIT to
// determine inline profitability of the other paths as it would normally.
[Intrinsic]
[DebuggerDisplay("{DisplayString,nq}")]
[DebuggerTypeProxy(typeof(Vector256DebugView<>))]
[StructLayout(LayoutKind.Sequential, Size = Vector256.Size)]
public readonly struct Vector256<T> : IEquatable<Vector256<T>>, IFormattable
where T : struct
{
// These fields exist to ensure the alignment is 8, rather than 1.
// This also allows the debug view to work https://github.com/dotnet/coreclr/issues/15694)
private readonly ulong _00;
private readonly ulong _01;
private readonly ulong _02;
private readonly ulong _03;
/// <summary>Gets the number of <typeparamref name="T" /> that are in a <see cref="Vector256{T}" />.</summary>
/// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
public static int Count
{
[Intrinsic]
get
{
ThrowHelper.ThrowForUnsupportedVectorBaseType<T>();
return Vector256.Size / Unsafe.SizeOf<T>();
}
}
/// <summary>Gets a new <see cref="Vector256{T}" /> with all elements initialized to zero.</summary>
/// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
public static Vector256<T> Zero
{
[Intrinsic]
get
{
ThrowHelper.ThrowForUnsupportedVectorBaseType<T>();
return default;
}
}
internal unsafe string DisplayString
{
get
{
if (IsSupported)
{
return ToString();
}
else
{
return SR.NotSupported_Type;
}
}
}
internal static bool IsSupported
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
return (typeof(T) == typeof(byte)) ||
(typeof(T) == typeof(sbyte)) ||
(typeof(T) == typeof(short)) ||
(typeof(T) == typeof(ushort)) ||
(typeof(T) == typeof(int)) ||
(typeof(T) == typeof(uint)) ||
(typeof(T) == typeof(long)) ||
(typeof(T) == typeof(ulong)) ||
(typeof(T) == typeof(float)) ||
(typeof(T) == typeof(double));
}
}
/// <summary>Determines whether the specified <see cref="Vector256{T}" /> is equal to the current instance.</summary>
/// <param name="other">The <see cref="Vector256{T}" /> to compare with the current instance.</param>
/// <returns><c>true</c> if <paramref name="other" /> is equal to the current instance; otherwise, <c>false</c>.</returns>
/// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(Vector256<T> other)
{
if (Avx.IsSupported)
{
if (typeof(T) == typeof(float))
{
Vector256<float> result = Avx.Compare(this.AsSingle(), other.AsSingle(), FloatComparisonMode.OrderedEqualNonSignaling);
return Avx.MoveMask(result) == 0b1111_1111; // We have one bit per element
}
if (typeof(T) == typeof(double))
{
Vector256<double> result = Avx.Compare(this.AsDouble(), other.AsDouble(), FloatComparisonMode.OrderedEqualNonSignaling);
return Avx.MoveMask(result) == 0b1111; // We have one bit per element
}
}
if (Avx2.IsSupported)
{
// Unlike float/double, there are no special values to consider
// for integral types and we can just do a comparison that all
// bytes are exactly the same.
Debug.Assert((typeof(T) != typeof(float)) && (typeof(T) != typeof(double)));
Vector256<byte> result = Avx2.CompareEqual(this.AsByte(), other.AsByte());
return Avx2.MoveMask(result) == unchecked((int)(0b1111_1111_1111_1111_1111_1111_1111_1111)); // We have one bit per element
}
return SoftwareFallback(in this, other);
static bool SoftwareFallback(in Vector256<T> vector, Vector256<T> other)
{
for (int i = 0; i < Count; i++)
{
if (!((IEquatable<T>)(vector.GetElement(i))).Equals(other.GetElement(i)))
{
return false;
}
}
return true;
}
}
/// <summary>Determines whether the specified object is equal to the current instance.</summary>
/// <param name="obj">The object to compare with the current instance.</param>
/// <returns><c>true</c> if <paramref name="obj" /> is a <see cref="Vector256{T}" /> and is equal to the current instance; otherwise, <c>false</c>.</returns>
/// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
public override bool Equals(object? obj)
{
return (obj is Vector256<T>) && Equals((Vector256<T>)(obj));
}
/// <summary>Gets the hash code for the instance.</summary>
/// <returns>The hash code for the instance.</returns>
/// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
public override int GetHashCode()
{
ThrowHelper.ThrowForUnsupportedVectorBaseType<T>();
int hashCode = 0;
for (int i = 0; i < Count; i++)
{
hashCode = HashCode.Combine(hashCode, this.GetElement(i).GetHashCode());
}
return hashCode;
}
/// <summary>Converts the current instance to an equivalent string representation.</summary>
/// <returns>An equivalent string representation of the current instance.</returns>
/// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
public override string ToString()
{
return ToString("G");
}
/// <summary>Converts the current instance to an equivalent string representation using the specified format.</summary>
/// <param name="format">The format specifier used to format the individual elements of the current instance.</param>
/// <returns>An equivalent string representation of the current instance.</returns>
/// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
public string ToString(string? format)
{
return ToString(format, formatProvider: null);
}
/// <summary>Converts the current instance to an equivalent string representation using the specified format.</summary>
/// <param name="format">The format specifier used to format the individual elements of the current instance.</param>
/// <param name="formatProvider">The format provider used to format the individual elements of the current instance.</param>
/// <returns>An equivalent string representation of the current instance.</returns>
/// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
public string ToString(string? format, IFormatProvider? formatProvider)
{
ThrowHelper.ThrowForUnsupportedVectorBaseType<T>();
string separator = NumberFormatInfo.GetInstance(formatProvider).NumberGroupSeparator;
int lastElement = Count - 1;
var sb = StringBuilderCache.Acquire();
sb.Append('<');
for (int i = 0; i < lastElement; i++)
{
sb.Append(((IFormattable)(this.GetElement(i))).ToString(format, formatProvider));
sb.Append(separator);
sb.Append(' ');
}
sb.Append(((IFormattable)(this.GetElement(lastElement))).ToString(format, formatProvider));
sb.Append('>');
return StringBuilderCache.GetStringAndRelease(sb);
}
}
}
|
