public void RunClsVarScenario_Load()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));

            fixed(Vector128 <Int16> *pClsVar1 = &_clsVar1)
            fixed(Vector128 <Int16> *pClsVar2 = &_clsVar2)
            {
                var result = AdvSimd.CompareEqual(
                    AdvSimd.LoadVector128((Int16 *)(pClsVar1)),
                    AdvSimd.LoadVector128((Int16 *)(pClsVar2))
                    );

                Unsafe.Write(_dataTable.outArrayPtr, result);
                ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
            }
        }
Пример #2
0
        public void RunClassFldScenario_Load()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));

            fixed(Vector64 <Int32> *pFld1 = &_fld1)
            fixed(Vector64 <Int32> *pFld2 = &_fld2)
            {
                var result = AdvSimd.CompareEqual(
                    AdvSimd.LoadVector64((Int32 *)(pFld1)),
                    AdvSimd.LoadVector64((Int32 *)(pFld2))
                    );

                Unsafe.Write(_dataTable.outArrayPtr, result);
                ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
            }
        }
Пример #3
0
        public static Vector128 <sbyte> CreateEscapingMask_DefaultJavaScriptEncoderBasicLatin(Vector128 <sbyte> sourceValue)
        {
            if (!AdvSimd.Arm64.IsSupported)
            {
                throw new PlatformNotSupportedException();
            }

            Vector128 <sbyte> mask = CreateEscapingMask_UnsafeRelaxedJavaScriptEncoder(sourceValue);

            mask = AdvSimd.Or(mask, AdvSimd.CompareEqual(sourceValue, s_ampersandMaskSByte));
            mask = AdvSimd.Or(mask, AdvSimd.CompareEqual(sourceValue, s_apostropheMaskSByte));
            mask = AdvSimd.Or(mask, AdvSimd.CompareEqual(sourceValue, s_plusSignMaskSByte));
            mask = AdvSimd.Or(mask, AdvSimd.CompareEqual(sourceValue, s_lessThanSignMaskSByte));
            mask = AdvSimd.Or(mask, AdvSimd.CompareEqual(sourceValue, s_greaterThanSignMaskSByte));
            mask = AdvSimd.Or(mask, AdvSimd.CompareEqual(sourceValue, s_graveAccentMaskSByte));

            return(mask);
        }
Пример #4
0
        public void RunClassLclFldScenario_Load()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));

            var test = new SimpleBinaryOpTest__CompareEqual_Vector128_Single();

            fixed(Vector128 <Single> *pFld1 = &test._fld1)
            fixed(Vector128 <Single> *pFld2 = &test._fld2)
            {
                var result = AdvSimd.CompareEqual(
                    AdvSimd.LoadVector128((Single *)(pFld1)),
                    AdvSimd.LoadVector128((Single *)(pFld2))
                    );

                Unsafe.Write(_dataTable.outArrayPtr, result);
                ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
            }
        }
Пример #5
0
        public static Vector128 <sbyte> CreateEscapingMask_UnsafeRelaxedJavaScriptEncoder(Vector128 <sbyte> sourceValue)
        {
            if (!AdvSimd.Arm64.IsSupported)
            {
                throw new PlatformNotSupportedException();
            }

            // Anything in the control characters range (except 0x7F), and anything above sbyte.MaxValue but less than or equal byte.MaxValue
            // That's because anything between 128 and 255 (inclusive) will overflow and become negative.
            Vector128 <sbyte> mask = AdvSimd.CompareLessThan(sourceValue, s_spaceMaskSByte);

            mask = AdvSimd.Or(mask, AdvSimd.CompareEqual(sourceValue, s_quotationMarkMaskSByte));
            mask = AdvSimd.Or(mask, AdvSimd.CompareEqual(sourceValue, s_reverseSolidusMaskSByte));

            // Leftover control character in the ASCII range - 0x7F
            // Since we are dealing with sbytes, 0x7F is the only value that would meet this comparison.
            mask = AdvSimd.Or(mask, AdvSimd.CompareGreaterThan(sourceValue, s_tildeMaskSByte));

            return(mask);
        }
Пример #6
0
        public static Vector128 <short> CreateEscapingMask_UnsafeRelaxedJavaScriptEncoder(Vector128 <short> sourceValue)
        {
            if (!AdvSimd.Arm64.IsSupported)
            {
                throw new PlatformNotSupportedException();
            }

            // Anything in the control characters range, and anything above short.MaxValue but less than or equal char.MaxValue
            // That's because anything between 32768 and 65535 (inclusive) will overflow and become negative.
            Vector128 <short> mask = AdvSimd.CompareLessThan(sourceValue, s_spaceMaskInt16);

            mask = AdvSimd.Or(mask, AdvSimd.CompareEqual(sourceValue, s_quotationMarkMaskInt16));
            mask = AdvSimd.Or(mask, AdvSimd.CompareEqual(sourceValue, s_reverseSolidusMaskInt16));

            // Anything above the ASCII range, and also including the leftover control character in the ASCII range - 0x7F
            // When this method is called with only ASCII data, 0x7F is the only value that would meet this comparison.
            // However, when called from "Default", the source could contain characters outside the ASCII range.
            mask = AdvSimd.Or(mask, AdvSimd.CompareGreaterThan(sourceValue, s_tildeMaskInt16));

            return(mask);
        }
Пример #7
0
    static Vector128 <float> AdvSimd_CompareEqual_Vector128_Single_CreateZeroZeroZeroZero_AsVariableLoop(Vector128 <float> left)
    {
        Vector128 <float> result = default;
        var asVar = Vector128.Create(0f, 0f, 0f, 0f);

        for (var i = 0; i < 4; i++)
        {
            result = AdvSimd.CompareEqual(left, asVar);
            result = AdvSimd.CompareEqual(left, asVar);
            result = AdvSimd.CompareEqual(left, asVar);
            result = AdvSimd.CompareEqual(left, asVar);
            for (var j = 0; j < 4; j++)
            {
                result = AdvSimd.CompareEqual(left, asVar);
                result = AdvSimd.CompareEqual(left, asVar);
                result = AdvSimd.CompareEqual(left, asVar);
                result = AdvSimd.CompareEqual(left, asVar);
            }
        }
        return(result);
    }
Пример #8
0
 static Vector64 <float> AdvSimd_CompareEqual_Vector64_Single_CreateZeroZero(Vector64 <float> left)
 {
     return(AdvSimd.CompareEqual(left, Vector64.Create(0f, 0f)));
 }
Пример #9
0
 static Vector128 <float> AdvSimd_CompareEqual_Vector128_Single_Zero(Vector128 <float> left)
 {
     return(AdvSimd.CompareEqual(left, Vector128 <float> .Zero));
 }
Пример #10
0
 static Vector128 <int> AdvSimd_CompareEqual_Vector128_Int32_Zero(Vector128 <int> left)
 {
     return(AdvSimd.CompareEqual(left, Vector128 <int> .Zero));
 }
Пример #11
0
 static Vector128 <ushort> AdvSimd_CompareEqual_Vector128_UInt16_Zero(Vector128 <ushort> left)
 {
     return(AdvSimd.CompareEqual(left, Vector128 <ushort> .Zero));
 }
Пример #12
0
 static Vector128 <sbyte> AdvSimd_CompareEqual_Vector128_SByte_Zero(Vector128 <sbyte> left)
 {
     return(AdvSimd.CompareEqual(left, Vector128 <sbyte> .Zero));
 }
Пример #13
0
 static Vector128 <float> AdvSimd_CompareEqual_Vector128_Single_Zero_Swapped(Vector128 <float> right)
 {
     return(AdvSimd.CompareEqual(Vector128 <float> .Zero, right));
 }
Пример #14
0
 static Vector128 <int> AdvSimd_CompareEqual_Vector128_Int32_Zero_Swapped(Vector128 <int> right)
 {
     return(AdvSimd.CompareEqual(Vector128 <int> .Zero, right));
 }
Пример #15
0
 static Vector128 <ushort> AdvSimd_CompareEqual_Vector128_UInt16_Zero_Swapped(Vector128 <ushort> right)
 {
     return(AdvSimd.CompareEqual(Vector128 <ushort> .Zero, right));
 }
Пример #16
0
 static Vector128 <sbyte> AdvSimd_CompareEqual_Vector128_SByte_Zero_Swapped(Vector128 <sbyte> right)
 {
     return(AdvSimd.CompareEqual(Vector128 <sbyte> .Zero, right));
 }
Пример #17
0
 static Vector128 <int> AdvSimd_CompareEqual_Vector128_Int32_CreateZero(Vector128 <int> left)
 {
     return(AdvSimd.CompareEqual(left, Vector128.Create(0)));
 }
Пример #18
0
 static Vector64 <int> AdvSimd_CompareEqual_Vector64_Int32_CreateZeroZero(Vector64 <int> left)
 {
     return(AdvSimd.CompareEqual(left, Vector64.Create(0, 0)));
 }
Пример #19
0
    static Vector128 <float> AdvSimd_CompareEqual_Vector128_Single_CreateZeroZeroZeroZero_AsVariable(Vector128 <float> left)
    {
        var asVar = Vector128.Create(0f, 0f, 0f, 0f);

        return(AdvSimd.CompareEqual(left, asVar));
    }