tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int32.22.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 /******************************************************************************
   6  * This file is auto-generated from a template file by the GenerateTests.csx  *
   7  * script in tests\src\JIT\HardwareIntrinsics\X86\Shared. In order to make    *
   8  * changes, please update the corresponding template and run according to the *
   9  * directions listed in the file.                                             *
  10  ******************************************************************************/
  11
  12 using System;
  13 using System.Runtime.CompilerServices;
  14 using System.Runtime.InteropServices;
  15 using System.Runtime.Intrinsics;
  16 using System.Runtime.Intrinsics.X86;
  17
  18 namespace JIT.HardwareIntrinsics.X86
  19 {
  20     public static partial class Program
  21     {
  22         private static void ExtractInt3222()
  23         {
  24             var test = new SimpleUnaryOpTest__ExtractInt3222();
  25
  26             if (test.IsSupported)
  27             {
  28                 // Validates basic functionality works, using Unsafe.Read
  29                 test.RunBasicScenario_UnsafeRead();
  30
  31                 if (Avx.IsSupported)
  32                 {
  33                     // Validates basic functionality works, using Load
  34                     test.RunBasicScenario_Load();
  35
  36                     // Validates basic functionality works, using LoadAligned
  37                     test.RunBasicScenario_LoadAligned();
  38                 }
  39
  40                 // Validates calling via reflection works, using Unsafe.Read
  41                 test.RunReflectionScenario_UnsafeRead();
  42
  43                 if (Avx.IsSupported)
  44                 {
  45                     // Validates calling via reflection works, using Load
  46                     test.RunReflectionScenario_Load();
  47
  48                     // Validates calling via reflection works, using LoadAligned
  49                     test.RunReflectionScenario_LoadAligned();
  50                 }
  51
  52                 // Validates passing a static member works
  53                 test.RunClsVarScenario();
  54
  55                 // Validates passing a local works, using Unsafe.Read
  56                 test.RunLclVarScenario_UnsafeRead();
  57
  58                 if (Avx.IsSupported)
  59                 {
  60                     // Validates passing a local works, using Load
  61                     test.RunLclVarScenario_Load();
  62
  63                     // Validates passing a local works, using LoadAligned
  64                     test.RunLclVarScenario_LoadAligned();
  65                 }
  66
  67                 // Validates passing the field of a local works
  68                 test.RunLclFldScenario();
  69
  70                 // Validates passing an instance member works
  71                 test.RunFldScenario();
  72             }
  73             else
  74             {
  75                 // Validates we throw on unsupported hardware
  76                 test.RunUnsupportedScenario();
  77             }
  78
  79             if (!test.Succeeded)
  80             {
  81                 throw new Exception("One or more scenarios did not complete as expected.");
  82             }
  83         }
  84     }
  85
  86     public sealed unsafe class SimpleUnaryOpTest__ExtractInt3222
  87     {
  88         private static readonly int LargestVectorSize = 32;
  89
  90         private static readonly int Op1ElementCount = Unsafe.SizeOf<Vector256<Int32>>() / sizeof(Int32);
  91         private static readonly int RetElementCount = Unsafe.SizeOf<Vector256<Int32>>() / sizeof(Int32);
  92
  93         private static Int32[] _data = new Int32[Op1ElementCount];
  94
  95         private static Vector256<Int32> _clsVar;
  96
  97         private Vector256<Int32> _fld;
  98
  99         private SimpleUnaryOpTest__DataTable<Int32, Int32> _dataTable;
 100
 101         static SimpleUnaryOpTest__ExtractInt3222()
 102         {
 103             var random = new Random();
 104
 105             for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (int)(random.Next(0, int.MaxValue)); }
 106             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector256<Int32>, byte>(ref _clsVar), ref Unsafe.As<Int32, byte>(ref _data[0]), (uint)Unsafe.SizeOf<Vector256<Int32>>());
 107         }
 108
 109         public SimpleUnaryOpTest__ExtractInt3222()
 110         {
 111             Succeeded = true;
 112
 113             var random = new Random();
 114
 115             for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (int)(random.Next(0, int.MaxValue)); }
 116             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector256<Int32>, byte>(ref _fld), ref Unsafe.As<Int32, byte>(ref _data[0]), (uint)Unsafe.SizeOf<Vector256<Int32>>());
 117
 118             for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (int)(random.Next(0, int.MaxValue)); }
 119             _dataTable = new SimpleUnaryOpTest__DataTable<Int32, Int32>(_data, new Int32[RetElementCount], LargestVectorSize);
 120         }
 121
 122         public bool IsSupported => Avx.IsSupported && (Environment.Is64BitProcess || ((typeof(Int32) != typeof(long)) && (typeof(Int32) != typeof(ulong))));
 123
 124         public bool Succeeded { get; set; }
 125
 126         public void RunBasicScenario_UnsafeRead()
 127         {
 128             var result = Avx.Extract(
 129                 Unsafe.Read<Vector256<Int32>>(_dataTable.inArrayPtr),
 130                 22
 131             );
 132
 133             Unsafe.Write(_dataTable.outArrayPtr, result);
 134             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
 135         }
 136
 137         public void RunBasicScenario_Load()
 138         {
 139             var result = Avx.Extract(
 140                 Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)),
 141                 22
 142             );
 143
 144             Unsafe.Write(_dataTable.outArrayPtr, result);
 145             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
 146         }
 147
 148         public void RunBasicScenario_LoadAligned()
 149         {
 150             var result = Avx.Extract(
 151                 Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)),
 152                 22
 153             );
 154
 155             Unsafe.Write(_dataTable.outArrayPtr, result);
 156             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
 157         }
 158
 159         public void RunReflectionScenario_UnsafeRead()
 160         {
 161             var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256<Int32>), typeof(byte) })
 162                                      .Invoke(null, new object[] {
 163                                         Unsafe.Read<Vector256<Int32>>(_dataTable.inArrayPtr),
 164                                         (byte)22
 165                                      });
 166
 167             Unsafe.Write(_dataTable.outArrayPtr, (Int32)(result));
 168             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
 169         }
 170
 171         public void RunReflectionScenario_Load()
 172         {
 173             var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256<Int32>), typeof(byte) })
 174                                      .Invoke(null, new object[] {
 175                                         Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)),
 176                                         (byte)22
 177                                      });
 178
 179             Unsafe.Write(_dataTable.outArrayPtr, (Int32)(result));
 180             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
 181         }
 182
 183         public void RunReflectionScenario_LoadAligned()
 184         {
 185             var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256<Int32>), typeof(byte) })
 186                                      .Invoke(null, new object[] {
 187                                         Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)),
 188                                         (byte)22
 189                                      });
 190
 191             Unsafe.Write(_dataTable.outArrayPtr, (Int32)(result));
 192             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
 193         }
 194
 195         public void RunClsVarScenario()
 196         {
 197             var result = Avx.Extract(
 198                 _clsVar,
 199                 22
 200             );
 201
 202             Unsafe.Write(_dataTable.outArrayPtr, result);
 203             ValidateResult(_clsVar, _dataTable.outArrayPtr);
 204         }
 205
 206         public void RunLclVarScenario_UnsafeRead()
 207         {
 208             var firstOp = Unsafe.Read<Vector256<Int32>>(_dataTable.inArrayPtr);
 209             var result = Avx.Extract(firstOp, 22);
 210
 211             Unsafe.Write(_dataTable.outArrayPtr, result);
 212             ValidateResult(firstOp, _dataTable.outArrayPtr);
 213         }
 214
 215         public void RunLclVarScenario_Load()
 216         {
 217             var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr));
 218             var result = Avx.Extract(firstOp, 22);
 219
 220             Unsafe.Write(_dataTable.outArrayPtr, result);
 221             ValidateResult(firstOp, _dataTable.outArrayPtr);
 222         }
 223
 224         public void RunLclVarScenario_LoadAligned()
 225         {
 226             var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr));
 227             var result = Avx.Extract(firstOp, 22);
 228
 229             Unsafe.Write(_dataTable.outArrayPtr, result);
 230             ValidateResult(firstOp, _dataTable.outArrayPtr);
 231         }
 232
 233         public void RunLclFldScenario()
 234         {
 235             var test = new SimpleUnaryOpTest__ExtractInt3222();
 236             var result = Avx.Extract(test._fld, 22);
 237
 238             Unsafe.Write(_dataTable.outArrayPtr, result);
 239             ValidateResult(test._fld, _dataTable.outArrayPtr);
 240         }
 241
 242         public void RunFldScenario()
 243         {
 244             var result = Avx.Extract(_fld, 22);
 245
 246             Unsafe.Write(_dataTable.outArrayPtr, result);
 247             ValidateResult(_fld, _dataTable.outArrayPtr);
 248         }
 249
 250         public void RunUnsupportedScenario()
 251         {
 252             Succeeded = false;
 253
 254             try
 255             {
 256                 RunBasicScenario_UnsafeRead();
 257             }
 258             catch (PlatformNotSupportedException)
 259             {
 260                 Succeeded = true;
 261             }
 262         }
 263
 264         private void ValidateResult(Vector256<Int32> firstOp, void* result, [CallerMemberName] string method = "")
 265         {
 266             Int32[] inArray = new Int32[Op1ElementCount];
 267             Int32[] outArray = new Int32[RetElementCount];
 268
 269             Unsafe.WriteUnaligned(ref Unsafe.As<Int32, byte>(ref inArray[0]), firstOp);
 270             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector256<Int32>>());
 271
 272             ValidateResult(inArray, outArray, method);
 273         }
 274
 275         private void ValidateResult(void* firstOp, void* result, [CallerMemberName] string method = "")
 276         {
 277             Int32[] inArray = new Int32[Op1ElementCount];
 278             Int32[] outArray = new Int32[RetElementCount];
 279
 280             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(firstOp), (uint)Unsafe.SizeOf<Vector256<Int32>>());
 281             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector256<Int32>>());
 282
 283             ValidateResult(inArray, outArray, method);
 284         }
 285
 286         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
 287         {
 288             if ((result[0] != firstOp[6]))
 289             {
 290                 Succeeded = false;
 291             }
 292
 293             if (!Succeeded)
 294             {
 295                 Console.WriteLine($"{nameof(Avx)}.{nameof(Avx.Extract)}<Int32>(Vector256<Int32><9>): {method} failed:");
 296                 Console.WriteLine($"  firstOp: ({string.Join(", ", firstOp)})");
 297                 Console.WriteLine($"   result: ({string.Join(", ", result)})");
 298                 Console.WriteLine();
 299             }
 300         }
 301     }
 302 }