public void RunStructFldScenario(VectorBinaryOpTest__EqualsInt16 testClass) { var result = Vector128.Equals(_fld1, _fld2); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); }
/// <summary> /// Searches for an opening character from a registered parser in the specified string. /// </summary> /// <param name="text">The text.</param> /// <param name="start">The start.</param> /// <param name="end">The end.</param> /// <returns>Index position within the string of the first opening character found in the specified text; if not found, returns -1</returns> public int IndexOfOpeningCharacter(string text, int start, int end) { Debug.Assert(text is not null); Debug.Assert(start >= 0 && end >= 0); Debug.Assert(end - start + 1 >= 0); Debug.Assert(end - start + 1 <= text.Length); if (nonAsciiMap is null) { #if NETCOREAPP3_1_OR_GREATER if (Ssse3.IsSupported && BitConverter.IsLittleEndian) { // Based on http://0x80.pl/articles/simd-byte-lookup.html#universal-algorithm // Optimized for sets in the [1, 127] range int lengthMinusOne = end - start; int charsToProcessVectorized = lengthMinusOne & ~(2 * Vector128 <short> .Count - 1); int finalStart = start + charsToProcessVectorized; if (start < finalStart) { ref char textStartRef = ref Unsafe.Add(ref Unsafe.AsRef(in text.GetPinnableReference()), start); Vector128 <byte> bitmap = _asciiBitmap; do { // Load 32 bytes (16 chars) into two Vector128<short>s (chars) // Drop the high byte of each char // Pack the remaining bytes into a single Vector128<byte> Vector128 <byte> input = Sse2.PackUnsignedSaturate( Unsafe.ReadUnaligned <Vector128 <short> >(ref Unsafe.As <char, byte>(ref textStartRef)), Unsafe.ReadUnaligned <Vector128 <short> >(ref Unsafe.As <char, byte>(ref Unsafe.Add(ref textStartRef, Vector128 <short> .Count)))); // Extract the higher nibble of each character ((input >> 4) & 0xF) Vector128 <byte> higherNibbles = Sse2.And(Sse2.ShiftRightLogical(input.AsUInt16(), 4).AsByte(), Vector128.Create((byte)0xF)); // Lookup the matching higher nibble for each character based on the lower nibble // PSHUFB will set the result to 0 for any non-ASCII (> 127) character Vector128 <byte> bitsets = Ssse3.Shuffle(bitmap, input); // Calculate a bitmask (1 << (higherNibble % 8)) for each character Vector128 <byte> bitmask = Ssse3.Shuffle(Vector128.Create(0x8040201008040201).AsByte(), higherNibbles); // Check which characters are present in the set // We are relying on bitsets being zero for non-ASCII characters Vector128 <byte> result = Sse2.And(bitsets, bitmask); if (!result.Equals(Vector128 <byte> .Zero)) { int resultMask = ~Sse2.MoveMask(Sse2.CompareEqual(result, Vector128 <byte> .Zero)); return(start + BitOperations.TrailingZeroCount((uint)resultMask)); } start += 2 * Vector128 <short> .Count; textStartRef = ref Unsafe.Add(ref textStartRef, 2 * Vector128 <short> .Count); }while (start != finalStart); } } ref char textRef = ref Unsafe.AsRef(in text.GetPinnableReference());
public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); var result = Vector128.Equals(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); }
public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); var result = Vector128.Equals(test._fld1, test._fld2); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); }
public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); var test = new VectorBinaryOpTest__EqualsInt16(); var result = Vector128.Equals(test._fld1, test._fld2); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); }
public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); var op1 = Unsafe.Read <Vector128 <Int16> >(_dataTable.inArray1Ptr); var op2 = Unsafe.Read <Vector128 <Int16> >(_dataTable.inArray2Ptr); var result = Vector128.Equals(op1, op2); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); }
public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); var result = Vector128.Equals( Unsafe.Read <Vector128 <SByte> >(_dataTable.inArray1Ptr), Unsafe.Read <Vector128 <SByte> >(_dataTable.inArray2Ptr) ); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); }
private static unsafe void ReplacePlusWithSpaceCore(Span <char> buffer, IntPtr state) { fixed(char *ptr = &MemoryMarshal.GetReference(buffer)) { var input = (ushort *)state.ToPointer(); var output = (ushort *)ptr; var i = (nint)0; var n = (nint)(uint)buffer.Length; if (Vector256.IsHardwareAccelerated && n >= Vector256 <ushort> .Count) { var vecPlus = Vector256.Create((ushort)'+'); var vecSpace = Vector256.Create((ushort)' '); do { var vec = Vector256.Load(input + i); var mask = Vector256.Equals(vec, vecPlus); var res = Vector256.ConditionalSelect(mask, vecSpace, vec); res.Store(output + i); i += Vector256 <ushort> .Count; } while (i <= n - Vector256 <ushort> .Count); } if (Vector128.IsHardwareAccelerated && n - i >= Vector128 <ushort> .Count) { var vecPlus = Vector128.Create((ushort)'+'); var vecSpace = Vector128.Create((ushort)' '); do { var vec = Vector128.Load(input + i); var mask = Vector128.Equals(vec, vecPlus); var res = Vector128.ConditionalSelect(mask, vecSpace, vec); res.Store(output + i); i += Vector128 <ushort> .Count; } while (i <= n - Vector128 <ushort> .Count); } for (; i < n; ++i) { if (input[i] != '+') { output[i] = input[i]; } else { output[i] = ' '; } } } }
static int Main(string[] args) { bool pass = true; if (Sse2.IsSupported) { Vector128 <byte> src = Vector128.Create((byte)1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); Vector128 <uint> srcAsUInt32 = src.AsUInt32(); Vector128 <uint> result = Sse2.Shuffle(srcAsUInt32, _MM_SHUFFLE(0, 1, 2, 3)); pass = result.Equals(Sse2.Shuffle(srcAsUInt32, (byte)(0 << 6 | 1 << 4 | 2 << 2 | 3))); } return(pass ? 100 : 0); }
public int Solve() { var stepCount = 0; while (true) { stepCount++; Step(); if (Positions.Equals(referencePos) && Velocities.Equals(referenceVel)) { return(stepCount); } } }
static bool VerifyExpectedVtor(Vector128 <int> a) => a.Equals(Vector128.Create(4));
public override bool Equals(Vector128 <int> x, Vector128 <int> y) { return(x.Equals(y)); }