Exemple #1
0
        public void RunLclVarScenario_LoadAligned()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned));

            var left  = Avx.LoadAlignedVector128((Double *)(_dataTable.inArray1Ptr));
            var right = Avx.LoadAlignedVector128((Double *)(_dataTable.inArray2Ptr));

            Avx.MaskStore((Double *)_dataTable.outArrayPtr, left, right);

            ValidateResult(left, right, _dataTable.outArrayPtr);
        }
Exemple #2
0
        public void RunLclVarScenario_LoadAligned()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned));

            var op1    = Avx.LoadAlignedVector128((Single *)(_dataTable.inArray1Ptr));
            var op2    = Avx.LoadAlignedVector128((Int32 *)(_dataTable.inArray2Ptr));
            var result = Avx.PermuteVar(op1, op2);

            Unsafe.Write(_dataTable.outArrayPtr, result);
            ValidateResult(op1, op2, _dataTable.outArrayPtr);
        }
        public void RunLclVarScenario_LoadAligned()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned));

            var left   = Avx.LoadAlignedVector256((Int16 *)(_dataTable.inArray1Ptr));
            var right  = Avx.LoadAlignedVector128((Int16 *)(_dataTable.inArray2Ptr));
            var result = Avx.InsertVector128(left, right, 1);

            Unsafe.Write(_dataTable.outArrayPtr, result);
            ValidateResult(left, right, _dataTable.outArrayPtr);
        }
Exemple #4
0
        public void RunBasicScenario_LoadAligned()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));

            Avx.MaskStore(
                (Double *)_dataTable.outArrayPtr,
                Avx.LoadAlignedVector128((Double *)(_dataTable.inArray1Ptr)),
                Avx.LoadAlignedVector128((Double *)(_dataTable.inArray2Ptr))
                );

            ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
        }
Exemple #5
0
        public void RunBasicScenario_LoadAligned()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));

            var result = Avx.PermuteVar(
                Avx.LoadAlignedVector128((Double *)(_dataTable.inArray1Ptr)),
                Avx.LoadAlignedVector128((Int64 *)(_dataTable.inArray2Ptr))
                );

            Unsafe.Write(_dataTable.outArrayPtr, result);
            ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
        }
Exemple #6
0
        public void RunLclVarScenario_LoadAligned()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned));

            var first  = Avx.LoadAlignedVector128((Int32 *)(_dataTable.inArray0Ptr));
            var second = Avx.LoadAlignedVector128((Byte *)(_dataTable.inArray1Ptr));
            var third  = Avx.LoadAlignedVector128((SByte *)(_dataTable.inArray2Ptr));
            var result = AvxVnni.MultiplyWideningAndAdd(first, second, third);

            Unsafe.Write(_dataTable.outArrayPtr, result);
            ValidateResult(first, second, third, _dataTable.outArrayPtr);
        }
Exemple #7
0
        public void RunReflectionScenario_LoadAligned()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));

            typeof(Avx).GetMethod(nameof(Avx.MaskStore), new Type[] { typeof(Double *), typeof(Vector128 <Double>), typeof(Vector128 <Double>) })
            .Invoke(null, new object[] {
                Pointer.Box(_dataTable.outArrayPtr, typeof(Double *)),
                Avx.LoadAlignedVector128((Double *)(_dataTable.inArray1Ptr)),
                Avx.LoadAlignedVector128((Double *)(_dataTable.inArray2Ptr))
            });

            ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
        }
Exemple #8
0
        public void RunReflectionScenario_LoadAligned()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));

            var result = typeof(Avx).GetMethod(nameof(Avx.PermuteVar), new Type[] { typeof(Vector128 <Double>), typeof(Vector128 <Int64>) })
                         .Invoke(null, new object[] {
                Avx.LoadAlignedVector128((Double *)(_dataTable.inArray1Ptr)),
                Avx.LoadAlignedVector128((Int64 *)(_dataTable.inArray2Ptr))
            });

            Unsafe.Write(_dataTable.outArrayPtr, (Vector128 <Double>)(result));
            ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
        }
Exemple #9
0
        public void RunBasicScenario_LoadAligned()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));

            var result = Avx.InsertVector128(
                Avx.LoadAlignedVector256((Byte *)(_dataTable.inArray1Ptr)),
                Avx.LoadAlignedVector128((Byte *)(_dataTable.inArray2Ptr)),
                1
                );

            Unsafe.Write(_dataTable.outArrayPtr, result);
            ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
        }
Exemple #10
0
        public void RunBasicScenario_LoadAligned()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));

            var result = AvxVnni.MultiplyWideningAndAdd(
                Avx.LoadAlignedVector128((Int32 *)(_dataTable.inArray0Ptr)),
                Avx.LoadAlignedVector128((Byte *)(_dataTable.inArray1Ptr)),
                Avx.LoadAlignedVector128((SByte *)(_dataTable.inArray2Ptr))
                );

            Unsafe.Write(_dataTable.outArrayPtr, result);
            ValidateResult(_dataTable.inArray0Ptr, _dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
        }
Exemple #11
0
        public void RunReflectionScenario_LoadAligned()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));

            var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256 <Byte>), typeof(Vector128 <Byte>), typeof(byte) })
                         .Invoke(null, new object[] {
                Avx.LoadAlignedVector256((Byte *)(_dataTable.inArray1Ptr)),
                Avx.LoadAlignedVector128((Byte *)(_dataTable.inArray2Ptr)),
                (byte)1
            });

            Unsafe.Write(_dataTable.outArrayPtr, (Vector256 <Byte>)(result));
            ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
        }
Exemple #12
0
        public void RunReflectionScenario_LoadAligned()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));

            var result = typeof(AvxVnni).GetMethod(nameof(AvxVnni.MultiplyWideningAndAdd), new Type[] { typeof(Vector128 <Int32>), typeof(Vector128 <Byte>), typeof(Vector128 <SByte>) })
                         .Invoke(null, new object[] {
                Avx.LoadAlignedVector128((Int32 *)(_dataTable.inArray0Ptr)),
                Avx.LoadAlignedVector128((Byte *)(_dataTable.inArray1Ptr)),
                Avx.LoadAlignedVector128((SByte *)(_dataTable.inArray2Ptr))
            });

            Unsafe.Write(_dataTable.outArrayPtr, (Vector128 <Int32>)(result));
            ValidateResult(_dataTable.inArray0Ptr, _dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
        }